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 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 nécessitant d'extraire des données à partir des serveurs de Google ou d'un serveur externe, comme les requêtes envoyées à Sheets, Docs, Sites, Translate, UrlFetch, etc. Vos scripts s'exécuteront plus rapidement si vous parvenez à réduire 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 lots
Les scripts doivent généralement lire des données à partir d'une feuille de calcul, effectuer des calculs, puis écrire les résultats des données dans une feuille de calcul. Google Apps Script propose déjà certaines optimisations intégrées, comme l'utilisation du cache d'anticipation pour récupérer ce qu'un script est susceptible d'obtenir et le cache d'écriture pour enregistrer ce qui est susceptible d'être défini.
Vous pouvez écrire des scripts pour exploiter au maximum 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.
Voici un exemple que vous ne devez 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 effectue une boucle sur 100 lignes et 100 colonnes, en écrivant consécutivement dans 10 000 cellules. Le cache de réécriture Google Apps Script est utile, car il force une réécriture à l'aide d'un vidage à la fin de chaque ligne. En raison 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 une réécriture dans laquelle la plage de cellules est lue dans un tableau appelé "couleurs", l'opération d'attribution des couleurs 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 axés sur l'UI
Les bibliothèques sont un moyen pratique de réutiliser du code, mais elles augmentent légèrement le temps de démarrage du script. Ce délai n'est pas perceptible pour les scripts relativement longs (comme un script utilitaire pour nettoyer vos fichiers Google Drive), mais pour les interfaces utilisateur Service HTML côté client qui effectuent des appels google.script.run répétés et de courte durée, le délai affecte chaque appel. 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 autres que les modules 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 des ressources entre les exécutions de script. En mettant en cache les données, vous pouvez réduire le nombre de fois ou la fréquence à laquelle vous devez les extraire. 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. 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;
}
Vous devrez toujours attendre 20 secondes si l'élément n'est 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.