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 .
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:
- Abra o projeto do Apps Script.
- À esquerda, clique em Configurações do projeto .
- 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:
- Abra o projeto do Apps Script.
- À esquerda, clique em Configurações do projeto .
- Selecione a caixa de seleção Mostrar arquivo de manifesto "appsscript.json" no editor.
- À esquerda, clique em Editor >
appsscript.json; - No arquivo de manifesto
appsscript.json, defina oruntimeVersionpara o valorV8. - Na parte de cima, clique em Salvar projeto .
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:
- Abra o projeto do Apps Script.
- À esquerda, clique em Configurações do projeto .
- Desmarque a caixa de seleção Ativar o tempo de execução do Chrome V8.
Como alternativa, edite o manifesto do script:
- Abra o projeto do Apps Script.
- À esquerda, clique em Configurações do projeto .
- Selecione a caixa de seleção Mostrar arquivo de manifesto "appsscript.json" no editor.
- À esquerda, clique em Editor >
appsscript.json; - No arquivo de manifesto
appsscript.json, defina oruntimeVersionpara o valorDEPRECATED_ES5. - Na parte de cima, clique em Salvar projeto .
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.