Ce document liste 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 accomplir dans Google Apps Script est beaucoup plus rapide que d'effectuer des appels qui doivent récupérer des données à partir des serveurs 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 pouvez trouver des moyens de réduire le nombre d'appels qu'ils envoient à ces services.
Envisagez de collaborer via 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 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 ont généralement besoin de lire les données d'une feuille de calcul, d'effectuer des calculs, puis d'écrire les résultats des données dans une feuille de calcul. Google Apps Script propose déjà des optimisations intégrées, telles que l'utilisation de la mise en cache anticipée pour récupérer ce qu'un script est susceptible d'obtenir et l'écriture de mise en cache 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 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 toutes 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 feuille de calcul de 100 x 100. Il utilise la 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 écrivant de manière consécutive dans 10 000 cellules. Le cache d'écriture différée de Google Apps Script est utile, car il force une opération d'écriture différée à l'aide de la suppression à 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 par lot. 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 des scripts gourmands en interface utilisateur
Les bibliothèques constituent un moyen pratique de réutiliser le code, mais elles augmentent légèrement le temps de démarrage du script. Ce retard n'est pas visible pour les scripts relativement longs (comme un script utilitaire servant à nettoyer vos fichiers Google Drive), mais pour les interfaces utilisateur du service HTML côté client qui effectuent des appels google.script.run de courte durée et répétés, le délai affecte chaque appel. Par conséquent, les bibliothèques doivent être utilisées avec parcimonie dans les modules complémentaires et vous pouvez les éviter dans les scripts autres que les modules complémentaires qui effectuent de nombreux appels google.script.run.
Utiliser le service de cache
Vous pouvez utiliser le service de cache pour mettre en cache les ressources entre les exécutions de script. La mise en cache des données vous permet de réduire le nombre de récupérations de données ou la fréquence à laquelle elles sont nécessaires. Prenons l'exemple d'un flux RSS sur example.com dont la récupération prend 20 secondes et que vous souhaitez accélérer l'accès pour 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, bien que vous deviez attendre 20 secondes si l'élément ne se trouve 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.