En este documento, se enumeran las prácticas recomendadas para mejorar el rendimiento de las secuencias de comandos.
Minimiza las llamadas a otros servicios
Usar operaciones de JavaScript en tu secuencia de comandos es más rápido que llamar a otros servicios. Todo lo que logres dentro de Google Apps Script es más rápido que recuperar datos de los servidores de Google o de un servidor externo, como las solicitudes a Hojas de cálculo, Documentos, Sites, Translate y UrlFetch. Tus secuencias de comandos se ejecutarán más rápido si minimizas las llamadas de servicio.
Colabora con unidades compartidas
Si trabajas en un proyecto de secuencias de comandos con otros desarrolladores, colabora con unidades compartidas. Los archivos de una unidad compartida son propiedad del grupo, no de personas específicas, lo que facilita el desarrollo y el mantenimiento de los proyectos.
Usa operaciones por lotes
Por lo general, las secuencias de comandos leen datos de una hoja de cálculo, realizan cálculos y vuelven a escribir los resultados. Apps Script usa optimizaciones integradas, como la caché de escritura y la anticipación.
Maximiza el almacenamiento en caché integrado minimizando las lecturas y escrituras. Alternar los comandos de lectura y escritura es lento. Para acelerar una secuencia de comandos, lee todos los datos en un array con un solo comando, realiza operaciones en los datos del array y escribe los datos con un solo comando.
Evita alternar lecturas y escrituras, como se muestra en este ejemplo ineficiente:
// 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();
}
La secuencia de comandos es ineficiente porque itera 10,000 celdas con escrituras consecutivas. Si bien la caché de escritura diferida ayuda, agrupar las llamadas es mucho más eficiente:
// 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);
El código ineficiente tarda alrededor de 70 segundos en ejecutarse, mientras que el código eficiente se ejecuta en solo 1 segundo.
Evita las bibliotecas en las secuencias de comandos con mucha IU
Las bibliotecas son convenientes para reutilizar código, pero aumentan el tiempo de inicio de la secuencia de comandos. Este retraso se nota en las interfaces de usuario de HTML Service del cliente que realizan llamadas google.script.run repetidas y de corta duración. Usa las bibliotecas con moderación en los complementos y evítalas en las secuencias de comandos que realizan muchas llamadas a google.script.run.
Usa el servicio de caché
Usa el servicio de caché para almacenar en caché los recursos entre las ejecuciones de la secuencia de comandos. El almacenamiento en caché reduce la frecuencia de recuperación de datos. En el siguiente ejemplo, se muestra cómo usar el servicio de caché para acelerar el acceso a un feed RSS lento.
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;
}
Si bien sigues esperando 20 segundos si el elemento no está en la caché, los accesos posteriores son rápidos hasta que vence el elemento.