Prácticas recomendadas

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

En este documento, se enumeran las prácticas recomendadas que te ayudarán a mejorar el rendimiento de tus secuencias de comandos.

Minimizar las llamadas a otros servicios

El uso de las operaciones de JavaScript en tu secuencia de comandos es considerablemente más rápido que llamar a otros servicios. Todo lo que puedes lograr con Google Apps Script será mucho más rápido que realizar llamadas que necesiten recuperar datos de los servidores de Google o de un servidor externo, como solicitudes a Hojas de cálculo, Documentos, Sites, Traductor, UrlFetch, etcétera. Tus secuencias de comandos se ejecutarán más rápido si puedes encontrar formas de minimizar las llamadas que realizan a esos servicios.

Considera la posibilidad de colaborar con unidades compartidas

Si trabajas en un proyecto de secuencias de comandos con otros desarrolladores, puedes colaborar en proyectos de Apps Script con unidades compartidas. Los archivos de una unidad compartida pertenecen al grupo, no a las personas. Esto facilita el desarrollo y el mantenimiento del proyecto.

Usa operaciones por lotes

Por lo general, las secuencias de comandos necesitan leer datos de una hoja de cálculo, realizar cálculos y, luego, escribir los resultados de los datos en una hoja de cálculo. Google Apps Script ya tiene una optimización integrada, como el uso del almacenamiento en caché anticipado para recuperar lo que es probable que obtenga una secuencia de comandos y el almacenamiento en caché de escritura para guardar lo que se puede configurar.

Puedes escribir secuencias de comandos para aprovechar al máximo el almacenamiento en caché integrado si minimizas la cantidad de lecturas y escrituras. La alternancia de los comandos de lectura y escritura es lenta. Para acelerar una secuencia de comandos, lee todos los datos en un arreglo con un comando, realiza las operaciones en los datos del arreglo y escribe los datos con un solo comando.

Este es un ejemplo que no deberías seguir ni usar. Una secuencia de comandos usa el siguiente código para establecer los colores de fondo de cada celda en una cuadrícula de hoja de cálculo de 100 x 100. Se usa como función llamada getColorFromCoordinates() (no se muestra aquí) a fin de 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 100 filas y 100 columnas y escribe consecutivamente en 10,000 celdas. La caché de reescritura de Google Apps Script ayuda, ya que fuerza una reescritura mediante la limpieza al final de cada línea. Debido al almacenamiento en caché, solo hay 100 llamadas a la hoja de cálculo.

Pero el código puede ser mucho más eficiente si se agrupan las llamadas en lotes. Esta es una reescritura en la que el rango de celdas se lee en un arreglo llamado colores, la operación de asignación de color se realiza en los datos del arreglo y los valores del arreglo 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);

El código ineficiente tarda alrededor de 70 segundos en ejecutarse. El código eficiente se ejecuta en solo 1 segundo.

Evita bibliotecas en secuencias de comandos pesadas de la IU

Las bibliotecas son una forma conveniente de reutilizar el código, pero aumentan un poco el tiempo que lleva iniciar la secuencia de comandos. Esta demora no es perceptible en las secuencias de comandos relativamente prolongadas (como una secuencia de comandos de utilidad para limpiar los archivos de Google Drive), pero en las interfaces de usuario del servicio HTML del cliente que realizan llamadas google.script.run repetidas y de ejecución breve, el retraso afectará a cada llamada. Debido a este problema, las bibliotecas deben usarse con moderación en complementos, y es posible que quieras evitarlos en secuencias de comandos no complementarias que realizan muchas llamadas google.script.run.

Usar el servicio de caché

Puedes usar el Servicio de caché para almacenar en caché los recursos entre ejecuciones de secuencias de comandos. Si almacenas datos en caché, puedes reducir la cantidad de veces o la frecuencia con la que necesitas recuperar los datos. Considera el caso en el que tienes un feed RSS en example.com que tarda 20 segundos en recuperarse y deseas acelerar el acceso en la solicitud promedio. En el siguiente ejemplo, se muestra cómo usar el servicio de caché para acelerar el acceso a estos datos.

  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 el elemento no esperará 20 segundos si no está almacenado en caché, ahora los accesos posteriores serán muy rápidos hasta que el elemento salga de la caché en 25 minutos.