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

No Apps Script e no JavaScript, um ambiente de execução ou de execução contém o mecanismo JavaScript que analisa e executa o código do script. O ambiente de execução fornece regras sobre como a memória é acessada, como o programa pode interagir com o sistema operacional do computador e qual sintaxe do programa é válida. Cada navegador da Web tem um ambiente de execução para JavaScript.

Historicamente, o Apps Script é alimentado pelo interpretador Rhino JavaScript da Mozilla. Embora o Rhino tenha fornecido uma maneira conveniente para o Apps Script executar scripts de desenvolvedor, ele também vinculou o Apps Script a uma versão específica do JavaScript (ES5). Os desenvolvedores do Apps Script não podem usar sintaxe e recursos mais modernos do JavaScript em scripts que usam o tempo de execução do Rhino.

Para resolver esse problema, o Apps Script agora tem suporte ao ambiente de execução V8, que alimenta o Chrome e o Node.js. É possível migrar scripts existentes para o V8 para aproveitar os recursos e a sintaxe do JavaScript moderno.

Esta página descreve os novos recursos ativados pelo V8 e como ativar o V8 para uso nos scripts. Como migrar scripts para o V8 descreve as etapas para migrar scripts atuais para usar o ambiente de execução do V8.

Recursos do ambiente de execução V8

Os scripts que usam o ambiente de execução V8 podem aproveitar os seguintes recursos:

Sintaxe moderna do ECMAScript

É possível usar a sintaxe moderna do ECMAScript em scripts que são executados pelo ambiente de execução V8. Essa sintaxe inclui let, const e muitos outros recursos conhecidos.

Consulte Exemplos de sintaxe do V8 para conferir uma lista curta de melhorias de sintaxe conhecidas que podem ser feitas usando o ambiente de execução do V8.

Atenção: ainda não há suporte para módulos ES6.

Detecção de função aprimorada

A detecção de funções do Apps Script foi aprimorada para scripts que usam o V8. O novo 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 lugares em que você já pode chamar métodos de biblioteca. Esses lugares incluem o seguinte:

• Ativadores de manifesto dos complementos do Google Workspace
• Gatilho instalável
• Itens de menu nos 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 ao criar itens de menu nas 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: o serviço Logger e a classe console. Esses dois serviços gravam registros no mesmo serviço do Stackdriver Logging.

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

Conferir execuções

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

Observação: como o painel Execuções não fornece registros com carimbo de data/hora das chamadas de serviço do Apps Script individuais, é recomendável usar o serviço console para criar mensagens de registro adequadas. Todos os registros criados com console aparecem no painel Executions.

Exemplos de sintaxe do V8

Confira a seguir uma lista breve de recursos sintáticos conhecidos disponíveis para scripts que usam o ambiente de execução V8.

let e const

As palavras-chave let e const permitem definir variáveis locais de escopo de bloco e constantes de escopo de 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

As funções de seta oferecem uma maneira compacta de definir funções em 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

As classes oferecem uma maneira de organizar conceitualmente o código com herança. As classes no V8 são principalmente açúcar sintático sobre a herança baseada em protótipo do 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 reestruturar atividades

As expressões de atribuição de desestruturação são uma maneira rápida de desempacotar 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

Template literals

Os literais de modelo são literais de string que permitem expressões incorporadas. Elas permitem que você evite instruções de concatenação de string 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

Os parâmetros padrão permitem especificar valores padrão para parâmetros de função na declaração da função. Isso pode simplificar o código no corpo da função, porque remove a necessidade de atribuir explicitamente valores padrão a 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 literales de modelo. Assim como com literales 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 V8

Se um script estiver usando o ambiente 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 .
3. Marque a caixa de seleção Ativar o tempo de execução do Chrome V8.

Como alternativa, especifique o ambiente de execução do script diretamente editando o arquivo de manifesto do script:

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

Como migrar scripts para o V8 explica outras etapas que você precisa seguir para garantir que o script funcione bem usando o V8.

Como ativar o ambiente de execução do Rhino

Se o script estiver usando o V8 e você precisar mudar para o ambiente de execução original do Rhino, faça o seguinte:

1. Abra o projeto do Apps Script.
2. À esquerda, clique em Configurações do projeto .
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 .
3. Selecione a caixa de seleção Mostrar arquivo de manifesto "appsscript.json" no editor.
4. À esquerda, clique em Editor > appsscript.json.
5. No arquivo de manifesto appsscript.json, defina o campo runtimeVersion como o valor DEPRECATED_ES5.
6. Na parte de cima, clique em Salvar projeto .

Como faço a migração de scripts existentes?

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

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

A partir de 18 de fevereiro de 2020, o Google vai começar a migrar gradualmente os scripts atualizados que passaram no teste de compatibilidade automática para a V8. Os scripts afetados continuam funcionando normalmente após a migração.

Se você quiser desativar a migração automática de um script, defina o campo runtimeVersion no manifesto como DEPRECATED_ES5. Você pode escolher migrar o script para o V8 manualmente a qualquer momento.

Como faço para informar bugs?

O guia de suporte explica como receber ajuda de programação no Stack Overflow, pesquisar relatórios de problemas existentes, registrar novos bugs e fazer novas solicitações de recursos.