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

Históricamente, Apps Script se ha basado en el intérprete de JavaScript Rhino de Mozilla. Si bien Rhino proporcionó una forma conveniente para que Apps Script ejecutara secuencias de comandos de desarrolladores, también vinculó Apps Script a una versión específica de JavaScript (ES5). Los desarrolladores de Apps Script no pueden usar sintaxis ni funciones de JavaScript más modernas en secuencias de comandos que usen el entorno de ejecución de Rhino.

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

En esta página, se describen las funciones nuevas habilitadas por V8 y cómo puedes habilitar V8 para usarlas en tus secuencias de comandos. En Cómo migrar secuencias de comandos a V8, se describen los pasos para migrar secuencias de comandos existentes para usar el entorno de ejecución de V8.

Funciones del entorno de ejecución de V8

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

Sintaxis moderna de ECMAScript

Puedes usar la sintaxis moderna de ECMAScript en secuencias de comandos que se ejecutan con el entorno de ejecución de V8. Esta sintaxis incluye let, const y muchas otras funciones populares.

Consulta Ejemplos de sintaxis de V8 para obtener una lista breve de mejoras de sintaxis populares que puedes realizar con el entorno de ejecución de V8.

Detección de funciones mejorada

Se mejoró la detección de funciones de Apps Script para las secuencias de comandos que usan V8. El nuevo tiempo 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 () => {}

Cómo llamar 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 métodos estáticos de clases desde lugares donde ya podías llamar a métodos de bibliotecas. Estos lugares incluyen lo siguiente:

En el siguiente ejemplo de V8, se muestra el uso de métodos de objetos cuando se construyen 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');
  }
}

Ver 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.

Cómo ver ejecuciones

Para ver el historial de ejecución de tu secuencia de comandos, abre el proyecto de Apps Script y, a la izquierda, haz clic en Ejecuciones .

Ejemplos de sintaxis de V8

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

let y const

Las palabras clave let y const te permiten definir variables locales 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 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 la herencia. Las clases en V8 son principalmente sintaxis 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)

Cómo desestructurar tareas

Las expresiones de asignación de desestructuración son una forma rápida de desempaquetar valores de arrays 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 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

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 quita la necesidad de asignar valores predeterminados de forma explícita 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 las cadenas literales de plantilla, esta sintaxis te permite evitar concatenaciones de cadenas y simplificar las 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`;

Habilita el entorno de ejecución de V8

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

  1. Abre el proyecto de 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.

Como alternativa, 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 de 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 Cómo migrar secuencias de comandos a V8, se explican 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 V8 y necesitas cambiarla para usar el entorno de ejecución de Rhino original, haz lo siguiente:

  1. Abre el proyecto de 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 de 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 Cómo migrar 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 posibles 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 siguen funcionando con normalidad después de la migración.

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

¿Cómo informo 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 solicitudes de funciones nuevas.