Práticas recomendadas

Neste documento, listamos as práticas recomendadas que ajudam a melhorar o desempenho dos scripts.

Minimizar chamadas para outros serviços

Usar operações JavaScript no seu script é consideravelmente mais rápido do que chamar outros serviços. Tudo o que você pode fazer com o Google Apps Script em si será muito mais rápido do que fazer chamadas que precisem buscar dados de servidores do Google ou de um servidor externo, como solicitações para os apps Planilhas, Documentos, Sites, Tradutor, UrlFetch etc. Seus scripts serão executados mais rapidamente se você encontrar maneiras de minimizar as chamadas que os scripts fazem para esses serviços.

Considere colaborar com drives compartilhados

Se você estiver trabalhando em um projeto de script com outros desenvolvedores, poderá colaborar em projetos do Apps Script usando drives compartilhados. Os arquivos em um drive compartilhado pertencem ao grupo, e não a pessoas. Isso facilita o desenvolvimento e a manutenção do projeto.

Usar operações em lote

Os scripts geralmente precisam ler dados de uma planilha, realizar cálculos e gravar os resultados dos dados em uma planilha. O Google Apps Script já tem algumas otimizações integradas, como usar o armazenamento em cache antecipado para recuperar o que um script provavelmente vai receber e o armazenamento em cache de gravação para salvar o que provavelmente será definido.

Grave scripts para aproveitar ao máximo o armazenamento em cache integrado, minimizando o número de leituras e gravações. A alternância de comandos de leitura e gravação é lenta. Para acelerar um script, leia todos os dados em uma matriz com um comando, execute qualquer operação nos dados da matriz e grave os dados com um comando.

Aqui está um exemplo: um exemplo que você não deve seguir ou usar. Um script usa o seguinte código para definir as cores do plano de fundo de cada célula em uma grade de planilha de 100 x 100. Ele usa como função chamada getColorFromCoordinates() (não mostrada aqui) para determinar qual cor usar em cada célula:

  // 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();
  }

O script é ineficiente: ele percorre 100 linhas e 100 colunas, gravando consecutivamente em 10.000 células. O cache de write-back do Google Apps Script ajuda porque força um write-back usando a limpeza no final de cada linha. Por causa do armazenamento em cache, há apenas 100 chamadas para a planilha.

Mas o código pode ser muito mais eficiente com o agrupamento de chamadas em lote. Veja aqui uma regravação em que o intervalo de células é lido em uma matriz chamada cores, a operação de atribuição de cor é executada nos dados da matriz e os valores na matriz são gravados na planilha:

  // 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);

O código ineficiente leva cerca de 70 segundos para ser executado. O código eficiente é executado em apenas um segundo.

Evite bibliotecas em scripts com muita interface

As bibliotecas são uma maneira conveniente de reutilizar o código, mas aumentam um pouco o tempo necessário para iniciar o script. Esse atraso não é perceptível para scripts relativamente longos (como um script utilitário para limpar seus arquivos do Google Drive), mas para interfaces de usuário do serviço HTML do lado do cliente que fazem chamadas google.script.run repetidas e de curta duração, o atraso afeta todas as chamadas. Devido a esse problema, as bibliotecas precisam ser usadas com moderação em complementos, e convém evitá-las em scripts que não sejam complementos que façam muitas chamadas google.script.run.

Usar o serviço Cache

Use o Serviço de cache para armazenar recursos em cache entre execuções de script. Ao armazenar dados em cache, é possível reduzir o número de vezes ou a frequência com que você precisa buscar os dados. Imagine que você tem um feed RSS em example.com que leva 20 segundos para ser buscado e quer acelerar o acesso na solicitação média. O exemplo abaixo mostra como usar o serviço de cache para acelerar o acesso a esses dados.

  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;
  }

Embora você ainda tenha que esperar 20 segundos se o item não estiver no cache, os acessos subsequentes serão muito rápidos até que o item expire fora do cache em 25 minutos.