Panoramica del runtime V8

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 regole su come accedere alla memoria, su come il programma può interagire con il sistema operativo del computer e su quale sintassi del programma è legale. Ogni browser web dispone di un ambiente di runtime per JavaScript.

Storicamente, Apps Script è basato sull'interprete JavaScript Rhino di Mozilla. Rhino ha fornito un metodo pratico per Apps Script per eseguire script per sviluppatori, ma ha anche collegato Apps Script a una specifica versione di JavaScript (ES5). Gli sviluppatori Apps Script non possono utilizzare sintassi e funzionalità JavaScript più moderne negli script che utilizzano il runtime Rhino.

Per risolvere questo problema, Apps Script è ora supportato dal runtime V8 su cui sono basati Chrome e Node.js. Puoi eseguire la migrazione degli script esistenti alla versione V8 per sfruttare la moderna sintassi e le funzionalità JavaScript.

In questa pagina vengono descritte le nuove funzionalità attivate dalla versione V8 e come è possibile attivare la versione V8 per l'utilizzo nei tuoi script. Nella sezione Migrazione degli script alla versione V8 vengono descritti i passaggi per eseguire la migrazione degli script esistenti per utilizzare il runtime V8.

Funzionalità del runtime V8

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

Sintassi ECMAScript moderna

Puoi utilizzare la moderna sintassi ECMAScript negli script che utilizzano il runtime V8. Questa sintassi include let, const e molte altre funzionalità popolari.

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

Rilevamento delle funzioni migliorato

Il rilevamento delle funzioni Apps Script è stato 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 () => {}

Metodi degli oggetti di chiamata da trigger e callback

Gli script che utilizzano V8 possono chiamare metodi oggetto e metodi statici di classe da posizioni in cui era già possibile chiamare i metodi di libreria. tra cui:

L'esempio V8 seguente 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 questi servizi scrivono 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 esecuzioni

Per visualizzare la cronologia delle esecuzioni 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ù utilizzate 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 con 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 zucchero sintattico 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)

Distruzione dei compiti

Le espressioni di distruzione delle assegnazioni sono un modo rapido per decomprimere 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 modello

I valori letterali modello sono valori letterali stringa che consentono le espressioni incorporate. 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
var name = `Hi ${first} ${last}.`;
var url =
  `http://localhost:3000/api/messages/${id}`;

Parametri predefiniti

I parametri predefiniti ti consentono di specificare i valori predefiniti per i parametri della funzione nella dichiarazione della funzione. Ciò 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 multilinea utilizzando la stessa sintassi dei valori letterali modello. Come per i valori letterali dei modelli, questa sintassi consente di evitare concatenazioni di stringhe e di 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
var multiline = `This on the other hand,
actually is a multi-line string,
thanks to JavaScript ES6`;

Abilitazione del runtime V8

Se uno script utilizza il runtime Rhino, puoi passarlo alla versione 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 Attiva runtime Chrome V8.

In alternativa, puoi specificare direttamente il runtime dello script 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 campo runtimeVersion sul valore V8.
  6. In alto, fai clic su Salva progetto .

Nella sezione Migrazione degli script alla V8 vengono spiegati gli altri passaggi da seguire per garantire che lo script funzioni correttamente utilizzando V8.

Abilitazione del runtime Rhino

Se il tuo script utilizza V8 e devi cambiarlo per utilizzare il 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 Attiva runtime Chrome V8.

In alternativa, modifica il manifest del tuo 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. In alto, fai clic su Salva progetto .

Come faccio a eseguire la migrazione degli script esistenti?

La guida Migrazione degli script alla V8 descrive i passaggi da seguire per eseguire la migrazione di uno script esistente per utilizzare V8. Ciò comporta l'attivazione del runtime V8 e la verifica dello script alla ricerca di eventuali incompatibilità note.

Migrazione automatica degli script a V8

A partire dal 18 febbraio 2020, Google inizierà a migrare gradualmente alla versione V8 gli script esistenti che superano il nostro test automatico di compatibilità. 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. Puoi scegliere di eseguire la migrazione manuale dello script alla versione V8 in qualsiasi momento successivo.

Come faccio a segnalare bug?

La guida all'assistenza spiega come ricevere assistenza per la programmazione su Stack Overflow, eseguire ricerche nei report sui problemi esistenti, segnalare nuovi bug e richiedere nuove funzionalità.