V8-Laufzeit – Übersicht

In Apps Script und JavaScript enthält eine Laufzeit oder Laufzeitumgebung die JavaScript-Engine, die Skriptcode parst und ausführt. Die Laufzeit enthält Regeln dazu, wie auf den Speicher zugegriffen wird, wie das Programm mit dem Betriebssystem des Computers interagieren kann und welche Programmsyntax zulässig ist. Jeder Webbrowser hat eine Laufzeitumgebung für JavaScript.

In der Vergangenheit wurde Apps Script vom Rhino-JavaScript-Interpreter von Mozilla bereitgestellt. Rhino bot Apps Script eine bequeme Möglichkeit, Entwicklerskripts auszuführen. Es verknüpft Apps Script aber auch mit einer bestimmten JavaScript-Version (ES5). Apps Script-Entwickler können modernere JavaScript-Syntax und -Funktionen in Skripts mit der Rhino-Laufzeit nicht verwenden.

Apps Script wird jetzt von der V8-Laufzeit von Chrome und Node.js unterstützt. Sie können vorhandene Skripts zu V8 migrieren, um die moderne JavaScript-Syntax und -Funktionen zu nutzen.

Auf dieser Seite werden die neuen Funktionen beschrieben, die von V8 aktiviert werden, und wie Sie V8 für die Verwendung in Ihren Skripts aktivieren. Unter Scripts zu V8 migrieren werden Schritte zum Migrieren vorhandener Skripts zur V8-Laufzeit beschrieben.

Features der V8-Laufzeit

Skripts, die die V8-Laufzeit verwenden, können die folgenden Funktionen nutzen:

Moderne ECMAScript-Syntax

Sie können die moderne ECMAScript-Syntax in Skripts verwenden, die auf der V8-Laufzeit basieren. Diese Syntax umfasst let, const und viele andere beliebte Funktionen.

Eine kurze Liste mit gängigen Syntaxverbesserungen, die Sie mit der V8-Laufzeit vornehmen können, finden Sie unter V8-Syntaxbeispiele.

Verbesserte Funktionserkennung

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

      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

Scripts, die V8 verwenden, können Objektmethoden und statische Methoden der Klasse von Orten aus aufrufen, an denen Sie bereits Bibliotheksmethoden aufrufen konnten. Dazu gehören:

• Manifest-Auslöser für Google Workspace-Add-ons
• Installierbare Trigger
• Menüpunkte in Google Workspace Editoren
• Nutzerrückruffunktionen wie im ScriptApp.newStateToken()-Codebeispiel beschrieben.

Das folgende V8-Beispiel zeigt die Verwendung von Objektmethoden beim Erstellen von Menüelementen 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 Logging-Dienste: den Dienst Logger und die Klasse console. Beide Dienste schreiben Logs in denselben Stackdriver Logging-Dienst.

Wenn Sie die Logs Logger und console aufrufen möchten, 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 klicken Sie links auf Ausführungen playlist_play.

Beispiele für V8-Syntax

Im Folgenden finden Sie eine kurze Liste beliebter syntaktischer Funktionen, die für Skripts mit der V8-Laufzeit verfügbar sind.

let und const

Mit den Keywords let und const können Sie lokale Variablen des Blockbereichs bzw. Blockumfangkonstanten definieren.

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

Kurse

Klassen bieten eine Möglichkeit, Code mit Übernahme konzeptionell zu organisieren. Die Klassen in V8 sind in erster Linie syntaktischer Zucker gegenüber der auf JavaScript-Prototypen basierenden Vererbung.

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

Destrukturierende Zuweisungsausdrücke bieten eine schnelle Möglichkeit, Werte aus Arrays und Objekten in bestimmte Variablen zu entpacken.

// 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. Damit vermeiden Sie komplexere Anweisungen zur Zeichenfolgenverkettung.

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

Mit Standardparametern können Sie Standardwerte für Funktionsparameter in der Funktionsdeklaration angeben. Dies kann den Code im Funktionstext vereinfachen, da es fehlenden Parametern explizit Standardwerte zugewiesen werden muss.

// 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 Vorlagenliterale definieren. Wie bei Vorlagenliteralen können Sie mit dieser Syntax Stringverkettungen vermeiden und Stringdefinitionen vereinfachen.

// 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 sie so auf V8 umstellen:

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 die Skriptmanifestdatei bearbeiten:

1. Öffnen Sie das Apps Script-Projekt.
2. Klicken Sie links auf Projekteinstellungen settings.
3. Klicken Sie das Kästchen Manifestdatei „appsscript.json“ im Editor anzeigen an.
4. Klicken Sie links auf Editor code > appsscript.json.
5. Legen Sie in der Manifestdatei appsscript.json für das Feld runtimeVersion den Wert V8 fest.
6. Klicken Sie oben auf Projekt speichern save.

Unter Scripts zu V8 migrieren werden weitere Schritte erläutert, die Sie ausführen sollten, damit Ihr Skript mit V8 einwandfrei funktioniert.

Rhino-Laufzeit aktivieren

Wenn Ihr Skript V8 verwendet und Sie es auf die ursprüngliche Rhino-Laufzeit umstellen müssen, gehen Sie so vor:

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. Klicken Sie das Kästchen Manifestdatei „appsscript.json“ im Editor anzeigen an.
4. Klicken Sie links auf Editor code > appsscript.json.
5. Legen Sie in der Manifestdatei appsscript.json für das Feld runtimeVersion den Wert DEPRECATED_ES5 fest.
6. Klicken Sie oben auf Projekt speichern save.

Wie migriere ich vorhandene Skripts?

Im Leitfaden Scripts zu V8 migrieren werden die Schritte beschrieben, die Sie ausführen müssen, um ein vorhandenes Script auf V8 zu migrieren. Dazu müssen Sie die V8-Laufzeit aktivieren und das Skript auf bekannte Inkompatibilitäten prüfen.

Automatische Migration von Skripts zu V8

Ab dem 18. Februar 2020 werden wir vorhandene Skripts, die unseren automatisierten Kompatibilitätstest bestehen, nach und nach zu V8 migrieren. Die betroffenen Skripts funktionieren nach der Migration weiterhin normal.

Wenn Sie die automatische Migration für ein Skript deaktivieren möchten, legen Sie das Feld runtimeVersion im Manifest auf DEPRECATED_ES5 fest. Sie können das Skript jederzeit manuell zu V8 migrieren.

Wie melde ich Fehler?

Im Supportleitfaden wird erläutert, wie Sie auf Stack Overflow Programmierhilfe erhalten, in vorhandenen Problemberichten suchen, neue Fehler melden und neue Funktionsanfragen stellen.