Visão geral do ambiente de execução do V8

No Apps Script e JavaScript, um ambiente de execução ou ambiente de execução contém o mecanismo JavaScript que analisa e executa o código de script. O ambiente de execução oferece de acesso à memória, como o programa pode interagir com os sistema operacional do computador e qual sintaxe de programa é legal. Cada rede navegador tem um ambiente de execução para JavaScript.

Historicamente, o Apps Script usa a tecnologia do Rhino JavaScript do Mozilla intérprete. Embora o Rhino ofereça uma maneira conveniente de executar o Apps Script os scripts do desenvolvedor, ele também vinculou o Apps Script a uma versão específica do JavaScript, (ES5). Desenvolvedores do Apps Script não é possível usar sintaxes e recursos mais modernos do JavaScript em scripts usando o Rhino no ambiente de execução.

Para resolver esse problema, o Apps Script agora tem suporte da Ambiente de execução V8 usado no Chrome e no Node.js. Você pode migrar scripts para o V8 para aproveitar a sintaxe e os recursos modernos do JavaScript.

Esta página descreve os novos recursos habilitados pelo V8 e como você pode ativar o V8 para uso em seus scripts. Como migrar scripts para a V8 descreve as etapas de migração de scripts existentes para usar o ambiente de execução do V8.

Recursos do ambiente de execução do V8

Os scripts que usam o tempo de execução do V8 aproveitam os seguintes recursos: recursos:

Sintaxe moderna do ECMAScript

Você pode usar o ECMAScript moderno em scripts com tecnologia do ambiente de execução do V8. Essa sintaxe inclui let, const e muitos outros recursos conhecidos.

Consulte os exemplos de sintaxe da V8 para ver uma pequena lista das melhorias de sintaxe que podem ser feitas usando o tempo de execução do V8.

Detecção de função aprimorada

A detecção de funções do Apps Script foi aprimorada para scripts que usam a V8. A nova O ambiente de execução reconhece estes formatos de definição de função:

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

Chamar métodos de objeto de gatilhos e callbacks

Os scripts que usam o V8 podem chamar métodos de objeto e métodos estáticos de classe de locais em que você já poderia chamar métodos da biblioteca. Esses locais incluem seguinte:

• Acionadores do manifesto de complementos do Google Workspace
• Acionadores instaláveis
• Itens do menu em Google Workspace editores
• Funções de callback do usuário, como a descrita no Exemplo de código ScriptApp.newStateToken().

O exemplo do V8 a seguir mostra o uso de métodos de objeto na construção itens de menu do Planilhas 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');
  }
}

Ver registros

O Apps Script oferece dois serviços de geração de registros: serviço Logger e os console. Ambos os serviços gravar registros no mesmo Serviço Stackdriver Logging.

Para mostrar os registros Logger e console, na parte superior do editor de script, clique em Registro de execução.

Conferir execuções

Para acessar o histórico de execução do seu script, abra o projeto do Apps Script e, em À esquerda, clique em Execuções playlist_play.

Exemplos de sintaxe do V8

A seguir está uma pequena lista de recursos sintáticos populares disponíveis para usando o ambiente de execução V8.

let e const

O let e const permitem que você defina as variáveis locais e o escopo do bloco , respectivamente.

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

Funções de seta

Funções de seta oferecem uma maneira compacta de definir funções dentro de expressões.

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

Classes

Turmas oferecem um meio de organizar conceitualmente o código com herança. Classes no V8 são principalmente facilidade sintáticas em vez da herança baseada em protótipos 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)
      

Como desestruturar atribuições

Atribuição de desestruturação as expressões são uma maneira rápida de descompactar valores de matrizes e objetos em variáveis distintas.

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


      

Literais de modelo

Literais de modelo são literais de string que permitem expressões incorporadas. Eles permitem evitar instruções de concatenação de strings mais complexas.

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


      

Parâmetros padrão

Parâmetros padrão permitem especificar valores padrão para parâmetros de função na função declaração de serviço. Isso pode simplificar o código no corpo da função, pois remove o atribuir explicitamente valores padrão aos parâmetros ausentes.

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

      

Strings de várias linhas

É possível definir strings de várias linhas usando a mesma sintaxe dos literais de modelos. Assim como acontece com literais de modelo, essa sintaxe permite evitar concatenações de strings e simplificar definições de strings.

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

Como ativar o ambiente de execução do V8

Se um script estiver usando o tempo de execução do Rhino, mude para o V8. fazendo o seguinte:

1. Abra o projeto do Apps Script.
2. À esquerda, clique em Configurações do projeto settings.
3. Marque a caixa de seleção Ativar o Chrome V8 Runtime.

Também é possível especificar o ambiente de execução do script diretamente editar o manifesto do script arquivo:

1. Abra o projeto do Apps Script.
2. À esquerda, clique em Configurações do projeto settings.
3. Selecione a caixa de seleção Mostrar arquivo de manifesto "appsscript.json" no editor.
4. À esquerda, clique em Editor code > appsscript.json;
5. No arquivo de manifesto appsscript.json, defina o runtimeVersion para o valor V8.
6. Na parte de cima, clique em Salvar projeto save.

Como migrar scripts para o V8 explica outras etapas que você deve seguir para garantir que seu script funcione bem com o V8.

Ativar o ambiente de execução do Rhino

Se seu script usar o V8 e você precisar alterá-lo para usar o original ambiente de execução do Rhino, faça o seguinte:

1. Abra o projeto do Apps Script.
2. À esquerda, clique em Configurações do projeto settings.
3. Desmarque a caixa de seleção Ativar o tempo de execução do Chrome V8.

Como alternativa, edite o manifesto do script:

1. Abra o projeto do Apps Script.
2. À esquerda, clique em Configurações do projeto settings.
3. Selecione a caixa de seleção Mostrar arquivo de manifesto "appsscript.json" no editor.
4. À esquerda, clique em Editor code > appsscript.json;
5. No arquivo de manifesto appsscript.json, defina o runtimeVersion para o valor DEPRECATED_ES5.
6. Na parte de cima, clique em Salvar projeto save.

Como faço para migrar scripts existentes?

Como migrar scripts para o V8 descreve as etapas necessárias para migrar um script existente para usar o V8. Isso envolve ativar o tempo de execução do V8 e verificar se o script incompatibilidades conhecidas.

Migração automática de scripts para o V8

A partir de 18 de fevereiro de 2020, o Google começará a migração gradual das contas scripts que passam no teste de compatibilidade automatizado para o V8. Os scripts afetados continuam funcionando normalmente após a migração.

Se você quiser desativar a migração automática por um script, defina o runtimeVersion no manifesto para DEPRECATED_ES5. É possível fazer isso manualmente migrar o script para o V8 a qualquer tempo depois.

Como faço para informar bugs?

O Guia de suporte explica como instalar aplicativos ajudar no Stack Overflow, pesquisar relatórios de problemas existentes, registrar novos bugs e fazer novas solicitações de atributos.