In Apps Script e JavaScript, un ambiente di runtime o runtime contiene il motore JavaScript che analizza ed esegue il codice dello script. Il runtime fornisce le regole per l'accesso alla memoria, il modo in cui il programma può interagire con il sistema operativo del computer e la sintassi del programma legale. Ogni browser web dispone di un ambiente di runtime per JavaScript.
Storicamente, Apps Script si basa sull'interprete di Rhino JavaScript di Mozilla. Sebbene Rhino fornisse ad Apps Script un modo comodo per eseguire gli script per sviluppatori, ha anche associato Apps Script a una versione JavaScript specifica (ES5). Gli sviluppatori di Apps Script non possono utilizzare la sintassi e le funzionalità JavaScript più moderne negli script che utilizzano il runtime di Rhino.
Per risolvere questo problema, Apps Script è ora supportato dal runtime V8 alla base di Chrome e Node.js. Puoi eseguire la migrazione degli script esistenti alla versione V8 per sfruttare la sintassi e le funzionalità JavaScript moderne.
In questa pagina vengono descritte le nuove funzionalità abilitate da V8 e come puoi abilitare l'utilizzo nei tuoi script. Nella sezione Migrazione degli script a V8 vengono descritti i passaggi per eseguire la migrazione degli script esistenti per utilizzare il runtime V8.
Caratteristiche del runtime V8
Gli script che utilizzano il runtime V8 sono in grado di sfruttare le seguenti funzionalità:
Sintassi ECMAScript moderna
Puoi utilizzare la moderna sintassi ECMAScript
negli script basati sul runtime V8. Questa sintassi include
let
, const
e molte altre funzionalità molto usate.
Consulta gli esempi di sintassi V8 per un breve elenco dei miglioramenti più comuni della sintassi che puoi apportare utilizzando il runtime V8.
Rilevamento delle funzioni migliorato
Il rilevamento delle funzioni di Apps Script è stato migliorato per gli script che utilizzano V8. Il nuovo runtime riconosce i seguenti formati di definizione delle funzioni:
function normalFunction() {} async function asyncFunction() {} function* generatorFunction() {} var varFunction = function() {} let letFunction = function() {} const constFunction = function() {} var namedVarFunction = function alternateNameVarFunction() {} let namedLetFunction = function alternateNameLetFunction() {} const namedConstFunction = function alternateNameConstFunction() {} var varAsyncFunction = async function() {} let letAsyncFunction = async function() {} const constAsyncFunction = async function() {} var namedVarAsyncFunction = async function alternateNameVarAsyncFunction() {} let namedLetAsyncFunction = async function alternateNameLetAsyncFunction() {} const namedConstAsyncFunction = async function alternateNameConstAsyncFunction() {} var varGeneratorFunction = function*() {} let letGeneratorFunction = function*() {} const constGeneratorFunction = function*() {} var namedVarGeneratorFunction = function* alternateNameVarGeneratorFunction() {} let namedLetGeneratorFunction = function* alternateNameLetGeneratorFunction() {} const namedConstGeneratorFunction = function* alternateNameConstGeneratorFunction() {} var varLambda = () => {} let letLambda = () => {} const constLambda = () => {} var varAsyncLambda = async () => {} let letAsyncLambda = async () => {} const constAsyncLambda = async () => {}
Chiamare metodi degli oggetti da trigger e callback
Gli script che utilizzano V8 possono chiamare metodi degli oggetti e metodi statici di classe da posizioni in cui puoi già chiamare metodi della libreria. ad esempio:
- Attivatori manifest dei componenti aggiuntivi di Google Workspace
- Trigger installabili
- Voci di menu negli Google Workspace editor
- Funzioni di callback dell'utente, come quella descritta nell'esempio di codice di
ScriptApp.newStateToken()
.
Il seguente esempio V8 mostra l'utilizzo di metodi oggetto durante la creazione di voci di menu in Fogli Google:
function onOpen() {
var ui = SpreadsheetApp.getUi(); // Or DocumentApp, SlidesApp, or FormApp.
ui.createMenu('Custom Menu')
.addItem('First item', 'menu.item1')
.addSeparator()
.addSubMenu(ui.createMenu('Sub-menu')
.addItem('Second item', 'menu.item2'))
.addToUi();
}
var menu = {
item1: function() {
SpreadsheetApp.getUi().alert('You clicked: First item');
},
item2: function() {
SpreadsheetApp.getUi().alert('You clicked: Second item');
}
}
visualizza i log
Apps Script offre due servizi di logging: il servizio Logger
e la classe console
. Entrambi i servizi scrivono i log nello stesso servizio Stackdriver Logging.
Per visualizzare i log Logger
e console
, fai clic su Log esecuzione nella parte superiore dell'editor di script.
Visualizza esecuzioni
Per visualizzare la cronologia di esecuzione del tuo script, apri il progetto Apps Script e fai clic su Esecuzioni
a sinistra.Esempi di sintassi V8
Di seguito è riportato un breve elenco delle funzionalità sintattiche più diffuse disponibili per gli script che utilizzano il runtime V8.
let
e const
Le parole chiave let
e const
consentono di definire, rispettivamente, le variabili locali e le costanti dell'ambito a blocchi.
// V8 runtime let s = "hello"; if (s === "hello") { let s = "world"; console.log(s); // Prints "world" } console.log(s); // Prints "hello" const N = 100; N = 5; // Results in TypeError |
Funzioni freccia
Le funzioni a freccia offrono un modo compatto per definire le funzioni all'interno delle espressioni.
// Rhino runtime function square(x) { return x * x; } console.log(square(5)); // Outputs 25 |
// V8 runtime const square = x => x * x; console.log(square(5)); // Outputs 25 // Outputs [1, 4, 9] console.log([1, 2, 3].map(x => x * x)); |
Corsi
Le classi forniscono un mezzo per organizzare concettualmente il codice con ereditarietà. Le classi in V8 sono principalmente zuccheri sintattici rispetto all'ereditarietà basata su prototipi JavaScript.
// V8 runtime class Rectangle { constructor(width, height) { // class constructor this.width = width; this.height = height; } logToConsole() { // class method console.log(`Rectangle(width=${this.width}, height=${this.height})`); } } const r = new Rectangle(10, 20); r.logToConsole(); // Outputs Rectangle(width=10, height=20) |
Interruzione delle assegnazioni
Le espressioni delle assegnazioni distruttive sono un modo rapido per separare i valori da array e oggetti in variabili distinte.
// Rhino runtime var data = {a: 12, b: false, c: 'blue'}; var a = data.a; var c = data.c; console.log(a, c); // Outputs 12 "blue" var array = [1, 2, 3]; var x = a[0]; var y = a[1]; var z = a[2]; console.log(x, y, z); // Outputs 1 2 3 |
// V8 runtime var data = {a: 12, b: false, c: 'blue'}; var {a, c} = data; console.log(a, c); // Outputs 12 "blue" var array = [1, 2, 3]; var [x, y, z] = array; console.log(x, y, z); // Outputs 1 2 3 |
Valori letterali del modello
I valori letterali modello sono valori letterali stringa che consentono le espressioni incorporate. Consentono di evitare istruzioni di concatenazione più complesse di stringhe.
// Rhino runtime var name = 'Hi ' + first + ' ' + last + '.'; var url = 'http://localhost:3000/api/messages/' + id; |
// V8 runtime var name = `Hi ${first} ${last}.`; var url = `http://localhost:3000/api/messages/${id}`; |
Parametri predefiniti
Parametri predefiniti ti consentono di specificare i valori predefiniti per i parametri della funzione nella dichiarazione della funzione. Questo può semplificare il codice nel corpo della funzione, in quanto elimina la necessità di assegnare esplicitamente valori predefiniti ai parametri mancanti.
// Rhino runtime function hello(greeting, name) { greeting = greeting || "hello"; name = name || "world"; console.log( greeting + " " + name + "!"); } hello(); // Outputs "hello world!" |
// V8 runtime var hello = function(greeting="hello", name="world") { console.log( greeting + " " + name + "!"); } hello(); // Outputs "hello world!" |
Stringhe su più righe
Puoi definire stringhe su più righe utilizzando la stessa sintassi dei valori letterali modello. Come per i valori letterali dei modelli, questa sintassi consente di evitare concatenazioni di stringhe e semplifica le definizioni delle stringhe.
// Rhino runtime var multiline = "This string is sort of\n" + "like a multi-line string,\n" + "but it's not really one."; |
// V8 runtime var multiline = `This on the other hand, actually is a multi-line string, thanks to JavaScript ES6`; |
Attivazione del runtime V8
Se uno script utilizza il runtime di Rhino, puoi passarlo alla V8 procedendo nel seguente modo:
- Apri il progetto Apps Script.
- A sinistra, fai clic su Impostazioni progetto .
- Seleziona la casella di controllo Attiva runtime Chrome V8.
In alternativa, puoi specificare direttamente il runtime dello script modificando il file manifest dello script:
- Apri il progetto Apps Script.
- A sinistra, fai clic su Impostazioni progetto .
- Seleziona la casella di controllo Mostra il file manifest "appsscript.json" nell'editor.
- A sinistra, fai clic su Editor
appsscript.json
.
>
- Nel file manifest
appsscript.json
, imposta il camporuntimeVersion
sul valoreV8
. - In alto, fai clic su Salva progetto .
Nella pagina Migrazione degli script alla versione V8 vengono spiegati altri passaggi da seguire per garantire che lo script funzioni correttamente con V8.
Attivazione del runtime di Rhino
Se lo script utilizza V8 e devi cambiarlo per utilizzare il runtime originale di Rhino, procedi nel seguente modo:
- Apri il progetto Apps Script.
- A sinistra, fai clic su Impostazioni progetto .
- Deseleziona la casella di controllo Attiva runtime Chrome V8.
In alternativa, modifica il manifest dello script:
- Apri il progetto Apps Script.
- A sinistra, fai clic su Impostazioni progetto .
- Seleziona la casella di controllo Mostra il file manifest "appsscript.json" nell'editor.
- A sinistra, fai clic su Editor
appsscript.json
.
>
- Nel file manifest
appsscript.json
, imposta il camporuntimeVersion
sul valoreDEPRECATED_ES5
. - In alto, fai clic su Salva progetto .
Come faccio a eseguire la migrazione degli script esistenti?
La guida Migrazione degli script a V8 descrive i passaggi da seguire per eseguire la migrazione di uno script esistente per utilizzare V8. Ciò comporta l'abilitazione del runtime V8 e il controllo dello script per rilevare eventuali incompatibilità note.
Migrazione automatica degli script a V8
A partire dal 18 febbraio 2020, Google inizierà la migrazione graduale degli script esistenti che superano il test di compatibilità automatico alla versione V8. Gli script interessati continueranno a funzionare normalmente dopo la migrazione.
Se vuoi disattivare la migrazione automatica per uno script, imposta il campo runtimeVersion
nel file manifest su DEPRECATED_ES5
. Successivamente, puoi scegliere di
eseguire manualmente la migrazione dello script alla versione V8
in qualsiasi momento.
Come faccio a segnalare i bug?
La guida di assistenza spiega come ricevere assistenza per la programmazione su Stack Overflow, effettuare ricerche nei report dei problemi esistenti, segnalare nuovi bug ed effettuare nuove richieste di funzionalità.