V8-Laufzeit – Übersicht

In Apps Script und JavaScript enthält eine Laufzeit oder Laufzeitumgebung die JavaScript-Engine, die Skriptcode analysiert und ausführt. Die Laufzeitumgebung legt fest, 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.

Bisher wurde Apps Script vom Rhino-JavaScript-Interpreter von Mozilla unterstützt. Rhino bot zwar eine praktische Möglichkeit, Entwicklerscripts in Apps Script auszuführen, band Apps Script aber auch an eine bestimmte JavaScript-Version (ES5) fest. Apps Script-Entwickler können in Scripts, die die Rhino-Laufzeit verwenden, keine modernere JavaScript-Syntax und keine modernen JavaScript-Funktionen verwenden.

Um dieses Problem zu beheben, wird Apps Script jetzt von der V8-Laufzeit unterstützt, die auch für Chrome und Node.js verwendet wird. Sie können vorhandene Scripts 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 wie Sie V8 für die Verwendung in Ihren Scripts aktivieren können. Im Hilfeartikel Scripts zu V8 migrieren werden die Schritte zum Migrieren vorhandener Scripts zur Verwendung der V8-Laufzeit beschrieben.

Funktionen der V8-Laufzeit

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

Moderne ECMAScript-Syntax

Sie können die moderne ECMAScript-Syntax in Scripts verwenden, die auf der V8-Laufzeit basieren. Dazu gehören let, const und viele andere beliebte Funktionen.

Unter Beispiele für die V8-Syntax 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 Scripts mit V8 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

Scripts mit V8 können Objektmethoden und statische Klassenmethoden an Stellen aufrufen, an denen bereits Bibliotheksmethoden aufgerufen werden können. 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 Logger-Dienst und die console-Klasse. Beide Dienste schreiben Protokolle in denselben Stackdriver Logging-Dienst.

Wenn Sie Logger- und console-Protokolle anzeigen möchten, klicken Sie oben im Script-Editor auf Ausführungsprotokoll.

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 jeweils lokale Variablen und Konstanten im Blockumfang 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 Funktionen innerhalb von Ausdrücken kompakt definiert werden.

// 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 mithilfe der Vererbung konzeptionell zu organisieren. Klassen in V8 sind in erster Linie eine Syntaxerweiterung für die JavaScript-basierte prototypbasierte 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)

Aufgaben destrukturieren

Mit Destrukturierungszuweisungen können Sie Werte aus Arrays und Objekten schnell in separate 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

Template-Literale sind Stringliterale, die eingebettete Ausdrücke zulassen. So lassen sich komplexere Stringkonkatenierungsanweisungen 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 Funktionskörper vereinfachen, da fehlenden Parametern keine Standardwerte mehr 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
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 Template-Literals definieren. Wie bei Vorlagenliteralen können Sie mit dieser Syntax Stringkonkatenationen 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 für ein Script die Rhino-Laufzeit verwendet wird, können Sie zu V8 wechseln. 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 Scriptlaufzeit direkt angeben, indem Sie das Script-Manifest 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 Bearbeiter > 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 .

Im Hilfeartikel Scripts zu V8 migrieren werden weitere Schritte beschrieben, die Sie ausführen sollten, damit Ihr Script mit V8 ordnungsgemäß funktioniert.

Rhino-Laufzeit aktivieren

Wenn in Ihrem Script V8 verwendet wird und Sie zur ursprünglichen Rhino-Laufzeit wechseln möchten, 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 auch das Script-Manifest 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 Bearbeiter > 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 Scripts?

Im Leitfaden Scripts zu V8 migrieren werden die Schritte beschrieben, die Sie ausführen müssen, um ein vorhandenes Script auf V8 umzustellen. Dazu müssen Sie die V8-Laufzeit aktivieren und das Script auf bekannte Inkompatibilitäten prüfen.

Automatische Migration von Scripts zu V8

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

Wenn Sie die automatische Migration für ein Script deaktivieren möchten, setzen Sie das Feld runtimeVersion im Manifest auf DEPRECATED_ES5. Sie können das Script danach jederzeit manuell auf V8 umstellen.

Wie melde ich Fehler?

Im Supportleitfaden wird erläutert, wie Sie auf Stack Overflow Hilfe zu Programmierfragen erhalten, nach vorhandenen Problemberichten suchen, neue Fehler melden und neue Funktionsanfragen stellen.