Descripción general del entorno de ejecución de V8

En Apps Script y JavaScript, un entorno de ejecución o entorno de ejecución contiene el motor de JavaScript que analiza y ejecuta el código de secuencia de comandos. El entorno de ejecución proporciona sobre cómo se accede a la memoria, cómo el programa puede interactuar con el sistema operativo de tu computadora y qué sintaxis de programa es legal. Cada sitio web navegador tiene un entorno de ejecución para JavaScript.

Históricamente, Apps Script ha utilizado la tecnología de Rhino JavaScript de Mozilla de un intérprete. Aunque Rhino proporcionó una forma conveniente de ejecutar Apps Script secuencias de comandos para desarrolladores; también vincula Apps Script a una versión específica de JavaScript (ES5). Desarrolladores de Apps Script no puedes usar la sintaxis ni las funciones de JavaScript más modernas en las secuencias de comandos con Rhino tiempo de ejecución.

Para abordar este problema, Apps Script ahora es compatible con el Es un entorno de ejecución V8 que potencian Chrome y Node.js. Puedes migrar secuencias de comandos existentes a V8 para aprovechar la sintaxis y las funciones modernas de JavaScript.

En esta página, se describen las nuevas funciones que habilita V8 y cómo puedes habilitarla para usarlos en tus secuencias de comandos. Cómo migrar secuencias de comandos a V8 se describen los pasos para migrar secuencias de comandos existentes a fin de usar el entorno de ejecución V8.

Características del tiempo de ejecución V8

Las secuencias de comandos que usan el tiempo de ejecución V8 pueden aprovechar lo siguiente atributos:

Sintaxis moderna de ECMAScript

Puede usar el ECMAScript moderno en secuencias de comandos con la tecnología del entorno de ejecución V8. Esta sintaxis incluye let, const y muchas otras funciones populares.

Consulta los ejemplos de sintaxis de la versión 8 para obtener una lista breve de los conceptos populares. que puedes realizar con el tiempo de ejecución V8.

Detección de funciones mejorada

Se mejoró la detección de funciones de Apps Script para las secuencias de comandos que usan V8. La nueva herramienta el entorno de ejecución reconoce estos formatos de definición de funciones:

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

Llama a métodos de objetos desde activadores y devoluciones de llamada

Las secuencias de comandos que usan V8 pueden llamar a métodos de objetos y clasificar métodos estáticos de lugares donde ya se podría llamar a los métodos de biblioteca. Estos lugares incluyen lo siguiente:

En el siguiente ejemplo de V8, se muestra el uso de métodos de objeto para la construcción elementos del menú en Google Sheets:

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

Apps Script proporciona dos servicios de registro: el El servicio de Logger y las console. Ambos servicios escribir registros en la misma Servicio de Stackdriver Logging.

Para mostrar los registros Logger y console, en la parte superior del editor de secuencia de comandos, haz clic en Registro de ejecución.

Ver ejecuciones

Para ver el historial de ejecución de tu secuencia de comandos, abre el proyecto Apps Script y en En el lado izquierdo, haz clic en Ejecuciones .

Ejemplos de sintaxis de V8

La siguiente es una lista breve de funciones sintácticas populares disponibles para secuencias de comandos con el entorno de ejecución V8.

let y const

La let y const Las palabras clave te permiten definir las variables locales de alcance de bloque y el alcance de bloque. constantes, 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

Funciones de flecha

Funciones de flecha proporcionan una forma compacta de definir funciones dentro de las expresiones.

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

Clases

Clases proporciona un medio para organizar conceptualmente el código con herencia. Clases en V8 son principalmente sintaxis sintáctica sobre la herencia basada en prototipos de 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)

Desestructuración de asignaciones

Desestructuración de la asignación son una forma rápida de desempaquetar valores de arrays y objetos variables 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

Literales de plantilla

Literales de plantilla son literales de cadena que permiten expresiones incorporadas. Te permiten evitar sentencias de concatenación de cadenas más complejas.

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

Parámetros predeterminados te permiten especificar valores predeterminados para los parámetros de la función en la función declaración. Esto puede simplificar el código en el cuerpo de la función, ya que quita el debes asignar explícitamente valores predeterminados a los parámetros faltantes.

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

Cadenas de varias líneas

Puedes definir cadenas de varias líneas con la misma sintaxis que los literales de plantilla. Al igual que con literales de plantilla, esta sintaxis te permite evitar las concatenaciones de cadenas y simplificar definiciones de cadenas.

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

Cómo habilitar el entorno de ejecución de V8

Si una secuencia de comandos usa el tiempo de ejecución de Rhino, puedes cambiarlo a V8 haciendo lo siguiente:

  1. Abre el proyecto Apps Script.
  2. A la izquierda, haz clic en Configuración del proyecto .
  3. Selecciona la casilla de verificación Habilitar el tiempo de ejecución de Chrome V8.

También puedes especificar el tiempo de ejecución de la secuencia de comandos directamente editar el manifiesto de la secuencia de comandos archivo:

  1. Abre el proyecto Apps Script.
  2. A la izquierda, haz clic en Configuración del proyecto .
  3. Selecciona la casilla de verificación Mostrar el archivo de manifiesto "appsscript.json" en el editor.
  4. A la izquierda, haz clic en Editor > appsscript.json
  5. En el archivo de manifiesto appsscript.json, configura la runtimeVersion con el valor V8.
  6. En la parte superior, haz clic en Guardar proyecto .

En Migra secuencias de comandos a V8, se explica otros pasos que debes seguir para asegurarte de que tu secuencia de comandos funcione bien con V8.

Habilita el entorno de ejecución de Rhino

Si tu secuencia de comandos usa la versión V8 y necesitas cambiarla para usar la original Tiempo de ejecución de Rhino, haz lo siguiente:

  1. Abre el proyecto Apps Script.
  2. A la izquierda, haz clic en Configuración del proyecto .
  3. Desmarca la casilla de verificación Habilitar el tiempo de ejecución de Chrome V8.

De manera alternativa, edita el manifiesto de la secuencia de comandos:

  1. Abre el proyecto Apps Script.
  2. A la izquierda, haz clic en Configuración del proyecto .
  3. Selecciona la casilla de verificación Mostrar el archivo de manifiesto "appsscript.json" en el editor.
  4. A la izquierda, haz clic en Editor > appsscript.json
  5. En el archivo de manifiesto appsscript.json, configura la runtimeVersion con el valor DEPRECATED_ES5.
  6. En la parte superior, haz clic en Guardar proyecto .

¿Cómo migro las secuencias de comandos existentes?

La guía Migra secuencias de comandos a V8 describe los pasos que debes seguir para migrar una secuencia de comandos existente a usa V8. Esto implica habilitar el tiempo de ejecución V8 y comprobar que la secuencia de comandos cualquier incompatibilidad conocida.

Migración automática de secuencias de comandos a V8

A partir del 18 de febrero de 2020, Google comenzará a migrar gradualmente que pasan la prueba de compatibilidad automatizada con V8. Las secuencias de comandos afectadas seguirán funcionando con normalidad después de la migración.

Si quieres inhabilitar la migración automática de una secuencia de comandos, configura runtimeVersion en su manifiesto a DEPRECATED_ES5. Puedes optar por migrar la secuencia de comandos a V8 en cualquier tiempo después.

¿Cómo informo errores?

En la guía de asistencia se explica cómo obtener acceso a la programación obtener ayuda en Stack Overflow, buscar informes de problemas existentes, informar errores nuevos y solicitar nuevas funciones.