Ce document liste les bonnes pratiques qui vous aideront à améliorer les performances de vos scripts.
Minimiser les appels à d'autres services
L'utilisation d'opérations JavaScript dans votre script est beaucoup plus rapide que l'appel d'autres services. Tout ce que vous pouvez accomplir dans Google Apps Script lui-même sera beaucoup plus rapide que d'effectuer des appels qui doivent récupérer des données à partir des serveurs de Google ou d'un serveur externe, comme les requêtes vers Sheets, Docs, Sites, Translate, UrlFetch, etc. Vos scripts s'exécuteront plus rapidement si vous trouvez des moyens de minimiser les appels qu'ils effectuent vers ces services.
Envisager de collaborer avec des 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 stockés dans un Drive partagé appartiennent au groupe, et non à des personnes spécifiques. Cela facilite le développement et la maintenance du projet.
Utiliser des opérations par lot
Les scripts doivent généralement lire les données d'une feuille de calcul, effectuer des calculs, puis écrire les résultats des données dans une feuille de calcul. Google Apps Script dispose déjà d'une optimisation intégrée, par exemple en utilisant la mise en cache anticipée pour récupérer ce qu'un script est susceptible d'obtenir et la mise en cache en écriture pour enregistrer ce qui est susceptible d'être défini.
Vous pouvez écrire des scripts pour tirer le meilleur parti de la mise en cache intégrée en minimisant 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 toutes les opérations sur les données du tableau et écrivez les données avec une seule commande.
Voici un exemple à ne pas suivre ni utiliser. Un script utilise le code suivant pour définir les couleurs d'arrière-plan de chaque cellule d'une grille de feuille de calcul de 100 x 100. Il utilise une fonction nommée getColorFromCoordinates() (non affichée 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 parcourt 100 lignes et 100 colonnes, en écrivant consécutivement dans 10 000 cellules. Le cache d'écriture différée Google Apps Script est utile, car il force une écriture différée à l'aide de la vidange à la fin de chaque ligne. Grâce à la mise en cache, il n'y a que 100 appels à la feuille de calcul.
Toutefois, le code peut être rendu beaucoup plus efficace en regroupant les appels par lot. Voici une réécriture dans laquelle la plage de cellules est lue dans un tableau appelé "colors", l'opération d'attribution de couleur est effectuée sur les données du tableau et les valeurs du tableau sont écrites 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 en seulement une seconde !
Éviter les bibliothèques dans les scripts à forte utilisation d'UI
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 perceptible pour les scripts relativement longs (comme un script utilitaire permettant de nettoyer vos fichiers Google Drive), mais il affecte chaque appel pour les interfaces utilisateur HTML Service côté client qui effectuent des appels google.script.run répétés et de courte durée. En raison de ce problème, les bibliothèques doivent être utilisées avec parcimonie dans les modules complémentaires. Vous pouvez également les éviter dans les scripts non complémentaires qui effectuent de nombreux appels google.script.run.
Utiliser le service Cache
Vous pouvez utiliser le service de cache pour mettre en cache les ressources entre les exécutions de script. En mettant les données en cache, vous pouvez réduire le nombre de fois ou la fréquence à laquelle vous devez les récupérer. Prenons l'exemple d'un flux RSS sur example.com qui met 20 secondes à être récupéré et que vous souhaitez accélérer l'accès à la requête moyenne. L'exemple ci-dessous montre comment utiliser le service de cache pour accélérer l'accès à ces 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;
}
Désormais, vous devrez toujours attendre 20 secondes si l'élément ne se trouve pas dans le cache, mais les accès suivants seront très rapides jusqu'à ce que l'élément expire du cache au bout de 25 minutes.