Neste documento, listamos as práticas recomendadas que ajudarão você a melhorar o desempenho dos seus scripts.
Minimizar chamadas para outros serviços
O uso de operações JavaScript no 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 dos servidores do Google ou de um servidor externo, como solicitações de planilhas, documentos, sites, Google Tradutor, UrlFetch etc. 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, colabore em projetos do Apps Script com drives compartilhados. Os arquivos em um drive compartilhado pertencem ao grupo, e não a pessoas específicas. Isso facilita o desenvolvimento e a manutenção do projeto.
Usar operações em lote
Os scripts geralmente precisam ler dados em uma planilha, fazer cálculos e gravar os resultados em uma planilha. O Google Apps Script já tem alguma otimização integrada, como o uso do armazenamento em cache antecipado para recuperar o que um script provavelmente recebe 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 quaisquer operações nos dados na matriz e grave os dados com um comando.
Veja um exemplo que você não deve seguir nem usar. O 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. Ela usa como função chamada
getColorFromCoordinates() (não mostrada aqui) para determinar qual cor usar
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 em 10.000 células. O cache de write-back do Google Apps Script ajuda, porque força um write-back usando limpe o 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 agrupando as chamadas em lote. Aqui, há uma regravação em que o intervalo de células é lido em uma matriz chamada cores, a operação de atribuição de cores é realizada nos dados na 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);
A execução do código ineficiente leva cerca de 70 segundos. O código eficiente é executado em apenas um segundo.
Evitar bibliotecas em scripts pesados em IU
As bibliotecas são uma maneira conveniente de reutilizar o código,
mas aumentam um pouco o tempo para iniciar o script. Esse atraso
não é perceptível para scripts de execução relativamente longa (como um script de utilitário para
limpar os arquivos do Google Drive), mas para interfaces do 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 é recomendável
evitá-los em scripts não complementares que fazem muitas chamadas google.script.run.
Usar o serviço de cache
É possível usar o Serviço de cache para armazenar recursos em cache entre as execuções de script. Ao armazenar os dados em cache, é possível reduzir o número de vezes ou a frequência com que é preciso buscar os dados. Considere um cenário em que você tem um feed RSS em example.com que leva 20 segundos para ser buscado e quer acelerar o acesso a uma 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;
}
Agora, embora você precise esperar 20 segundos se o item não estiver no cache, os acessos subsequentes serão muito rápidos até que o item expire para fora do cache em 25 minutos.