Práticas recomendadas

Este documento lista as práticas recomendadas que vão ajudar 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 realizar no Google Apps Script em si será muito mais rápido do que fazer chamadas que precisam buscar dados servidores do Google ou um servidor externo, como solicitações para os apps Planilhas, Documentos, Sites, Tradutor, UrlFetch e assim por diante. Seus scripts serão executados mais rapidamente se você puder 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 Google Apps Script com drives compartilhados. Os arquivos em um drive compartilhado pertencem ao grupo, não a indivíduos. 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, em seguida, gravar os resultados dos dados em uma planilha. Apps do Google O script já tem otimização integrada, como o armazenamento em cache prévio recuperar o que um script provavelmente obterá e gravar o armazenamento em cache para provavelmente será definido.

Escreva scripts para aproveitar ao máximo o armazenamento em cache integrado, minimizando o número de leituras e gravações. Comandos de leitura e gravação alternados é lento. Para acelerar um script, leia todos os dados em uma matriz com um comando, executar qualquer operação nos dados da matriz e gravar os dados com um comando.

Aqui está um exemplo que você não deve seguir ou usar. Um roteiro usa o seguinte código para definir as cores de fundo de todas as células de um Grade de planilha de 100 x 100. Ele usa a função 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 passa por 100 linhas e 100 colunas, escrevendo consecutivamente até 10.000 células. O cache de gravação do Google Apps Script ajuda, porque força uma gravação de retorno usando o flush no final de cada linha. Devido ao do armazenamento em cache, existem apenas 100 chamadas à planilha.

No entanto, o código pode ficar muito mais eficiente com as chamadas em lote. Confira uma reescrita em que o intervalo de células é lido em uma matriz chamada "colors", a operação de atribuição de cor é realizada 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).setBackgrounds(colors);

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

Evitar bibliotecas em scripts com uso intenso de 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 de execução relativamente longa (como um script utilitário para limpar os arquivos do Google Drive), mas para clientes interfaces de usuário de serviço HTML que fazem repetições, google.script.run de curta duração chamadas, o atraso afetará todas elas. Por causa desse problema, as bibliotecas precisam ser usadas com moderação em complementos, e é recomendável evitar o uso em scripts que não são complementos e fazem muitas chamadas google.script.run.

Usar o serviço Cache

É possível usar o serviço de cache para armazenar recursos em cache entre as 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. Considere o cenário em que você tem um feed RSS em example.com que leva 20 segundos para buscar e quer acelerar o acesso em uma solicitação média. O exemplo abaixo mostra como usar o serviço de cache para acelerar o acesso a esta 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;
  }

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