En este documento, se enumeran las prácticas recomendadas para mejorar el rendimiento de tus secuencias de comandos.
Minimiza las llamadas a otros servicios
El uso de operaciones de JavaScript en tu secuencia de comandos es considerablemente más rápido que llamando a otros servicios. Todo lo que puedas lograr con Google Apps Script puede ser mucho más rápido que realizar llamadas que necesitan los servidores de Google o un servidor externo, como las solicitudes a Hojas de cálculo, Documentos, Sites, Translate, UrlFetch, etcétera. Tus secuencias de comandos se ejecutarán más rápido si puedes encontrar formas de minimizar las llamadas que realizan las secuencias de comandos a esos servicios.
Considera colaborar con unidades compartidas
Si estás trabajando en un proyecto de script con otros desarrolladores, puedes colaborar en proyectos de Apps Script con unidades compartidas. Los archivos de una unidad compartida son propiedad del grupo, no de individuos. Esta facilita el desarrollo y el mantenimiento del proyecto.
Usa operaciones por lotes
Por lo general, las secuencias de comandos necesitan leer los datos de una hoja de cálculo, realizar cálculos, y luego escribir los resultados de los datos en una hoja de cálculo. Apps de Google La secuencia de comandos ya tiene una optimización integrada, como el uso de almacenamiento en caché con anticipación. para recuperar lo que podría obtener una secuencia de comandos y escribir el almacenamiento en caché para guardar más probable que se establezca.
Puede escribir secuencias de comandos para aprovechar al máximo el almacenamiento en caché integrado, lo que minimiza la cantidad de operaciones de lectura y escritura. Alternancia entre comandos de lectura y escritura es lenta. Para acelerar una secuencia de comandos, lee todos los datos en un array con un comando, realizar cualquier operación en los datos del array y escribir los datos con con un solo comando.
A continuación, se muestra un ejemplo que no deberías seguir ni usar. Un guion
usa el siguiente código para establecer los colores de fondo de cada celda de una
Cuadrícula de hoja de cálculo de 100 x 100. Usa como una función llamada
getColorFromCoordinates() (no se muestra aquí) para determinar qué color usar
para cada celda:
// 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: recorre en bucle 100 filas y 100 columnas, y escribe de forma consecutiva hasta 10,000 celdas. La caché de reescritura de Google Apps Script ayuda ya que fuerza una reescritura con el vaciado al final de cada línea. Porque del almacenamiento en caché, solo hay 100 llamadas a la hoja de cálculo.
Sin embargo, se puede hacer que el código sea mucho más eficiente agrupando las llamadas en lotes. Este es un reescritura en la que el rango de celdas se lee en un array llamado colores, el color se realiza una operación de asignación en los datos del array y los valores los arrays se escriben en la hoja de cálculo:
// 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);
Un código ineficiente tarda unos 70 segundos en ejecutarse. El código eficiente se ejecuta en solo 1 segundo.
Evita las bibliotecas en secuencias de comandos con mucha IU
Las bibliotecas son una forma conveniente de reutilizar códigos
pero aumentan ligeramente el tiempo de inicio del script. Esta demora
no se puede observar en secuencias de comandos de larga duración (como una secuencia de comandos de utilidad para
limpiar archivos de Google Drive), pero para los clientes
HTML Service que crean interfaces de usuario repetidas
google.script.run de corta duración
llamadas, la demora afectará a todas las llamadas. Debido a este problema, las bibliotecas deberían
usarse con moderación en complementos, y le recomendamos
evítalos en secuencias de comandos que no sean complementos que realicen muchas llamadas a google.script.run.
Usa el servicio de caché
Puedes usar el servicio de caché para almacenar en caché los recursos entre ejecuciones de secuencias de comandos. Al almacenar datos en caché, puedes reducir la cantidad de veces o la frecuencia con la que debes recuperar los datos. Supongamos que tienes un feed RSS en example.com que tarda 20 segundos para recuperar y quieres acelerar el acceso en la solicitud promedio. El En el siguiente ejemplo, se muestra cómo usar el servicio de caché para acelerar el acceso a esta de datos no estructurados.
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;
}
Aunque deberás esperar 20 segundos si el elemento no está en la caché los accesos posteriores serán muy rápidos hasta que el elemento caduque de la caché en 25 minutos.