Neste documento, listamos as práticas recomendadas que ajudarão você a melhorar o desempenho dos scripts.
Minimizar chamadas para outros serviços
O uso de operações JavaScript no seu script é consideravelmente mais rápido do que chamar outros serviços. Tudo o que você pode realizar no próprio Google Apps Script será muito mais rápido do que fazer chamadas que precisam buscar dados de servidores do Google ou de um servidor externo, como solicitações ao Planilhas, Documentos, Sites, Tradutor, UrlFetch e assim por diante. 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, colabore em projetos do 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 os dados de uma planilha, realizar cálculos e gravar os resultados dos dados em uma planilha. O Google Apps Script já tem otimização integrada, como o uso do armazenamento em cache prévio para recuperar o que um script provavelmente receberá e o armazenamento 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. Alternar comandos de leitura e gravação é lento. 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 que você não deve seguir ou usar. Um script usa o código a seguir para definir as cores de fundo de todas as células em uma grade de planilha de 100 x 100. Ele usa como uma 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 passa por 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, existem apenas 100 chamadas para a planilha.
No entanto, o código pode ficar muito mais eficiente com as chamadas em lote. Aqui está uma regravaçã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 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 1 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 de utilitário para
limpar seus arquivos do Google Drive), mas para interfaces do usuário de
Serviço HTML do lado do cliente que fazem chamadas google.script.run
repetidas e de curta duração, o atraso afetará todas as chamadas. Devido a esse problema, as bibliotecas precisam
ser usadas com moderação em complementos, e é recomendável evitá-las
em scripts que não são complementos que fazem muitas chamadas google.script.run.
Usar o serviço Cache
Use o serviço de cache para armazenar recursos em cache entre as execuções de script. Ao armazenar dados em cache, você pode reduzir o número de vezes ou a frequência com que é preciso buscar os dados. Considere o cenário em que você tem um feed RSS em example.com que leva 20 segundos para ser buscado e você 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 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.