Panoramica del runtime V8

In Apps Script e JavaScript, un ambiente di runtime o di runtime contiene il motore JavaScript che analizza ed esegue il codice dello script. Il runtime fornisce regole su come si accede alla memoria, come il programma può interagire sistema operativo del computer e qual è la sintassi del programma legale. Ogni sito web un browser dispone di un ambiente di runtime per JavaScript.

Storicamente, Apps Script utilizza la tecnologia JavaScript Rhino di Mozilla come interprete. Sebbene Rhino fornisse un modo conveniente per l'esecuzione di Apps Script, per sviluppatori, associava anche Apps Script a una versione JavaScript specifica (ES5). Sviluppatori di Apps Script non è possibile utilizzare la sintassi e le funzioni JavaScript più moderne negli script che utilizzano Rhino runtime.

Per risolvere questo problema, Apps Script è ora supportato Runtime V8 alla base di Chrome e Node.js. Puoi eseguire la migrazione degli script esistenti alla versione V8 per sfruttare la moderna sintassi e funzionalità JavaScript.

In questa pagina vengono descritte le nuove funzionalità abilitate da V8 e come attivare V8 per l'uso nei tuoi script. Migrazione degli script alla versione V8 descrive la procedura per 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 i seguenti vantaggi caratteristiche:

Sintassi ECMAScript moderna

Puoi utilizzare il moderno file ECMAScript negli script basati sul runtime V8. Questa sintassi include let, const e molte altre funzionalità popolari.

Consulta gli esempi di sintassi V8 per un breve elenco delle principali miglioramenti della sintassi che puoi apportare con 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 delle librerie. Questi luoghi includono seguenti:

Il seguente esempio V8 mostra l'utilizzo di metodi oggetto durante la creazione 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: Logger e console. Entrambi i servizi di scrivere i log nello stesso Servizio Stackdriver Logging.

Per visualizzare i log Logger e console, fai clic nella parte superiore dell'editor di script Log Execution (Esecuzione).

Visualizza esecuzioni

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

Esempi di sintassi V8

Di seguito è riportato un breve elenco delle funzionalità sintattiche più diffuse a disposizione che utilizzano il runtime V8.

let e const

La let e const Le parole chiave ti consentono di definire le variabili locali con ambito a blocchi e costanti,

// 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

Funzioni delle frecce 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

Corsi forniscono un mezzo per organizzare concettualmente il codice con ereditarietà. Corsi 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

Compito in fase di distruzione sono un modo rapido per separare i valori da array e oggetti in diverse variabili.

// 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

Valori letterali modello sono valori letterali stringa che consentono espressioni incorporate. Ti permettono 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

Parametri predefiniti consente di specificare i valori predefiniti per i parametri della funzione nella funzione dichiarazione. Questo può semplificare il codice nel corpo della funzione in quanto rimuove il 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 multiriga utilizzando la stessa sintassi dei valori letterali modello. Come con i valori letterali del modello, 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 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 il runtime dello script direttamente modifica del manifest dello script file:

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

Spiegazione della migrazione degli script a V8 altri passaggi da seguire per assicurarti che lo script funzioni correttamente con V8.

Attivazione del runtime di Rhino

Se lo script utilizza V8 e devi cambiarlo per utilizzare la versione originale Durante il runtime di Rhino:

  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 dello script:

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

Come faccio a eseguire la migrazione degli script esistenti?

La pagina Migrazione degli script alla versione V8 descrive i passaggi da seguire per eseguire la migrazione di uno script esistente a V8. Ciò comporta l'abilitazione del runtime V8 e il controllo dello script per incompatibilità note.

Migrazione automatica degli script a V8

A partire dal 18 febbraio 2020, Google inizierà la migrazione graduale delle script che superano il nostro test automatico di compatibilità alla versione V8. Gli script interessati continuano a funzionare normalmente dopo la migrazione.

Se vuoi disattivare la migrazione automatica per uno script, imposta il valore runtimeVersion nel file manifest in DEPRECATED_ES5. Puoi scegliere di eseguire manualmente eseguire la migrazione dello script alla versione V8 in qualsiasi tempo dopo.

Come faccio a segnalare i bug?

La guida di assistenza spiega come iniziare a programmare aiuto su Stack Overflow, cercare report di problemi esistenti, segnalare nuovi bug e per effettuare nuove richieste di funzionalità.