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 bietet Regeln für den Zugriff auf den Speicher, die Interaktion des Programms mit dem Betriebssystem des Computers und die zulässige Programmsyntax. 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 zu V8 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-Laufzeit 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 Logger- und console-Logs 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 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 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. 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

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

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 Standardereignisschleife für Makroaufgaben. Funktionen wie setTimeout und setInterval sind nicht verfügbar.
  • WebAssembly-Ausnahme: Die WebAssembly API ist das einzige integrierte Feature, das nicht blockierend in der Laufzeit ausgeführt wird. Dadurch sind bestimmte asynchrone Kompilierungsmuster (WebAssembly.instantiate) möglich.

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

Einschränkungen bei Kursen

Für die V8-Laufzeit 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 Skriptdatei 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 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-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 für die Verwendung von V8 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 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 jederzeit manuell zu V8 migrieren.

Wie melde ich Fehler?

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