Panoramica del runtime V8

In Google Apps Script e JavaScript, un runtime o ambiente di runtime contiene il motore JavaScript che analizza ed esegue il codice dello script. Il runtime fornisce regole per l'accesso alla memoria, per l'interazione del programma con il sistema operativo del computer e per la sintassi del programma valida. Ogni browser web ha un ambiente di runtime per JavaScript.

Storicamente, Apps Script è stato basato sull'interprete JavaScript Rhino di Mozilla. Sebbene Rhino fornisse un modo pratico per Apps Script di eseguire gli script degli sviluppatori, legava anche Apps Script a una versione specifica di JavaScript (ES5). Gli sviluppatori di Apps Script non possono utilizzare la sintassi e le funzionalità JavaScript più moderne negli script che utilizzano il runtime Rhino.

Per risolvere questo problema, Apps Script è ora supportato dal V8V8 che alimenta Chrome e Node.js. Esegui la migrazione degli script esistenti a V8 per sfruttare la sintassi e le funzionalità JavaScript moderne.

Questa pagina descrive le nuove funzionalità abilitate da V8 e come puoi abilitare V8 per l'utilizzo negli script. La pagina Esegui la migrazione degli script a V8 descrive i passaggi per la migrazione degli script esistenti in modo che utilizzino il runtime V8.

Funzionalità del runtime V8

Gli script che utilizzano il runtime V8 possono sfruttare le seguenti funzionalità:

Sintassi ECMAScript moderna

Utilizza la sintassi ECMAScript moderna negli script basati sul runtime V8. Questa sintassi include let, const e molte altre funzionalità comuni.

Consulta gli esempi di sintassi V8 per un breve elenco dei miglioramenti della sintassi più comuni che puoi apportare utilizzando il runtime V8.

Il runtime V8 di Apps Script presenta alcune limitazioni e differenze chiave rispetto ad altri runtime JavaScript comuni. Per maggiori dettagli, consulta la pagina Limitazioni del runtime V8 di Apps Script.

Rilevamento delle funzioni migliorato

Il rilevamento delle funzioni di Apps Script è migliorato per gli script che utilizzano V8. Il nuovo runtime riconosce questi 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 () => {}

Chiama i metodi degli oggetti da trigger e callback

Gli script che utilizzano V8 possono chiamare i metodi degli oggetti e i metodi statici delle classi da posizioni in cui era già possibile chiamare i metodi delle librerie. Queste posizioni includono:

L'esempio V8 seguente mostra l'utilizzo dei metodi degli oggetti durante la creazione di voci di menu in Fogli Google:

function onOpen() {
  const 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();
}

const menu = {
  item1: function() {
    SpreadsheetApp.getUi().alert('You clicked: First item');
  },
  item2: function() {
    SpreadsheetApp.getUi().alert('You clicked: Second item');
  }
}

Visualizza i log

Apps Script fornisce due servizi di logging: il Logger servizio e la console classe. Entrambi questi servizi scrivono i log nello stesso servizio Stackdriver Logging.

Per visualizzare i log Logger e console, fai clic su Log di esecuzione nella parte superiore dell'editor di script.

Visualizza le esecuzioni

Per visualizzare la cronologia di esecuzione dello script, apri il progetto Apps Script e fai clic su Esecuzioni a sinistra.

Il riquadro Esecuzioni non fornisce log con timestamp delle singole chiamate al servizio Apps Script. Utilizza il console servizio per creare appropriati messaggi di log. Tutti i log creati con console vengono visualizzati nel riquadro Esecuzioni.

Esempi di sintassi V8

Di seguito è riportato un breve elenco delle funzionalità sintattiche più comuni disponibili per gli script che utilizzano il runtime V8.

let e const

Le parole chiave let e const consentono di definire rispettivamente variabili locali con ambito di blocco e costanti con ambito di blocco.

// V8 runtime
let s = "hello";
if (s === "hello") {
  s = "world";
  console.log(s);  // Prints "world"
}
console.log(s);  // Prints "hello"

const N = 100;
N = 5; // Results in TypeError

Funzioni freccia

Le funzioni freccia forniscono 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

I corsi forniscono un mezzo per organizzare concettualmente il codice con l'ereditarietà. I corsi in V8 sono principalmente zucchero sintattico sull'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)

Assegnazioni di destrutturazione

Le espressioni di assegnazione di destrutturazione sono un modo rapido per decomprimere i valori di 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 a = [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
const data = {a: 12, b: false, c: 'blue'};
const {a, c} = data;
console.log(a, c);  // Outputs 12 "blue"


const array = [1, 2, 3];
const [x, y, z] = array;
console.log(x, y, z);  // Outputs 1 2 3

Valori letterali del modello

I valori letterali del modello sono valori letterali stringa che consentono espressioni incorporate. Ti consentono di evitare istruzioni di concatenazione di stringhe più complesse.

// Rhino runtime
var name =
  'Hi ' + first + ' ' + last + '.';
var url =
  'http://localhost:3000/api/messages/'
  + id;
      
// V8 runtime
const name = `Hi ${first} ${last}.`;
const url =
  `http://localhost:3000/api/messages/${id}`;

Parametri predefiniti

I parametri predefiniti consentono di specificare i valori predefiniti per i parametri delle funzioni nella dichiarazione. Questo può semplificare il codice nel corpo della funzione, in quanto elimina la necessità di assegnare esplicitamente i 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
const hello =
  function(greeting="hello", name="world") {
      console.log(
        greeting + " " + name + "!");
  }

hello();  // Outputs "hello world!"

Stringhe multiriga

Definisci le stringhe multiriga utilizzando la stessa sintassi dei valori letterali del modello. Come per i valori letterali del modello, questa sintassi consente di evitare le concatenazioni di stringhe e semplificare le definizioni di 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
const multiline = `This on the other hand,
actually is a multi-line string,
thanks to JavaScript ES6`;

Limitazioni del runtime V8

Il runtime V8 di Apps Script non è un ambiente Node.js o browser standard. Ciò può causare problemi di compatibilità quando chiami librerie di terze parti o adatti esempi di codice da altri ambienti JavaScript.

API non disponibili

Le seguenti API JavaScript standard NON sono disponibili nel runtime V8 di Apps Script:

  • Timer: setTimeout, setInterval, clearTimeout, clearInterval
  • Stream: ReadableStream, WritableStream, TextEncoder, TextDecoder
  • API web: fetch, FormData, File, Blob, URL, URLSearchParams, DOMException, atob, btoa
  • Crittografia: crypto, SubtleCrypto
  • Oggetti globali: window, navigator, performance, process (Node.js)

Utilizza le seguenti API Apps Script come alternative:

Per le API senza un'alternativa Apps Script, come TextEncoder, a volte puoi utilizzare un polyfill. Un polyfill è una libreria che replica la funzionalità API non disponibile per impostazione predefinita nell'ambiente di runtime. Prima di utilizzare un polyfill, verifica che sia compatibile con il runtime V8 di Apps Script.

Limitazioni asincrone

Il runtime V8 supporta la sintassi async e await e l'oggetto Promise. Tuttavia, l'ambiente di runtime di Apps Script è fondamentalmente sincrono.

  • Microtask (supportati): il runtime elabora la coda di microtask (in cui si verificano i callback Promise.then e le risoluzioni await) dopo che lo stack di chiamate corrente è stato cancellato.
  • Macrotask (non supportati): Apps Script non ha un loop di eventi standard per i macrotask. Funzioni come setTimeout e setInterval non sono disponibili.
  • Eccezione WebAssembly: l'API WebAssembly è l'unica funzionalità integrata che opera in modo non bloccante all'interno del runtime, consentendo pattern di compilazione asincrona specifici (WebAssembly.instantiate).

Tutte le operazioni di I/O, come UrlFetchApp.fetch, sono bloccanti. Per ottenere richieste di rete parallele, utilizza UrlFetchApp.fetchAll.

Limitazioni dei corsi

Il runtime V8 presenta limitazioni specifiche relative alle funzionalità dei corsi ES6+ moderni:

  • Campi privati: i campi dei corsi privati (ad es. #field) non sono supportati e causano errori di analisi. Valuta la possibilità di utilizzare chiusure o WeakMap per una vera incapsulamento.
  • Campi statici: le dichiarazioni di campi statici diretti all'interno del corpo del corso (ad es. static count = 0;) non sono supportate. Assegna le proprietà statiche al corso dopo la sua definizione (ad es. MyClass.count = 0;).

Limitazioni dei moduli

  • Moduli ES6: il runtime V8 non supporta i moduli ES6 (import / export). Per utilizzare le librerie, devi utilizzare il meccanismo della libreria Apps Script o raggruppare il codice e le relative dipendenze in un unico file di script. (Issue Tracker)
  • Ordine di esecuzione dei file: tutti i file di script nel progetto vengono eseguiti in un ambito globale. È consigliabile evitare il codice di primo livello con effetti collaterali e assicurarsi che le funzioni e i corsi siano definiti prima di essere utilizzati nei file. Ordina esplicitamente i file nell'editor se esistono dipendenze tra loro.

Abilita il runtime V8

Se uno script utilizza il runtime Rhino, passa a V8 procedendo nel seguente modo:

  1. Apri il progetto Apps Script.
  2. A sinistra, fai clic su Impostazioni progetto .
  3. Seleziona la casella di controllo Abilita il runtime Chrome V8.

In alternativa, specifica il runtime dello script direttamente modificando il file manifest dello script:

  1. Apri il progetto Apps Script.
  2. A sinistra, fai clic su Impostazioni progetto .
  3. Seleziona la casella di controllo Mostra il file manifest "appsscript.json" nell'editor.
  4. A sinistra, fai clic su Editor > appsscript.json.
  5. Nel file manifest appsscript.json, imposta il runtimeVersion campo sul valore V8.
  6. Nella parte superiore, fai clic su Salva progetto .

La pagina Esegui la migrazione degli script a V8 spiega altri passaggi da eseguire per assicurarti che lo script funzioni correttamente utilizzando V8.

Abilita il runtime Rhino

Se lo script utilizza V8 e devi passare al runtime Rhino originale, procedi nel seguente modo:

  1. Apri il progetto Apps Script.
  2. A sinistra, fai clic su Impostazioni progetto .
  3. Deseleziona la casella di controllo Abilita il runtime Chrome V8.

In alternativa, modifica il manifest dello script:

  1. Apri il progetto Apps Script.
  2. A sinistra, fai clic su Impostazioni progetto .
  3. Seleziona la casella di controllo Mostra il file manifest "appsscript.json" nell'editor.
  4. A sinistra, fai clic su Editor > appsscript.json.
  5. Nel file manifest appsscript.json, imposta il campo runtimeVersion sul valore DEPRECATED_ES5.
  6. Nella parte superiore, fai clic su Salva progetto .

Come faccio a eseguire la migrazione degli script esistenti?

La guida Esegui la migrazione degli script a V8 descrive i passaggi da eseguire per eseguire la migrazione di uno script esistente in modo che utilizzi V8. Ciò comporta l'abilitazione del runtime V8 e il controllo dello script per eventuali incompatibilità note.

Migrazione automatica degli script a V8

A partire dal 18 febbraio 2020, Google esegue gradualmente la migrazione degli script esistenti che superano il nostro test di compatibilità automatizzato a V8. Gli script interessati continuano a funzionare normalmente dopo la migrazione.

Se vuoi disattivare la migrazione automatica di uno script, imposta il runtimeVersion campo nel relativo manifest su DEPRECATED_ES5. Scegli di eseguire manualmente la migrazione dello script a V8 in qualsiasi momento successivo.

Come faccio a segnalare i bug?

La guida Supporto spiega come ottenere assistenza per la programmazione su Stack Overflow, cercare le segnalazioni di problemi esistenti, segnalare nuovi bug ed effettuare nuove richieste di funzionalità.