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 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 zwar eine bequeme Möglichkeit für Apps Script zum Ausführen von Entwicklerskripts, wurde aber auch an eine bestimmte JavaScript-Version (ES5) gebunden. Apps Script-Entwickler können keine modernere JavaScript-Syntax und -Funktionen in Skripts verwenden, die die Rhino-Laufzeit verwenden.

Aus diesem Grund wird Apps Script jetzt von der V8-Laufzeit 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. Außerdem erfahren Sie, 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

Für Skripts, die die V8-Laufzeit verwenden, stehen folgende Funktionen zur Verfügung:

Moderne ECMAScript-Syntax

Sie können die moderne ECMAScript-Syntax in Skripts verwenden, die von der V8-Laufzeit unterstützt werden. Diese Syntax umfasst let, const und viele weitere beliebte Features.

Eine kurze Liste beliebter Syntaxverbesserungen, die Sie mit der V8-Laufzeit vornehmen können, finden Sie unter V8-Syntaxbeispiele.

Verbesserte Funktionserkennung

Die Apps Script-Funktionserkennung wurde für Skripts mit V8 verbessert. Die neue Laufzeit erkennt diese Funktionsdefinitionsformate:

      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üpunkten 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ührungsprotokoll, um die Protokolle 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 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 innerhalb von 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 eine Möglichkeit, Code konzeptionell zu organisieren und zu übernehmen. Klassen in V8 sind primär syntaktischer Zucker anstelle der auf JavaScript-Prototypen basierenden 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

Mit Zuweisungsausdrücken zerstören können Sie Werte aus Arrays und Objekten schnell in eindeutige Variablen 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 zulassen. 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 in der Funktionsdeklaration Standardwerte für Funktionsparameter 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 mit den folgenden Schritten 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 Manifestdatei "appsscript.json" im Editor anzeigen an.
  4. Klicken Sie links auf Editor > appsscript.json.
  5. Legen Sie in der Manifestdatei appsscript.json für das Feld runtimeVersion 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, damit 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 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 für das Feld runtimeVersion 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 muss die V8-Laufzeit aktiviert und das Skript auf bekannte Inkompatibilitäten geprüft werden.

Automatische Migration von Skripts zu V8

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

Wenn Sie die automatische Migration für ein Skript 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.