Prácticas recomendadas

En este documento, se enumeran las prácticas recomendadas que te ayudarán a 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 mucho más rápido que llamar a otros servicios. Todo lo que puedas lograr dentro de 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. Las secuencias de comandos se ejecutarán más rápido si puedes encontrar formas de minimizar las llamadas que las secuencias de comandos hacen a esos servicios.

Considera colaborar con unidades compartidas

Si trabajas en un proyecto de secuencia de comandos 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 personas individuales. Esto facilita el desarrollo y el mantenimiento del proyecto.

Cómo usar 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 cuenta con cierta optimización incorporada, como el uso del almacenamiento en caché de visualización anticipada para recuperar lo que podría obtener una secuencia de comandos y el almacenamiento en caché de escritura para guardar lo que probablemente se configure.

Puedes escribir secuencias de comandos para aprovechar al máximo el almacenamiento en caché integrado, ya que minimiza la cantidad de lecturas y escrituras. La alternancia de comandos de lectura y escritura es lenta. Para acelerar una secuencia de comandos, lee todos los datos en un arreglo con un comando, realiza cualquier operación en los datos del arreglo y escríbelos con un comando.

Aquí hay un ejemplo que no debes 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 100 x 100 de una hoja de cálculo. Usa como función llamada getColorFromCoordinates() (que 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: realiza un bucle a través de 100 filas y 100 columnas y escribe de forma consecutiva en 10,000 celdas. La caché de reescritura de Google Apps Script es útil, ya que fuerza una reescritura mediante un vaciado al final de cada línea. Debido al almacenamiento en caché, solo hay 100 llamadas a la hoja de cálculo.

Sin embargo, el código puede ser mucho más eficiente si se agrupan las llamadas en lotes. A continuación, se muestra una reescritura en la que el rango de celdas se lee en un array llamado colores, la operación de asignación de colores se realiza sobre los datos del array y los valores del array 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 unos 70 segundos en ejecutarse. El código eficiente se ejecuta en solo 1 segundo.

Evita las bibliotecas en secuencias de comandos con muchas IU

Las bibliotecas son una forma conveniente de reutilizar el código, pero aumentan ligeramente el tiempo que lleva iniciar la secuencia de comandos. Esta demora no es evidente en secuencias de comandos de ejecución relativamente larga (como una secuencia de comandos de utilidad para limpiar tus archivos de Google Drive), pero en las interfaces de usuario del servicio HTML del cliente que realizan llamadas repetidas de google.script.run de corta duración, la demora afectará a cada llamada. Debido a este problema, las bibliotecas deberían usarse con moderación en los complementos y se recomienda evitarlas en las secuencias de comandos que no son complementos y que realizan muchas llamadas a google.script.run.

Usa el servicio de caché

Puedes usar el servicio de caché para almacenar recursos en caché entre ejecuciones de secuencias de comandos. Mediante el almacenamiento en caché de los datos, puedes reducir la cantidad de veces o la frecuencia con la que tienes que recuperar los datos. Considera una situación en la 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;
  }

Aunque todavía 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.