Bonnes pratiques

Ce document répertorie les bonnes pratiques qui vous aideront à améliorer les performances de vos scripts.

Réduire le nombre d'appels vers d'autres services

L'utilisation d'opérations JavaScript dans votre script est considérablement plus rapide en appelant d'autres services. Ce que vous pouvez faire dans Google Apps Script elle-même sera beaucoup plus rapide que les appels destinés à récupérer des données aux serveurs de Google ou à un serveur externe, par exemple pour envoyer des requêtes à Sheets, Docs, Sites, Translate, UrlFetch, etc. Vos scripts s'exécuteront plus rapidement si vous le pouvez trouver des moyens de minimiser les appels que les scripts effectuent vers ces services.

Envisager de collaborer à l'aide de Drive partagés

Si vous travaillez sur un projet de script avec d'autres développeurs, vous pouvez collaborer sur des projets Apps Script avec des drives partagés. Les fichiers d'un Drive partagé appartiennent au groupe, et non à des individus. Ce facilite le développement et la maintenance du projet.

Utiliser des opérations par lot

Les scripts ont généralement besoin de lire les données d'une feuille de calcul, d'effectuer des calculs, puis écrire les résultats des données dans une feuille de calcul. Google Apps Le script intègre déjà une optimisation, comme l'utilisation de la mise en cache anticipée pour récupérer ce qu'un script est susceptible d'obtenir et écrire la mise en cache pour enregistrer susceptibles d'être définis.

Vous pouvez écrire des scripts pour tirer le meilleur parti de la mise en cache intégrée : ce qui réduit le nombre de lectures et d'écritures. L'alternance des commandes de lecture et d'écriture est lente. Pour accélérer un script, lisez toutes les données dans un tableau en une seule commande, d'effectuer toutes les opérations sur les données du tableau et écrire les données une seule commande.

Voici un exemple que vous ne devez pas suivre ni utiliser. Script utilise le code suivant pour définir les couleurs d'arrière-plan de chaque cellule d'une Grille de feuille de calcul (100 x 100) Il utilise comme fonction nommée getColorFromCoordinates() (non illustré ici) pour déterminer la couleur à utiliser pour chaque cellule:

  // DO NOT USE THIS CODE. It is an example of SLOW, INEFFICIENT code.
  // FOR DEMONSTRATION ONLY
  var cell = sheet.getRange('a1');
  for (var y = 0; y < 100; y++) {
    xcoord = xmin;
    for (var x = 0; x < 100; x++) {
      var c = getColorFromCoordinates(xcoord, ycoord);
      cell.offset(y, x).setBackgroundColor(c);
      xcoord += xincrement;
    }
    ycoord -= yincrement;
    SpreadsheetApp.flush();
  }

Le script est inefficace : il effectue une boucle sur 100 lignes et 100 colonnes, en écrivant consécutivement dans 10 000 cellules. Le cache d'écriture de Google Apps Script car il force une écriture à l'aide d'un vidage à la fin de chaque ligne. En effet, de la mise en cache, il n'y a que 100 appels à la feuille de calcul.

Toutefois, le code peut être beaucoup plus efficace en regroupant les appels. Voici un réécriture qui consiste à lire la plage de cellules dans un tableau appelé "couleurs", la couleur est effectuée sur les données du tableau, et les valeurs dans les tableaux sont écrits dans la feuille de calcul:

  // OKAY TO USE THIS EXAMPLE or code based on it.
  var cell = sheet.getRange('a1');
  var colors = new Array(100);
  for (var y = 0; y < 100; y++) {
    xcoord = xmin;
    colors[y] = new Array(100);
    for (var x = 0; x < 100; x++) {
      colors[y][x] = getColorFromCoordinates(xcoord, ycoord);
      xcoord += xincrement;
    }
    ycoord -= yincrement;
  }
  sheet.getRange(1, 1, 100, 100).setBackgrounds(colors);

L'exécution du code inefficace prend environ 70 secondes. Le code efficace s'exécute dans seulement 1 seconde !

Éviter les bibliothèques dans les scripts gourmands en interface utilisateur

Les bibliothèques sont un moyen pratique de réutiliser du code, mais elles augmentent légèrement le temps nécessaire au démarrage du script. Ce délai n'est pas visible pour les scripts d'une durée relativement longue (comme un script utilitaire pour nettoyer vos fichiers Google Drive), Des interfaces utilisateur de service HTML qui assurent des de courte durée google.script.run le délai s'appliquera à chaque appel. En raison de ce problème, les bibliothèques doivent être utilisés avec parcimonie dans les modules complémentaires, et il peut être judicieux évitez-les dans des scripts autres que des modules complémentaires qui effectuent de nombreux appels google.script.run.

Utiliser le service Cache

Vous pouvez utiliser le service Cache pour mettre en cache les ressources entre les exécutions de script. La mise en cache des données permet de réduire le nombre de fois ou la fréquence à laquelle vous devez récupérer les données. Imaginons que vous disposiez d'un flux RSS sur example.com qui prend 20 secondes à extraire et que vous souhaitiez accélérer l'accès à la requête moyenne. La l'exemple ci-dessous montre comment utiliser le service de cache pour accélérer l'accès à ce données.

  function getRssFeed() {
    var cache = CacheService.getScriptCache();
    var cached = cache.get("rss-feed-contents");
    if (cached != null) {
      return cached;
    }
    // This fetch takes 20 seconds:
    var result = UrlFetchApp.fetch("http://example.com/my-slow-rss-feed.xml");
    var contents = result.getContentText();
    cache.put("rss-feed-contents", contents, 1500); // cache for 25 minutes
    return contents;
  }

Bien que vous deviez attendre 20 secondes si l'élément n'est pas dans le cache, les accès ultérieurs seront très rapides jusqu'à ce que l'élément expire en dehors du cache. en 25 minutes.