V8-Laufzeit – Übersicht

In Apps Script und JavaScript enthält eine runtime oder runtime der JavaScript-Engine, die Skriptcode parst und ausführt. Die Laufzeit bietet Regeln für den Zugriff auf den Speicher, wie das Programm mit dem Speicher interagieren kann Betriebssystem des Computers und welche Programmsyntax zulässig ist. Jedes Web Der Browser verfügt über eine Laufzeitumgebung für JavaScript.

In der Vergangenheit wurde Apps Script von Mozillas Rhino JavaScript unterstützt. Dolmetscher. Rhino bot Apps Script eine bequeme Möglichkeit, Entwicklerskripts gearbeitet hat, verbinde es Apps Script mit einer bestimmten JavaScript-Version (ES5) Apps Script-Entwickler Moderne JavaScript-Syntax und -Funktionen können in Skripts mit Rhino nicht verwendet werden Laufzeit.

Um dieses Problem zu beheben, wird Apps Script jetzt vom V8-Laufzeit für Chrome und Node.js Sie können Vorhandene Skripts zu V8 migrieren um die Vorteile der modernen JavaScript-Syntax und -Funktionen zu nutzen.

Auf dieser Seite werden die neuen Funktionen von V8 beschrieben und wie Sie V8 aktivieren können. die Sie in Ihren Skripts verwenden können. Scripts zu V8 migrieren beschreibt Schritte zum Migrieren vorhandener Skripts zur Verwendung der V8-Laufzeit.

Features der V8-Laufzeit

Scripts, die die V8-Laufzeit verwenden, können von Folgendem profitieren: Funktionen:

Moderne ECMAScript-Syntax

Sie können modernes ECMAScript verwenden. -Syntax in Skripts verwenden, die von der V8-Laufzeit unterstützt werden. Diese Syntax umfasst let, const und viele weitere beliebte Funktionen.

Eine kurze Liste mit beliebten Elementen finden Sie in den Beispielen für die V8-Syntax. Syntaxverbesserungen, die Sie mit der V8-Laufzeit vornehmen können.

Verbesserte Funktionserkennung

Die Apps Script-Funktionserkennung wurde für Scripts mit V8 verbessert. Das neue die folgenden Funktionsdefinitionsformate erkennt:

      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 () => {}

Objektmethoden über Trigger und Callbacks aufrufen

Skripts, die V8 verwenden, können Objektmethoden und statische Methoden der Klasse von Orten aus aufrufen die bereits Bibliotheksmethoden aufrufen könnten. Dazu gehören die Folgendes:

• Manifest-Auslöser für Google Workspace-Add-ons
• Installierbare Trigger
• Menüpunkte in Google Workspace Editoren
• Nutzer-Callback-Funktionen wie in den Codebeispiel für ScriptApp.newStateToken().

Das folgende V8-Beispiel zeigt die Verwendung von Objektmethoden bei der Konstruktion Menüpunkte in Google Tabellen:

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');
  }
}

Logs ansehen

Apps Script bietet zwei Protokollierungsdienste: die Logger-Dienst und die Kurs console. Beide Dienste und Logs in denselben Stackdriver Logging-Dienst

Um die Logs Logger und console aufzurufen, klicken Sie oben im Skripteditor auf Ausführungsprotokoll:

Ausführungen ansehen

Wenn Sie sich den Ausführungsverlauf Ihres Skripts ansehen möchten, öffnen Sie das Apps Script-Projekt und rufen Sie klicken Sie links auf Ausführungen playlist_play.

Beispiele für V8-Syntax

Im Folgenden finden Sie eine kurze Liste beliebter syntaktischer Funktionen, Scripts mit der V8-Laufzeit verwenden.

let und const

Die let und const Mit Keywords können Sie lokale Variablen und den Umfang des Blockierungsumfangs definieren. Konstanten.

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

Pfeilfunktionen

Pfeilfunktionen bieten eine kompakte Möglichkeit, Funktionen innerhalb von Ausdrücken zu definieren.

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

Klassen

Kurse bieten eine Möglichkeit, Code konzeptionell und vererbt zu organisieren. Klassen in V8 in erster Linie syntaktischer Zucker gegenüber der auf dem JavaScript-Prototyp basierenden Vererbung sind.

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

Zuweisungen werden gelöscht

Aufgaben zerstören Ausdrücke sind eine schnelle Möglichkeit, Werte aus Arrays und Objekten Variablen definiert werden.

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


      

Vorlagenliterale

Vorlagenliterale sind Stringliterale, die eingebettete Ausdrücke zulassen. Sie ermöglichen es Ihnen, und komplexere Verkettungsanweisungen für Zeichenfolgen.

// 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}`;


      

Standardparameter

Standardparameter können Sie Standardwerte für Funktionsparameter in der Funktion angeben. Erklärung. Dies kann den Code im Funktionstext vereinfachen, da dabei müssen fehlenden Parametern explizit Standardwerte zuweisen.

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

      

Mehrzeilige Strings

Sie können mehrzeilige Strings mit derselben Syntax wie bei Vorlagenliteralen. Wie bei Vorlagenliteralen verwenden, können Sie mit dieser Syntax Stringverkettungen vermeiden und Zeichenfolgendefinitionen.

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

V8-Laufzeit aktivieren

Wenn ein Skript die Rhino-Laufzeit verwendet, können Sie es auf V8 umstellen, indem Sie Dazu gehen Sie so vor:

1. Öffnen Sie das Apps Script-Projekt.
2. Klicken Sie links auf Projekteinstellungen settings.
3. Klicken Sie das Kästchen Chrome V8-Laufzeit aktivieren an.

Alternativ können Sie die Skriptlaufzeit direkt angeben, indem Sie Skriptmanifest bearbeiten Datei:

1. Öffnen Sie das Apps Script-Projekt.
2. Klicken Sie links auf Projekteinstellungen settings.
3. Aktivieren Sie das Kontrollkästchen "appsscript.json" anzeigen Manifestdatei im Editor an.
4. Klicken Sie links auf Editor code > appsscript.json
5. Legen Sie in der Manifestdatei appsscript.json Folgendes fest: runtimeVersion auf den Wert V8.
6. Klicken Sie oben auf Projekt speichern save.

Informationen zur Migration von Skripts zu V8 weitere Schritte, die Sie ausführen sollten, um sicherzustellen, dass Ihr Skript mit V8 einwandfrei funktioniert.

Rhino-Laufzeit aktivieren

Wenn Ihr Script V8 verwendet und Sie es auf die ursprüngliche Version umstellen müssen Rhino-Laufzeit:

1. Öffnen Sie das Apps Script-Projekt.
2. Klicken Sie links auf Projekteinstellungen settings.
3. Entfernen Sie das Häkchen aus dem Kästchen Chrome V8-Laufzeit aktivieren.

Alternativ können Sie das Skriptmanifest bearbeiten:

1. Öffnen Sie das Apps Script-Projekt.
2. Klicken Sie links auf Projekteinstellungen settings.
3. Aktivieren Sie das Kontrollkästchen "appsscript.json" anzeigen Manifestdatei im Editor an.
4. Klicken Sie links auf Editor code > appsscript.json
5. Legen Sie in der Manifestdatei appsscript.json Folgendes fest: runtimeVersion auf den Wert DEPRECATED_ES5.
6. Klicken Sie oben auf Projekt speichern save.

Wie migriere ich vorhandene Skripts?

Die Anleitung zur Migration von Skripts zu V8 in dem die Schritte beschrieben werden, die Sie ausführen müssen, um ein verwenden Sie V8. Dazu müssen die V8-Laufzeit aktiviert und das Skript auf alle bekannten Inkompatibilitäten.

Automatische Migration von Skripts zu V8

Ab dem 18. Februar 2020 beginnt Google schrittweise mit der Migration bestehender die unseren automatisierten Kompatibilitätstest mit V8 bestehen. Betroffene Skripts nach der Migration wieder normal funktionieren.

Wenn Sie die automatische Migration für ein Skript deaktivieren möchten, legen Sie runtimeVersion in seinem Manifest auf DEPRECATED_ES5 gesetzt. Sie können manuell das Skript jederzeit zu V8 migrieren Zeit danach.

Wie melde ich Fehler?

Im Supportleitfaden wird erläutert, wie Sie programmieren können. auf Stack Overflow zu helfen, in vorhandenen Problemberichten zu suchen, neue Fehler zu melden und neue Funktionsanfragen stellen.