Prácticas recomendadas

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.

Conjuntos de datos grandes y cálculos complejos

Hojas de cálculo de Google es una herramienta potente, pero, a medida que los conjuntos de datos crecen y los cálculos se vuelven más complejos, es posible que experimentes problemas de rendimiento, como retrasos en la hoja de cálculo, errores de IMPORTRANGE y tiempos de espera de los scripts.

Cuándo usar una base de datos

Si tu hoja de cálculo se acerca al límite de 10 millones de celdas o si tienes muchos formularios conectados (p.ej., 10 o más) y fórmulas complejas entre hojas, considera usar una solución de base de datos dedicada.

  • Google Cloud SQL: Un servicio de base de datos relacional completamente administrado para MySQL, PostgreSQL y SQL Server. Usa el servicio JDBC para conectarte a Cloud SQL o a otras bases de datos externas, como Oracle o MongoDB (a través de los puentes adecuados).
  • BigQuery: Es un almacén de datos sin servidores y altamente escalable. Puedes usar Hojas conectadas para analizar grandes conjuntos de datos de BigQuery directamente en Hojas de cálculo o usar el servicio de BigQuery para interactuar con los datos de Apps Script.

Optimización del rendimiento de las fórmulas

El uso excesivo de ciertas fórmulas puede ralentizar tu hoja de cálculo:

  • ARRAYFORMULA: Si bien es útil, los cálculos de ARRAYFORMULA a gran escala pueden ser costosos.
  • VLOOKUP y OFFSET: Estas funciones pueden ser lentas en conjuntos de datos grandes. Considera usar INDEX y MATCH o Apps Script para realizar búsquedas de manera más eficiente en la memoria.
  • IMPORTRANGE: El uso frecuente de IMPORTRANGE en muchas hojas puede generar "errores internos" si las hojas de origen son grandes o están sobrecargadas. Consolidar los datos en una fuente centralizada puede ser útil.

Control del tiempo de espera de la secuencia de comandos

Apps Script tiene límites de tiempo de ejecución (por lo general, 6 minutos por ejecución o 30 minutos para algunas cuentas de Google Workspace). Si tu secuencia de comandos falla con frecuencia porque supera el límite de ejecución, haz lo siguiente:

  1. Usa operaciones por lotes: Como se mencionó en la sección Usa operaciones por lotes, minimiza las llamadas a hojas de cálculo y otros servicios.
  2. Dividir tareas: Divide las tareas grandes en partes más pequeñas que se puedan completar dentro del límite de tiempo.
  3. Usa activadores para las continuaciones: Configura un activador basado en el tiempo instalable para reanudar un proceso de ejecución prolongada. Tu secuencia de comandos puede almacenar su estado actual (p.ej., el índice de la última fila procesada) con el servicio de propiedades y continuar desde ese punto en la próxima ejecución.