Este documento lista as práticas recomendadas que ajudarão você a melhorar o desempenho dos seus 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ê puder fazer no Google Apps Script 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 o Planilhas, o Documentos, o Sites, o Tradutor, o 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 Apps Script com drives compartilhados. Os arquivos em um drive compartilhado pertencem ao grupo, não aos usuários. Isso facilita o desenvolvimento e a manutenção do projeto.
Usar operações em lote
Os scripts geralmente precisam ler os dados de uma planilha, realizar cálculos e gravar os resultados dos dados em uma planilha. O Google Apps Script já tem uma otimização integrada, como o uso de armazenamento em cache antecipado para recuperar o que um script provavelmente receberá e gravar em cache para salvar o que provavelmente será definido.
Escreva 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.
Veja a seguir um exemplo que você não deve seguir ou usar. Um script usa o código a seguir para definir as cores do plano de fundo de cada célula em uma grade de planilha de 100 x 100. Ele usa a função chamada
getColorFromCoordinates() (não mostrada aqui) para determinar a cor a ser usada
para 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 10.000 células. O cache de write-back do Google Apps Script ajuda, porque força um write-back usando limpeza ao final de cada linha. Por causa do armazenamento em cache, há apenas 100 chamadas para a planilha.
Mas o código pode ficar muito mais eficiente se as chamadas forem agrupadas. Aqui está uma substituição em que o intervalo de células é lido em uma matriz chamada cores, a operação de atribuição de cores é executada nos dados na matriz e os valores nela 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.
Evitar bibliotecas em scripts com IU pesada
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 longa (como um script utilitário para
limpar arquivos do Google Drive), mas para interfaces de usuário do
serviço HTML do lado do cliente que fazem
chamadas repetidas e curtas de google.script.run,
o atraso afeta todas as chamadas. Devido a esse problema, as bibliotecas precisam
ser usadas com moderação em complementos, e você pode
evitá-las em scripts não complementares que fazem muitas chamadas de google.script.run.
Usar o serviço Cache
Você pode usar o serviço de cache para armazenar recursos em cache entre as execuções do script. Ao armazenar os dados em cache, é possível reduzir o número de vezes ou a frequência com que você precisa buscar os dados. Considere um cenário em que você tem um feed RSS em example.com que leva 20 segundos para buscar 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 ainda seja necessário aguardar 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.