V8-Laufzeit – Übersicht

In Google 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-Laufzeitumgebung 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. Vorhandene Scripts zu V8 migrieren, um die moderne JavaScript-Syntax und die modernen Funktionen nutzen zu können.

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 zu V8 migrieren finden Sie eine Anleitung zur Migration vorhandener Scripts zur V8-Laufzeitumgebung.

Funktionen der V8-Laufzeitumgebung

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

Moderne ECMAScript-Syntax

Verwenden Sie in Scripts, die auf der V8-Laufzeitumgebung basieren, die moderne ECMAScript-Syntax. 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.

Die Apps Script V8-Laufzeitumgebung hat einige Einschränkungen und wichtige Unterschiede im Vergleich zu anderen gängigen JavaScript-Laufzeitumgebungen. Weitere Informationen finden Sie unter Einschränkungen der Apps Script V8-Laufzeitumgebung.

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üpunkten 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 Logger- und console-Logs aufrufen möchten, klicken Sie oben im Skripteditor auf Ausführungslog.

Ausführungen ansehen

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

Im Bereich Ausführungen sind keine Zeitstempel-Logs der einzelnen Apps Script-Dienstaufrufe verfügbar. Verwenden Sie den console-Dienst, um geeignete Logmeldungen zu erstellen. Alle mit console erstellten Logs werden im Bereich Ausführungen angezeigt.

V8-Syntaxbeispiele

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 und 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 in 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. So lassen sich 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

Mehrzeilige Strings werden mit derselben Syntax wie Template-Literale definiert. 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`;

Einschränkungen der V8-Laufzeitumgebung

Die Apps Script V8-Laufzeit ist keine Standard-Node.js- oder Browserumgebung. Dies kann zu Kompatibilitätsproblemen führen, wenn Sie Drittanbieterbibliotheken aufrufen oder Codebeispiele aus anderen JavaScript-Umgebungen anpassen.

Nicht verfügbare APIs

Die folgenden Standard-JavaScript-APIs sind in der Apps Script V8-Laufzeit NICHT verfügbar:

  • Timer: setTimeout, setInterval, clearTimeout, clearInterval
  • Streams: ReadableStream, WritableStream, TextEncoder, TextDecoder
  • Web-APIs: fetch, FormData, File, Blob, URL, URLSearchParams, DOMException, atob, btoa
  • Krypto: crypto, SubtleCrypto
  • Globale Objekte: window, navigator, performance, process (Node.js)

Verwenden Sie stattdessen die folgenden Apps Script-APIs:

Für APIs ohne Apps Script-Alternative, z. B. TextEncoder, können Sie manchmal ein Polyfill verwenden. Ein Polyfill ist eine Bibliothek, die API-Funktionen repliziert, die in der Laufzeitumgebung nicht standardmäßig verfügbar sind. Bevor Sie ein Polyfill verwenden, prüfen Sie, ob es mit der V8-Laufzeit von Apps Script kompatibel ist.

Asynchrone Einschränkungen

Die V8-Laufzeit unterstützt die Syntax async und await sowie das Objekt Promise. Die Apps Script-Laufzeitumgebung ist jedoch grundsätzlich synchron.

  • Microtasks (Unterstützt): Die Laufzeit verarbeitet die Microtask-Warteschlange (in der Promise.then-Rückrufe und await-Auflösungen erfolgen), nachdem der aktuelle Aufrufstack geleert wurde.
  • Makroaufgaben (nicht unterstützt): Apps Script hat keine Standardschleife für Makroaufgaben. Funktionen wie setTimeout und setInterval sind nicht verfügbar.
  • WebAssembly-Ausnahme: Die WebAssembly API ist die einzige integrierte Funktion, die nicht blockierend in der Laufzeit ausgeführt wird und bestimmte asynchrone Kompilierungsmuster (WebAssembly.instantiate) ermöglicht.

Alle E/A-Vorgänge, z. B. UrlFetchApp.fetch, sind blockierend. Verwenden Sie UrlFetchApp.fetchAll, um parallele Netzwerkanfragen zu stellen.

Einschränkungen bei Klassen

Für die V8-Laufzeitumgebung gelten bestimmte Einschränkungen in Bezug auf moderne ES6+-Klassenfunktionen:

  • Private Felder: Private Klassenfelder (z. B. #field) werden nicht unterstützt und führen zu Parsing-Fehlern. Verwenden Sie Closures oder WeakMap für eine echte Kapselung.
  • Statische Felder: Direkte statische Felddeklarationen im Klassenrumpf (z. B. static count = 0;) werden nicht unterstützt. Weisen Sie der Klasse nach ihrer Definition statische Eigenschaften zu (z. B. MyClass.count = 0;).

Einschränkungen bei Modulen

  • ES6-Module: Die V8-Laufzeit unterstützt keine ES6-Module (import / export). Wenn Sie Bibliotheken verwenden möchten, müssen Sie entweder den Apps Script-Bibliotheksmechanismus verwenden oder Ihren Code und seine Abhängigkeiten in einer einzigen Scriptdatei bündeln. (Issue Tracker)
  • Reihenfolge der Dateiausführung: Alle Skriptdateien in Ihrem Projekt werden in einem globalen Bereich ausgeführt. Vermeiden Sie am besten Code auf oberster Ebene mit Nebeneffekten und sorgen Sie dafür, dass Funktionen und Klassen definiert werden, bevor sie in Dateien verwendet werden. Ordnen Sie Ihre Dateien im Editor explizit an, wenn Abhängigkeiten zwischen ihnen bestehen.

V8-Laufzeit aktivieren

Wenn ein Script die Rhino-Laufzeit verwendet, wechseln Sie zur V8-Laufzeit. Gehen Sie dazu so vor:

  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. 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 Script 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 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 Skripts zu V8

Ab dem 18. Februar 2020 migriert Google vorhandene Skripts, die unseren automatischen Kompatibilitätstest bestehen, schrittweise zu V8. 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 Script 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 Feature Requests einreichen.