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

En Apps Script y JavaScript, un tiempo 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 tiempo de ejecución proporciona reglas sobre cómo se accede a la memoria, cómo el programa puede interactuar 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 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 la sintaxis y las funciones más modernas de JavaScript en las secuencias de comandos que usan el entorno de ejecución de Rhino.

Para abordar esta inquietud, 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 nuevas funciones que habilita V8 y cómo puedes habilitar V8 para usarlo en tus secuencias de comandos. En Migración de secuencias de comandos a V8, se describen los pasos para migrar secuencias de comandos existentes y 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 las 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 ver una lista breve de las mejoras de sintaxis populares que puedes realizar con el entorno de ejecución de V8.

Mejoras en la detección de funciones

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

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

Los secuencias de comandos que usan V8 pueden llamar a métodos de objetos y métodos estáticos de clases desde lugares donde ya se podían llamar a métodos de bibliotecas. Estos lugares incluyen lo siguiente:

• Activadores de manifiesto de complementos de Google Workspace
• Activadores instalables
• Elementos de menú en los editores de Google Workspace
• Funciones de devolución de llamada del usuario, como la que se describe en la muestra de código de ScriptApp.newStateToken()

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

const 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 de Logger y console, haz clic en Registro de ejecución en la parte superior del editor de secuencias de comandos.

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

Ejemplos de sintaxis de V8

A continuación, se muestra una lista breve de las 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") {
  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 en V8 son principalmente azúcar sintáctico 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)
      

Asignaciones de desestructuración

Las expresiones de asignación por 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 a = [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
const data = {a: 12, b: false, c: 'blue'};
const {a, c} = data;
console.log(a, c);  // Outputs 12 "blue"


const array = [1, 2, 3];
const [x, y, z] = array;
console.log(x, y, z);  // Outputs 1 2 3


      

Plantillas literales

Los literales de plantilla son literales de cadena 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
const name = `Hi ${first} ${last}.`;
const 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
const 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 los 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
const multiline = `This on the other hand,
actually is a multi-line string,
thanks to JavaScript ES6`;
      

Cómo habilitar el entorno de ejecución V8

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

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

Como alternativa, puedes especificar el tiempo de ejecución de la secuencia de comandos directamente editando 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 settings.
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 code > 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 save.

En Migrating scripts to V8, se explican otros pasos que debes seguir para garantizar que tu secuencia de comandos funcione bien con V8.

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

Si tu secuencia de comandos usa V8 y necesitas cambiarla para que use el entorno de ejecución original de Rhino, haz lo siguiente:

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

Como alternativa, edita el manifiesto de tu secuencia de comandos:

1. Abre el proyecto de Apps Script.
2. A la izquierda, haz clic en Configuración del proyecto settings.
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 code > 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 save.

¿Cómo migro las secuencias de comandos existentes?

En la guía Migrating scripts to V8, se describen los pasos que debes seguir para migrar una secuencia de comandos existente para usar V8. Esto implica habilitar el tiempo de ejecución de V8 y verificar si la secuencia de comandos tiene alguna 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 a V8 las secuencias de comandos existentes que superen nuestra prueba de compatibilidad automatizada. Las secuencias de comandos afectadas seguirán 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 de su manifiesto en DEPRECATED_ES5. Puedes optar por migrar la secuencia de comandos a V8 manualmente en cualquier momento después de eso.

¿Cómo informo errores?

En la Guía de asistencia, se explica cómo obtener ayuda para programar en Stack Overflow, buscar informes de problemas existentes, registrar errores nuevos y realizar solicitudes de funciones nuevas.