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 que d'appeler d'autres services. Tout ce que vous pouvez faire 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 des requêtes vers Sheets, Docs, Sites, Translate, UrlFetch, etc. Vos scripts s'exécuteront plus rapidement si vous trouvez des moyens de réduire les appels qu'ils 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 Drive partagés. Les fichiers d'un Drive partagé appartiennent au groupe, et non à des individus. 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 intègre déjà des fonctionnalités d'optimisation, telles que l'utilisation de la mise en cache anticipée pour récupérer ce qu'un script est susceptible d'obtenir et écrire une mise en cache pour enregistrer ce qui est susceptible d'être défini.
Vous pouvez écrire des scripts pour tirer pleinement parti de 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 à l'aide d'une seule commande, effectuez les opérations sur les données du tableau et écrivez les données à l'aide d'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 100 x 100. Il s'agit d'une fonction nommée getColorFromCoordinates() (non illustré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 boucle, en écrivant de manière consécutive dans 10 000 cellules. Le cache d'écriture de Google Apps Script est utile, car il force une écriture différée en utilisant 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).setBackgroundColors(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 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 retard n'est pas visible pour les scripts relativement longs (par exemple, un script utilitaire permettant de nettoyer vos fichiers Google Drive). Toutefois, pour les interfaces utilisateur de service HTML côté client qui effectuent des appels google.script.run de courte durée répétés, ce 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 les éviter dans les scripts autres que ceux des 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 récupérer les données. Prenons l'exemple d'un flux RSS sur example.com dont l'extraction prend 20 secondes, et où vous souhaitez accélérer l'accès pour une 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;
}
Même si vous devez quand même 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 du cache au bout de 25 minutes.