Übersicht zur V8-Laufzeitumgebung

In Apps Script und JavaScript enthält eine Laufzeit oder Laufzeitumgebung die JavaScript-Engine, die den Skriptcode parst und ausführt. Die Laufzeit enthält Regeln dazu, wie auf den Arbeitsspeicher 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 JavaScript-Interpreter Rhino von Mozilla unterstützt. Rhino bot Apps Script zwar eine bequeme Möglichkeit, Entwicklerskripts auszuführen, es hat aber auch Apps Script an eine bestimmte JavaScript-Version (ES5) gebunden. Apps Script-Entwickler können modernere JavaScript-Syntax und -Funktionen in Skripts mit der Rhino-Laufzeit nicht verwenden.

Aus diesem Grund wird Apps Script jetzt von der V8-Laufzeit unterstützt, die Chrome und Node.js unterstützt. 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 Features beschrieben, die von V8 aktiviert werden, und wie Sie V8 für die Verwendung in Ihren Skripts aktivieren können. Unter Skripts zu V8 migrieren werden Schritte zum Migrieren vorhandener Skripts zur Verwendung der 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 Features.

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

Verbesserte Funktionserkennung

Die Funktionserkennung für Apps Script wurde für Skripts mit Version 8 verbessert. In der neuen Laufzeit werden die folgenden Funktionsdefinitionsformate erkannt:

      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 aus Triggern und Callbacks aufrufen

Skripts, die V8 verwenden, können Objektmethoden und statische Klassenmethoden von Orten aufrufen, 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 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.

Klicken Sie oben im Skripteditor auf Ausführungslog, um die Logs Logger und console aufzurufen.

Ausführungen ansehen

Öffnen Sie zum Aufrufen des Ausführungsverlaufs Ihres Skripts 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 Features, 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. Blockbereichskonstanten 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

Mit Pfeilfunktionen können Sie Funktionen in Ausdrücken kompakt 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 die Möglichkeit, Code konzeptionell zu organisieren und zu übernehmen. Die Klassen in V8 sind in erster Linie syntaktischer Zucker statt der auf Prototypen basierenden JavaScript-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

Zuweisungsausdrücke zerstören sind eine schnelle Möglichkeit, Werte aus Arrays und Objekten in unterschiedliche 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 ermöglichen. Damit können Sie komplexere Stringverkettungsanweisungen vermeiden.

// 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 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
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 wie folgt zu V8 wechseln:

  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 direkt angeben, indem Sie die Skriptmanifestdatei bearbeiten:

  1. Öffnen Sie das Apps Script-Projekt.
  2. Klicken Sie links auf Projekteinstellungen .
  3. Klicken Sie das Kästchen "appsscript.json"-Manifestdatei im Editor anzeigen an.
  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 Skripts zu V8 migrieren werden weitere Schritte beschrieben, die Sie ausführen sollten, um sicherzustellen, dass 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 .
  3. Entfernen Sie das Häkchen aus dem Kästchen Chrome V8-Laufzeit aktivieren.

Alternativ können Sie Ihr Skriptmanifest bearbeiten:

  1. Öffnen Sie das Apps Script-Projekt.
  2. Klicken Sie links auf Projekteinstellungen .
  3. Klicken Sie das Kästchen "appsscript.json"-Manifestdatei im Editor anzeigen an.
  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?

In der Anleitung Skripts zu V8 migrieren werden die Schritte beschrieben, die Sie ausführen müssen, um ein vorhandenes Skript zu 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 migriert Google schrittweise vorhandene Skripts, die unseren automatischen Kompatibilitätstest bestehen, zu V8. Die betroffenen Skripts funktionieren nach der Migration weiterhin normal.

Wenn Sie die automatische Migration eines Skripts deaktivieren möchten, setzen Sie das Feld runtimeVersion in seinem Manifest auf DEPRECATED_ES5. Sie können das Skript anschließend 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.