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 udostępnia reguły dostępu do pamięci, sposób interakcji programu z systemem operacyjnym komputera oraz legalną składnię programu. Każda przeglądarka ma swoje środowisko wykonawcze dla JavaScriptu.

Dawniej Apps Script opierał się na interpreterze JavaScriptu Rhino firmy Mozilla. Rhino zapewniał wygodny sposób wykonywania skryptów programistycznych przez Apps Script, a jednocześnie wiązał Apps Script z konkretną wersją JavaScriptu (ES5). Deweloperzy Apps Script nie mogą używać w skryptach bardziej nowoczesnej składni ani funkcji JavaScriptu w środowisku wykonawczym Rhino.

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

Na tej stronie opisujemy nowe funkcje dostępne w wersji 8 i opisujemy, jak włączyć V8 do użycia w skryptach. Migracja skryptów do wersji 8 zawiera opis 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 obsługiwanych przez środowisko wykonawcze V8 możesz używać nowoczesnej składni ECMAScript. Obejmuje ona let, const i wiele innych popularnych funkcji.

W przykładach składni V8 znajdziesz krótką listę popularnych ulepszeń składni, które możesz wprowadzić w środowisku wykonawczym V8.

Ulepszone wykrywanie funkcji

Wykrywanie funkcji Apps Script zostało ulepszone w przypadku skryptów korzystających z wersji 8. Nowe środowisko wykonawcze 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łuj metody obiektów z aktywatorów i wywołań zwrotnych

Skrypty używające V8 mogą wywoływać metody obiektów i metody statyczne klas z miejsc, w których można wywoływać metody biblioteki. Są to m.in.:

• Reguły w pliku manifestu dodatków do Google Workspace
• Aktywatory instalacyjne
• Pozycje menu w Google Workspace edytorach
• funkcji wywołań zwrotnych użytkownika, takich jak ta opisana w przykładowym kodzie ScriptApp.newStateToken();

Poniższy przykład w wersji 8 pokazuje wykorzystanie metod obiektów 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świetlanie logów

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

Aby wyświetlić logi Logger i console, u góry edytora skryptów kliknij Dziennik wykonywania.

Wyświetl uruchomienia

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

Przykłady składni V8

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

let i const

Słowa kluczowe let i const umożliwiają definiowanie zmiennych lokalnych zakresu bloku i stały zakresu 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ą kompaktowy 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ą koncepcyjną koncepcyjną uporządkowanie kodu z dziedziczeniem. Klasy w V8 są głównie cukrem składniowym zamiast dziedziczenia opartego na prototypie 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)
      

Niszczenie przypisań

Zniszczenie wyrażeń przypisań to szybki sposób na rozpakowywanie wartości z tablic i obiektów do odrębnych 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


      

Literały szablonów

Literały szablonów to literały tekstowe, które umożliwiają umieszczanie wyrażeń. Pozwalają one uniknąć bardziej złożonych instrukcji łączenia ciągów 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ślanie domyślnych wartości parametrów funkcji w deklaracji funkcji. Może to uprościć kod w treści funkcji, ponieważ eliminuje konieczność jawnego przypisywania 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 wielowierszowe

Ciągi tekstowe z wielowierszami możesz definiować przy użyciu tej samej składni co literały szablonu. Podobnie jak w przypadku literałów szablonów ta składnia pozwala uniknąć konkatenacji ciągów znaków i uprościć definicje ciągó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łączam środowisko wykonawcze V8

Jeśli skrypt korzysta ze środowiska wykonawczego Rhino, możesz przełączyć go na wersję 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 8.

Środowisko wykonawcze skryptu możesz też określić 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 Pokaż plik manifestu „appsscript.json” w edytorze.
4. Po lewej stronie kliknij Edytor code > appsscript.json.
5. W pliku manifestu appsscript.json ustaw pole runtimeVersion na wartość V8.
6. U góry kliknij Zapisz projekt save.

W artykule Migracja skryptów do wersji 8 wyjaśniamy, jakie inne kroki należy podjąć, aby zapewnić prawidłowe działanie skryptu w wersji 8.

Włączanie środowiska wykonawczego Rhino

Jeśli Twój skrypt korzysta z V8 i chcesz go przełączyć na oryginalne ś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 Pokaż plik manifestu „appsscript.json” w edytorze.
4. Po lewej stronie kliknij Edytor code > appsscript.json.
5. W pliku manifestu appsscript.json ustaw pole runtimeVersion na wartość DEPRECATED_ES5.
6. U góry kliknij Zapisz projekt save.

Jak przenieść istniejące skrypty?

Przewodnik Migracja skryptów do wersji 8 zawiera opis czynności, które musisz wykonać, aby przenieść istniejący skrypt do wersji 8. Wymaga to włączenia środowiska wykonawczego V8 i sprawdzenia skryptu pod kątem znanych niezgodności.

Automatyczna migracja skryptów do wersji 8

Od 18 lutego 2020 r. Google zacznie stopniowo przenosić do wersji 8 istniejące skrypty, które przeszły automatyczny test zgodności. Po migracji skrypty, których dotyczy problem, będą nadal działać normalnie.

Jeśli chcesz wyłączyć automatyczną migrację skryptu, ustaw pole runtimeVersion w pliku manifestu na DEPRECATED_ES5. W każdej chwili możesz ręcznie przenieść skrypt do wersji 8.

Jak zgłaszać błędy?

Z przewodnika po pomocy dowiesz się, jak uzyskać pomoc w zakresie programowania w Stack Overflow, przeszukiwać istniejące raporty o problemach, zgłaszać nowe błędy i zgłaszać prośby o nowe funkcje.