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 la secuencia de comandos. El entorno de ejecución proporciona reglas sobre cómo se accede a la memoria, cómo puede interactuar el programa con el sistema operativo de la computadora y qué sintaxis del programa es legal. Cada navegador web tiene un entorno de ejecución para JavaScript.

Históricamente, Apps Script cuenta con la tecnología del intérprete Rhino JavaScript de Mozilla. Si bien Rhino le proporcionó a Apps Script una manera conveniente de ejecutar secuencias de comandos para desarrolladores, también vinculó Apps Script a una versión específica de JavaScript (ES5). Los desarrolladores de Apps Script no pueden usar la sintaxis y las funciones de JavaScript más modernas en las secuencias de comandos que usan el entorno de ejecución de Rhino.

Para abordar este problema, Apps Script ahora es compatible con el entorno de ejecución V8 que impulsa 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 funciones nuevas que habilita V8 y el modo en que se puede habilitar para su uso en tus secuencias de comandos. En Cómo migrar secuencias de comandos a V8, se describen los pasos para migrar secuencias de comandos existentes de modo que usen el entorno de ejecución de V8.

Funciones del entorno de ejecución V8

Las secuencias de comandos que utilizan el tiempo de ejecución V8 pueden aprovechar las siguientes funciones:

Sintaxis moderna de ECMAScript

Puedes usar la sintaxis moderna de ECMAScript en las 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 V8 para obtener una lista breve de las mejoras populares de sintaxis que puedes realizar con el tiempo de ejecución de V8.

Detección de funciones mejorada

Se mejoró la detección de funciones de Apps Script para secuencias de comandos que usan V8. El nuevo 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 llamadas

Las secuencias de comandos que usan V8 pueden llamar a métodos de objetos y métodos estáticos de clase desde lugares donde ya podrías llamar a métodos de biblioteca. Entre estos lugares, se incluyen los siguientes:

El siguiente ejemplo de V8 muestra el uso de métodos de objetos al crear elementos de menú en Hojas de cálculo de 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');
  }
}

Visualiza los registros

Apps Script proporciona dos servicios de registro: el servicio Logger y la clase console. Ambos servicios escriben registros en el mismo 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 ejecuciones de tu secuencia de comandos, abre el proyecto de Apps Script y, a la izquierda, haz clic en Executions .

Ejemplos de sintaxis de V8

La siguiente es una lista breve de las funciones sintácticas populares disponibles para las secuencias de comandos que usan el tiempo de ejecución V8.

let y const

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

Las funciones de flecha proporcionan una forma compacta de definir funciones dentro de 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

Las clases proporcionan un medio para organizar conceptualmente el código con herencia. Las clases de V8 son principalmente azúcar 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

Las expresiones de desestructuración de asignación son una forma rápida de descomprimir valores de arreglos y objetos en 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

Los literales de plantilla son literales de string que permiten expresiones incorporadas. Te permiten evitar instrucciones 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

Los parámetros predeterminados te permiten especificar valores predeterminados para los parámetros de la función en la declaración de la función. Esto puede simplificar el código en el cuerpo de la función, ya que elimina la necesidad de 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!"

Strings de varias líneas

Puedes definir strings de varias líneas con la misma sintaxis que los literales de plantilla. Al igual que con los literales de plantilla, esta sintaxis te permite evitar las concatenaciones de strings y simplificar las definiciones 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`;

Cómo habilitar el tiempo de ejecución V8

Si una secuencia de comandos usa el tiempo de ejecución de Rhino, puedes cambiarla a V8 de la siguiente manera:

  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 entorno de ejecución de la secuencia de comandos directamente si editas el archivo de 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, establece el campo runtimeVersion en el valor V8.
  6. En la parte superior, haz clic en Guardar proyecto .

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

Habilita el tiempo de ejecución de Rhino

Si tu secuencia de comandos usa V8 y necesitas cambiarla para usar el tiempo de ejecución original 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.

Como 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, establece el campo runtimeVersion en el valor DEPRECATED_ES5.
  6. En la parte superior, haz clic en Guardar proyecto .

¿Cómo migro las secuencias de comandos existentes?

En la guía Migra secuencias de comandos a V8, se describen los pasos que debes seguir para migrar una secuencia de comandos existente y usar V8. Esto implica habilitar el tiempo de ejecución de V8 y verificar la secuencia de comandos para detectar incompatibilidades conocidas.

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

A partir del 18 de febrero de 2020, Google comenzará a migrar gradualmente las secuencias de comandos existentes que superen nuestra prueba de compatibilidad automatizada a V8. Las secuencias de comandos afectadas continúan funcionando con normalidad después de la migración.

Si deseas inhabilitar la migración automática de una secuencia de comandos, establece el campo runtimeVersion en su manifiesto como DEPRECATED_ES5. Puedes elegir migrar la secuencia de comandos a V8 de forma manual en cualquier momento a partir de entonces.

¿Cómo informo los errores?

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