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 Laufzeit bietet Regeln für den Zugriff auf den Arbeitsspeicher, 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 dieses Problem zu beheben, wird Apps Script jetzt von der V8-Laufzeit unterstützt, die Chrome und Node.js zugrunde liegt. Migrieren Sie vorhandene Skripts zu V8, um die moderne JavaScript-Syntax und ‑Funktionen zu nutzen.

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

Funktionen der V8-Laufzeit

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

Moderne ECMAScript-Syntax

Verwenden Sie in Skripts, die von der V8-Laufzeit unterstützt werden, die moderne ECMAScript Syntax. Diese Syntax umfasst let, const und viele andere beliebte Funktionen.

Unter V8-Syntaxbeispiele finden Sie eine kurze Liste beliebter Syntax verbesserungen, die Sie mit der V8-Laufzeit vornehmen können.

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

Verbesserte Funktionserkennung

Die Apps Script-Funktionserkennung wurde für Skripts mit V8 verbessert. Die neue Laufzeit erkennt die folgenden Formate für die Funktionsdefinition:

      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 Rückrufen aufrufen

Skripts, die V8 verwenden, können Objektmethoden und statische Methoden der Klasse von Stellen aus 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 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 anzeigen möchten, klicken Sie oben im Skripteditor auf Ausführungsprotokoll.

Ausführungen ansehen

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

Im Bereich Ausführungen werden keine mit Zeitstempeln versehenen Logs der einzelnen Apps Script-Dienstanrufe angezeigt. Verwenden Sie den console Dienst, um entsprechende Logmeldungen zu erstellen. Alle mit console erstellten Logs werden im Bereich Ausführungen angezeigt.

V8-Syntaxbeispiele

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

let und const

Mit den let und const Schlüsselwörtern 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 konzeptionell mit Vererbung zu organisieren. Klassen in V8 sind in erster Linie syntaktischer Zucker für die auf JavaScript-Prototypen basierende 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)

Destrukturierungszuweisungen

Destrukturierungszuweisungsausdrü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

Vorlagenliterale

Vorlagenliterale sind Stringliterale, die eingebettete Ausdrücke ermöglichen. So können Sie 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

Standardparameter ermöglichen es Ihnen, Standardwerte für Funktionsparameter in der Funktions deklaration anzugeben. Dadurch kann der Code im Funktionskörper vereinfacht werden, da keine Standardwerte für fehlende Parameter explizit 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

Definieren Sie mehrzeilige Strings mit derselben Syntax wie Vorlagenliterale. 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
const multiline = `This on the other hand,
actually is a multi-line string,
thanks to JavaScript ES6`;

Einschränkungen der V8-Laufzeit

Die Apps Script V8-Laufzeit ist keine Standard-Node.js- oder Browserumgebung. Dies kann zu Kompatibilitätsproblemen führen, wenn Sie Bibliotheken von Drittanbietern 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
  • Crypto: 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 nachbildet, die in der Laufzeitumgebung standardmäßig nicht 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.

  • Mikroaufgaben (unterstützt): Die Laufzeit verarbeitet die Mikroaufgabenwarteschlange (in der Promise.then Rückrufe und await Auflösungen auftreten), nachdem der aktuelle Aufrufstack gelöscht 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 in der Laufzeit nicht blockierend arbeitet und bestimmte asynchrone Kompilierungsmuster ermöglicht (WebAssembly.instantiate).

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

Einschränkungen bei Klassen

Die V8-Laufzeit hat bestimmte Einschränkungen in Bezug auf moderne ES6+-Klassenfunktionen:

  • Private Felder: Private Klassenfelder (z. B. #field) werden nicht unterstützt und verursachen Parsingfehler. Verwenden Sie stattdessen Closures oder WeakMap für eine echte Kapselung.
  • Statische Felder: Direkte statische Felddeklarationen im Klassenkörper (z. B. static count = 0;) werden nicht unterstützt. Weisen Sie der Klasse nach der Definition statische Attribute 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. (Problem verfolgung)
  • Reihenfolge der Dateiausführung: Alle Skriptdateien in Ihrem Projekt werden in einem globalen Bereich ausgeführt. Vermeiden Sie Code auf oberster Ebene mit Nebeneffekten und stellen Sie sicher, dass Funktionen und Klassen definiert werden, bevor sie in verschiedenen 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, wechseln Sie so zu V8:

  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 Manifestdatei „appsscript.json“ im Editor anzeigen an.
  4. Klicken Sie links auf Editor > appsscript.json.
  5. Legen Sie in der Manifestdatei appsscript.json das runtimeVersion Feld 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 ordnungsgemäß funktioniert.

Rhino-Laufzeit aktivieren

Wenn Ihr Skript V8 verwendet und Sie zur ursprünglichen Rhino-Laufzeit wechseln 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. Klicken Sie das Kästchen Manifestdatei „appsscript.json“ 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?

Im Leitfaden Skripts zu V8 migrieren werden die Schritte beschrieben, die Sie ausführen müssen, um ein vorhandenes Skript zur Verwendung von 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 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 runtimeVersion Feld im Manifest auf DEPRECATED_ES5 fest. Sie können das Skript jederzeit manuell zu V8 migrieren

Wie melde ich Fehler?

Im Supportleitfaden wird erklärt, wie Sie auf Stack Overflow Programmierhilfe erhalten, nach vorhandenen Problemberichten suchen, neue Fehler melden und neue Feature Requests einreichen.