V8-Laufzeit – Übersicht

In Apps Script und JavaScript enthält eine Laufzeit oder Laufzeitumgebung die JavaScript-Engine, die Skriptcode parst und ausführt. Die Laufzeitumgebung enthält Regeln dafür, 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.

Bisher wurde Apps Script vom Rhino JavaScript-Interpreter von Mozilla unterstützt. Rhino bot zwar eine praktische Möglichkeit für Apps Script, Entwicklerskripts auszuführen, band Apps Script aber auch an eine bestimmte JavaScript-Version (ES5). Apps Script-Entwickler können in Skripts, die die Rhino-Laufzeit verwenden, keine modernere JavaScript-Syntax und ‑Funktionen nutzen.

Um diesem Problem entgegenzuwirken, wird Apps Script jetzt von der V8-Laufzeitumgebung unterstützt, die Chrome und Node.js zugrunde liegt. 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 durch V8 aktiviert werden, und es wird erläutert, wie Sie V8 für die Verwendung in Ihren Skripts aktivieren können. Unter Scripts zur V8-Laufzeitumgebung migrieren finden Sie eine Anleitung zur Migration vorhandener Scripts zur V8-Laufzeitumgebung.

Funktionen der V8-Laufzeitumgebung

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

Moderne ECMAScript-Syntax

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

Unter V8-Syntaxbeispiele finden Sie eine kurze Liste beliebter Syntaxverbesserungen, die Sie mit der V8-Laufzeitumgebung vornehmen können.

Verbesserte Funktionserkennung

Die Erkennung von Apps Script-Funktionen wurde für Skripts, die V8 verwenden, verbessert. Die neue Laufzeit erkennt die folgenden Formate für Funktionsdefinitionen:

      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

In Scripts, die V8 verwenden, können Objektmethoden und statische Klassenmethoden an Stellen aufgerufen werden, an denen Sie bereits Bibliotheksmethoden aufrufen konnten. Dazu gehören:

Das folgende V8-Beispiel zeigt die Verwendung von Objektmethoden beim Erstellen von Menüelementen in Google Sheets:

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

Logs ansehen

Apps Script bietet zwei Logging-Dienste: den Logger-Dienst und die console-Klasse. Beide Dienste schreiben Logs in denselben Stackdriver Logging-Dienst.

Wenn Sie die Logs für Logger und console aufrufen möchten, klicken Sie oben im Skripteditor auf Ausführungslog.

Ausführungen ansehen

Wenn Sie den Ausführungsverlauf Ihres Scripts aufrufen möchten, öffnen Sie das Apps Script-Projekt und klicken Sie links auf Ausführungen .

Beispiele für die V8-Syntax

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

let und const

Mit den Schlüsselwörtern let und const können Sie lokale Variablen bzw. Konstanten mit Blockbereich definieren.

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

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

Klassen bieten eine Möglichkeit, Code mit Vererbung konzeptionell zu organisieren. Klassen in V8 sind in erster Linie syntaktischer Zucker für die prototypbasierte Vererbung in 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)

Destrukturierungszuweisungen

Destrukturierungszuweisung-Ausdrücke sind eine schnelle Möglichkeit, Werte aus Arrays und Objekten in separate 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 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

Template-Literale

Vorlagenliterale sind Stringliterale, die eingebettete Ausdrücke zulassen. Sie können damit komplexere Anweisungen zur Stringverkettung vermeiden.

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

Standardparameter

Mit Standardparametern können Sie Standardwerte für Funktionsparameter in der Funktionsdeklaration angeben. Dadurch kann der Code im Funktionsrumpf vereinfacht werden, da fehlenden Parametern nicht explizit Standardwerte zugewiesen werden müssen.

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

Mehrzeilige Strings

Sie können mehrzeilige Strings mit derselben Syntax wie Template-Literale definieren. Wie bei Template-Literalen 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
const 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 so auf V8 umstellen:

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

Alternativ können Sie die Skriptlaufzeit auch direkt angeben, indem Sie die Manifestdatei des Skripts bearbeiten:

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

Unter Scripts zu V8 migrieren finden Sie weitere Schritte, die Sie ausführen sollten, damit Ihr Script mit V8 gut funktioniert.

Rhino-Laufzeit aktivieren

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

  1. Öffnen Sie das Apps Script-Projekt.
  2. Klicken Sie links auf Projekteinstellungen .
  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 .
  3. Aktivieren Sie das Kästchen Manifestdatei „appsscript.json“ im Editor anzeigen.
  4. Klicken Sie links auf Editor > appsscript.json.
  5. Legen Sie in der Manifestdatei appsscript.json das Feld runtimeVersion auf den Wert DEPRECATED_ES5 fest.
  6. Klicken Sie oben auf Projekt speichern .

Wie migriere ich vorhandene Skripts?

Im Leitfaden zur Migration von Scripts zu V8 wird beschrieben, wie Sie ein vorhandenes Script migrieren, damit es V8 verwendet. Dazu müssen Sie die V8-Laufzeit aktivieren und das Skript auf bekannte Inkompatibilitäten prüfen.

Automatische Migration von Scripts zu V8

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

Wenn Sie ein Skript von der automatischen Migration ausschließen möchten, legen Sie das Feld runtimeVersion im Manifest auf DEPRECATED_ES5 fest. Sie können das Skript danach jederzeit manuell zu V8 migrieren.

Wie melde ich Fehler?

Im Supportleitfaden wird erläutert, wie Sie auf Stack Overflow Programmierhilfe erhalten, nach vorhandenen Fehlerberichten suchen, neue Fehler melden und neue Funktionsanfragen stellen können.