Este documento lista as práticas recomendadas que vão ajudar você a melhorar o desempenho dos seus 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 realizar 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 o 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 a 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, e não a pessoas específicas. Isso facilita o desenvolvimento e a manutenção do projeto.
Usar operações em lote
Normalmente, os scripts precisam ler dados de uma planilha, fazer cálculos e gravar os resultados em outra planilha. O Google Apps Script já tem algumas otimizações integradas, como o uso do armazenamento em cache de look-ahead para recuperar o que um script provavelmente vai receber e o armazenamento em cache de gravação para salvar o que provavelmente será definido.
É possível 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, realize as operações necessárias nos dados da matriz e grave os dados com um comando.
Confira um exemplo que não deve ser seguido nem usado. Um script usa o código a seguir para definir as cores de plano de fundo de cada célula em uma grade de planilha de 100 x 100. Ele usa uma função chamada 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 faz um loop por 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 usando o flush no final de cada linha. Devido ao armazenamento em cache, há apenas 100 chamadas para a planilha.
Mas o código pode ser muito mais eficiente com o agrupamento das 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 da 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 com muitas interfaces
As bibliotecas são uma maneira conveniente de reutilizar 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. No entanto, 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 devem ser usadas com moderação em complementos, e talvez seja melhor evitá-las em scripts que não são complementos e fazem muitas chamadas de google.script.run.
Usar o serviço de cache
É possível usar o serviço de cache para armazenar recursos em cache entre execuções de script. Ao armazenar dados em cache, você pode reduzir o número 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.