Questo documento elenca le best practice che ti aiuteranno a migliorare il rendimento dei tuoi script.
Ridurre al minimo le chiamate ad altri servizi
L'utilizzo di operazioni JavaScript all'interno dello script è notevolmente più veloce rispetto alla chiamata di altri servizi. Qualsiasi operazione che puoi eseguire all'interno di Google Apps Script sarà molto più veloce rispetto alle chiamate che devono recuperare dati da server Google o da un server esterno, ad esempio le richieste a Fogli, Documenti, Sites, Traduttore, UrlFetch e così via. I tuoi script verranno eseguiti più rapidamente se riesci a trovare modi per ridurre al minimo le chiamate che gli script effettuano a questi servizi.
Valuta la collaborazione con i Drive condivisi
Se stai lavorando a un progetto di script con altri sviluppatori, puoi collaborare ai progetti Apps Script con i drive condivisi. I file che si trovano su un Drive condiviso appartengono al gruppo, non ai singoli utenti. In questo modo lo sviluppo e la manutenzione del progetto sono più semplici.
Utilizzare le operazioni batch
Gli script in genere devono leggere i dati da un foglio di lavoro, eseguire calcoli e quindi scrivere i risultati dei dati in un foglio di lavoro. Google Apps Script dispone già di alcune ottimizzazioni integrate, ad esempio l'utilizzo della memorizzazione nella cache look-ahead per recuperare ciò che è probabile che uno script ottenga e la memorizzazione nella cache di scrittura per salvare ciò che è probabile che venga impostato.
Puoi scrivere script per sfruttare al meglio la memorizzazione nella cache integrata riducendo al minimo il numero di letture e scritture. L'alternanza di comandi di lettura e scrittura è lenta. Per velocizzare uno script, leggi tutti i dati in un array con un solo comando, esegui le operazioni sui dati nell'array e scrivi i dati con un solo comando.
Ecco un esempio, che non devi seguire o utilizzare. Uno script
utilizza il seguente codice per impostare i colori di sfondo di ogni cella di una
griglia di foglio di lavoro 100 x 100. Utilizza una funzione denominata
getColorFromCoordinates() (non mostrata qui) per determinare il colore da utilizzare
per ogni cella:
// 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();
}
Lo script è inefficiente: esegue il ciclo di 100 righe e 100 colonne, scrivendo consecutivamente in 10.000 celle. La cache write-back di Google Apps Script è utile, perché forza un write-back utilizzando flush alla fine di ogni riga. A causa della memorizzazione nella cache, il foglio di lavoro viene chiamato solo 100 volte.
Tuttavia, il codice può essere reso molto più efficiente raggruppando le chiamate. Ecco una riscrittura in cui l'intervallo di celle viene letto in un array denominato colori, l'operazione di assegnazione del colore viene eseguita sui dati dell'array e i valori dell'array vengono scritti nel foglio di lavoro:
// 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);
L'esecuzione del codice inefficiente richiede circa 70 secondi. Il codice efficiente viene eseguito in solo 1 secondo.
Evitare librerie in script con molte UI
Le librerie sono un modo pratico per riutilizzare il codice,
ma aumentano leggermente il tempo necessario per avviare lo script. Questo ritardo
non è evidente per gli script in esecuzione relativamente lunga (come uno script di utilità per
pulire i file di Google Drive), ma per le interfacce utente Servizio HTML lato client che effettuano chiamate google.script.run ripetute e di breve durata, il ritardo influirà su ogni chiamata. A causa di questo problema, le librerie devono
essere utilizzate con parsimonia nei componenti aggiuntivi e potresti volerle
evitare negli script non componenti aggiuntivi che effettuano molte chiamate google.script.run.
Utilizzare il servizio di cache
Puoi utilizzare il servizio di memorizzazione nella cache per memorizzare nella cache le risorse tra le esecuzioni degli script. Memorizzando i dati nella cache, puoi ridurre il numero di volte o la frequenza con cui devi recuperare i dati. Considera lo scenario in cui hai un feed RSS su example.com che richiede 20 secondi per essere recuperato e vuoi velocizzare l'accesso alla richiesta media. L'esempio riportato di seguito mostra come utilizzare il servizio di cache per velocizzare l'accesso a questi dati.
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;
}
Ora, anche se dovrai comunque attendere 20 secondi se l'elemento non è nella cache, gli accessi successivi saranno molto veloci fino alla scadenza dell'elemento nella cache in 25 minuti.