Bonnes pratiques

Ce document répertorie les bonnes pratiques pour améliorer les performances des scripts.

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

L'utilisation d'opérations JavaScript dans votre script est plus rapide que l'appel d'autres services. Tout ce que vous effectuez dans Google Apps Script lui-même est plus rapide que la récupération de données à partir des serveurs de Google ou d'un serveur externe, comme les requêtes adressées à Sheets, Docs, Sites, Sites, Traduction et UrlFetch. Vos scripts s'exécuteront plus rapidement si vous réduisez le nombre d'appels de service.

Collaborer avec des Drive partagés

Si vous travaillez sur un projet de script avec d'autres développeurs, collaborez à l'aide de Drive partagés. Les fichiers d'un Drive partagé appartiennent au groupe plutôt qu'à des personnes, ce qui facilite le développement et la maintenance du projet.

Utiliser des opérations par lot

Les scripts lisent généralement des données à partir d'une feuille de calcul, effectuent des calculs et réécrivent les résultats. Apps Script utilise une optimisation intégrée, comme la prélecture et la mise en cache des écritures.

Maximisez la mise en cache intégrée en réduisant 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 avec une seule commande, effectuez des opérations sur les données du tableau et écrivez les données avec une seule commande.

Évitez d'alterner les lectures et les écritures, comme illustré dans cet exemple inefficace :

// 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,car il effectue une boucle sur 10 000 cellules avec des écritures consécutives. Bien que le cache de réécriture soit utile, le traitement par lot des appels est beaucoup plus efficace :

// 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, tandis que celle du code efficace ne prend qu'une seconde.

Éviter les bibliothèques dans les scripts qui utilisent beaucoup d'interface utilisateur

Les bibliothèques sont pratiques pour réutiliser du code, mais elles augmentent le temps de démarrage des scripts. Ce délai est perceptible dans les interfaces utilisateur HTML Service côté client qui effectuent des appels de courte durée google.script.run répétés. Utilisez les bibliothèques avec parcimonie dans les modules complémentaires et évitez-les dans les scripts qui effectuent de nombreux appels google.script.run.

Utiliser le service de cache

Utilisez le service de cache pour mettre en cache les ressources entre les exécutions de script. La mise en cache réduit la fréquence de récupération des données. L'exemple suivant montre comment utiliser le service de cache pour accélérer l'accès à un flux RSS lent.

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;
}

Même si vous attendez toujours 20 secondes si l'élément ne se trouve pas dans le cache, les accès suivants sont rapides jusqu'à l'expiration de l'élément.

Grands ensembles de données et calculs complexes

Google Sheets est un outil puissant, mais à mesure que les ensembles de données augmentent et que les calculs deviennent plus complexes, vous pouvez rencontrer des problèmes de performances tels que des retards dans les feuilles de calcul, des erreurs IMPORTRANGE et des délais avant expiration des scripts.

Quand utiliser une base de données

Si votre feuille de calcul approche la limite de 10 millions de cellules ou si vous disposez de nombreux formulaires connectés (par exemple, 10 ou plus) et de formules complexes entre les feuilles, envisagez d'utiliser une solution de base de données dédiée.

  • Google Cloud SQL : service de base de données relationnelle entièrement géré pour MySQL, PostgreSQL et SQL Server. Utilisez le service JDBC pour vous connecter à Cloud SQL ou à d'autres bases de données externes telles qu'Oracle ou MongoDB (via des ponts appropriés).
  • BigQuery : entrepôt de données sans serveur et hautement évolutif. Vous pouvez utiliser les feuilles connectées pour analyser de grands ensembles de données BigQuery directement dans Sheets, ou utiliser le service BigQuery pour interagir avec les données à partir d'Apps Script.

Optimisation des performances des formules

Une utilisation intensive de certaines formules peut ralentir votre feuille de calcul :

  • ARRAYFORMULA : bien qu'utiles, les calculs ARRAYFORMULA à grande échelle peuvent être coûteux.
  • VLOOKUP et OFFSET : ces fonctions peuvent être lentes sur de grands ensembles de données. Envisagez d'utiliser INDEX et MATCH ou Apps Script pour effectuer des recherches plus efficacement en mémoire.
  • IMPORTRANGE : une utilisation fréquente de IMPORTRANGE dans de nombreuses feuilles peut entraîner des "erreurs internes" si les feuilles sources sont volumineuses ou fortement chargées. La consolidation des données dans une source centralisée peut être utile.

Gestion des délais avant expiration des scripts

Apps Script est soumis à des limites de temps d'exécution (généralement six minutes par exécution, ou 30 minutes pour certains comptes Google Workspace). Si votre script plante fréquemment, car il dépasse la limite d'exécution :

  1. Utilisez des opérations par lot : comme indiqué dans la section Utiliser des opérations par lot, réduisez le nombre d'appels aux feuilles de calcul et à d'autres services.
  2. Divisez les tâches : divisez les tâches volumineuses en plusieurs parties plus petites qui peuvent chacune être effectuées dans le délai imparti.
  3. Utilisez des déclencheurs pour les continuations : configurez un déclencheur installable basé sur le temps pour reprendre un processus de longue durée. Votre script peut stocker son état actuel (par exemple, l'index de la dernière ligne traitée) à l'aide du service Properties et reprendre à partir de ce point lors de la prochaine exécution.