Przegląd środowiska wykonawczego V8

W Apps Script i JavaScript środowisko wykonawcze lub środowisko wykonawcze zawiera mechanizm JavaScript, który analizuje i wykonuje kod skryptu. Środowisko wykonawcze określa zasady dostępu do pamięci, sposoby interakcji programu z systemem operacyjnym komputera oraz prawidłową składnię programu. Każda przeglądarka ma środowisko uruchomieniowe dla JavaScriptu.

Do tej pory Apps Script korzystał z interpretera JavaScript Rhino firmy Mozilla. Chociaż Rhino zapewniał wygodny sposób wykonywania skryptów deweloperów w Apps Script, wiązał też Apps Script z określoną wersją JavaScript (ES5). Deweloperzy Apps Script nie mogą używać bardziej nowoczesnej składni i funkcji JavaScript w skryptach korzystających ze środowiska wykonawczego Rhino.

Aby rozwiązać ten problem, środowisko wykonawcze Apps Script jest teraz obsługiwane przez środowisko V8, które obsługuje Chrome i Node.js. Możesz przenosić istniejące skrypty do V8, aby korzystać z nowoczesnej składni i funkcji JavaScript.

Na tej stronie opisaliśmy nowe funkcje udostępnione przez V8 oraz sposób włączania V8 do użycia w skryptach. W artykule Przenoszenie skryptów do V8 opisano czynności, które należy wykonać, aby przenieść istniejące skrypty do środowiska wykonawczego V8.

Funkcje środowiska wykonawczego V8

Skrypty korzystające ze środowiska wykonawczego V8 mogą korzystać z tych funkcji:

Nowoczesna składnia ECMAScript

W skryptach używających środowiska wykonawczego V8 możesz używać nowoczesnej składni ECMAScript. Ta składnia obejmuje let, const i wiele innych popularnych funkcji.

Aby zobaczyć krótką listę popularnych ulepszeń składni, które możesz wprowadzić za pomocą środowiska wykonawczego V8, zapoznaj się z przykładami składni V8.

Ulepszone wykrywanie funkcji

W przypadku skryptów używających V8 poprawiono wykrywanie funkcji Apps Script. Nowy runtime rozpoznaje te formaty definicji funkcji:

      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 () => {}

Wywoływanie metod obiektu z pomocy wyzwalaczy i wyzwań zwrotnych

Skrypty korzystające z V8 mogą wywoływać metody obiektów i metody statyczne klas z miejsc, w których można już wywoływać metody biblioteki. Te miejsca to:

• wyzwalacze w pliku manifestu dodatków do Google Workspace.
• Wyzwalacze do zainstalowania
• Pozycje menu w  Google Workspace edytorze
• Funkcje wywołania zwrotnego użytkownika, takie jak opisana w przykładowym kodzie ScriptApp.newStateToken().

Ten przykład V8 pokazuje użycie metod obiektu podczas tworzenia elementów menu w Arkuszach Google:

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');
  }
}

Wyświetl logi

Apps Script udostępnia 2 usługi rejestrowania: usługę Logger i klasę console. Obie te usługi zapisują logi w tej samej usłudze Stackdriver Logging.

Aby wyświetlić dzienniki Logger i console, u góry edytora skryptu kliknij Dziennik wykonywania.

Wyświetlanie wykonanych zadań

Aby wyświetlić historię wykonania skryptu, otwórz projekt Apps Script i po lewej stronie kliknij Wykonania playlist_play.

Przykłady składni V8

Poniżej znajduje się krótka lista popularnych funkcji składniowych dostępnych dla skryptów korzystających z środowiska wykonawczego V8.

let i const

Słowa kluczowe let i const umożliwiają definiowanie odpowiednio zmiennych lokalnych w zakresie bloku i stałych w zakresie bloku.

// 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
      

Funkcje strzałek

Funkcje strzałek zapewniają zwięzły sposób definiowania funkcji w wyrażeniach.

// 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));
      

Zajęcia

Klasy umożliwiają porządkowanie kodu za pomocą dziedziczenia. Klasy w V8 są głównie cukrem składniczym dla dziedziczenia na podstawie prototypu w 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)
      

Przekształcanie przypisań

Wyrażenia przypisania z przekształcaniem to szybki sposób na rozpakowanie wartości z tablic i obiektów do oddzielnych zmiennych.

// 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


      

Literaly szablonu

Składniki szablonu to ciągi znaków, które umożliwiają umieszczanie wyrażeń. Dzięki nim można uniknąć bardziej skomplikowanych instrukcji łańcucha znaków.

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


      

Parametry domyślne

Parametry domyślne umożliwiają określenie domyślnych wartości parametrów funkcji w deklaracji funkcji. Może to uprościć kod w ciele funkcji, ponieważ nie trzeba już jawnie przypisywać wartości domyślnych do brakujących parametrów.

// 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!"

      

Ciągi znaków wielowierszowych

Możesz definiować wielolinijkowe ciągi znaków za pomocą tej samej składni co literaly szablonu. Podobnie jak w przypadku literaliów szablonów, ta składnia pozwala uniknąć konkatenacji ciągów znaków i uprościć definicje ciągów znaków.

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

Włączanie środowiska wykonawczego V8

Jeśli skrypt korzysta ze środowiska wykonawczego Rhino, możesz przełączyć go na V8, wykonując te czynności:

1. Otwórz projekt Apps Script.
2. Po lewej stronie kliknij Ustawienia projektu settings.
3. Zaznacz pole wyboru Włącz środowisko wykonawcze Chrome V8.

Możesz też określić środowisko wykonawcze skryptu bezpośrednio, edytując plik manifestu skryptu:

1. Otwórz projekt Apps Script.
2. Po lewej stronie kliknij Ustawienia projektu settings.
3. Zaznacz pole wyboru Wyświetlaj plik manifestu „appsscript.json” w edytorze.
4. Po lewej stronie kliknij Edytor code > appsscript.json.
5. W pliku manifestu appsscript.json ustaw wartość pola runtimeVersion na V8.
6. U góry kliknij Zapisz projekt save.

W artykule Konwertowanie skryptów na V8 znajdziesz inne wskazówki, które pomogą Ci zapewnić prawidłowe działanie skryptu w V8.

Włączanie środowiska wykonawczego Rhino

Jeśli skrypt korzysta z V8 i musisz przełączyć go na pierwotne środowisko wykonawcze Rhino, wykonaj te czynności:

1. Otwórz projekt Apps Script.
2. Po lewej stronie kliknij Ustawienia projektu settings.
3. Odznacz pole wyboru Włącz środowisko wykonawcze Chrome 8.

Możesz też edytować plik manifestu skryptu:

1. Otwórz projekt Apps Script.
2. Po lewej stronie kliknij Ustawienia projektu settings.
3. Zaznacz pole wyboru Wyświetlaj plik manifestu „appsscript.json” w edytorze.
4. Po lewej stronie kliknij Edytor code > appsscript.json.
5. W pliku manifestu appsscript.json ustaw wartość pola runtimeVersion na DEPRECATED_ES5.
6. U góry kliknij Zapisz projekt save.

Jak przenieść istniejące skrypty?

W przewodniku Migrowanie skryptów do V8 opisano czynności, które należy wykonać, aby przenieść istniejący skrypt do korzystania z V8. Polega to na włączeniu środowiska wykonawczego V8 i sprawdzeniu, czy skrypt nie zawiera żadnych znanych niezgodności.

Automatyczna migracja skryptów do V8

Od 18 lutego 2020 r. Google zacznie stopniowo przenosić istniejące skrypty, które przejdą nasz automatyczny test zgodności, do V8. Po migracji te skrypty będą działać normalnie.

Jeśli chcesz wykluczyć skrypt z automatycznej migracji, ustaw w pliku manifestu pole runtimeVersion na DEPRECATED_ES5. W każdej chwili możesz ręcznie przenieść skrypt do V8.

Jak zgłaszać błędy?

Przewodnik po pomocy zawiera informacje o tym, jak uzyskać pomoc programistów na Stack Overflow, wyszukiwać istniejące raporty o problemach, zgłaszać nowe błędy oraz zgłaszać prośby o dodanie nowych funkcji.