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 script é consideravelmente mais rápido do que chamar outros serviços. Qualquer coisa que você possa fazer no Google Apps Script será muito mais rápida do que fazer chamadas que precisam buscar dados dos servidores do Google ou de um servidor externo, como solicitações para 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 eles fazem para esses serviços.
Considerar a colaboração 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, e 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 gravar os resultados dos dados em uma planilha. O Apps Script do Google já tem algumas otimizações integradas, como o uso do armazenamento em cache de previsão para recuperar o que um script provavelmente vai receber e o armazenamento em cache de gravação para salvar o que provavelmente será definido.
Você pode escrever 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 na matriz e grave os dados com um comando.
Confira um exemplo que não deve ser seguido ou usado. Um script
usa o código abaixo para definir as cores de plano de fundo de cada célula em uma
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 percorre 100 linhas e 100 colunas, gravando consecutivamente em 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 armazenamento em cache, há apenas 100 chamadas para a planilha.
No entanto, o código pode ficar muito mais eficiente agrupando as chamadas. 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 em apenas 1 segundo.
Evite bibliotecas em scripts pesados 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 em scripts relativamente longos (como um script de utilitário para
limpar seus arquivos do Google Drive), mas para interfaces do usuário
HTML Service do lado do cliente que fazem chamadas
de google.script.run
repetidas e de curta duração, o atraso afetará todas as chamadas. Por causa desse problema, as bibliotecas precisam
ser usadas com moderação em complementos, e é recomendável
evitar o uso delas em scripts que não são complementos e 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 dados em cache, você pode reduzir a quantidade de vezes ou a frequência com que precisa 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 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;
}
Agora, embora você ainda 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 do cache em 25 minutos.