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 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 cuenta con la tecnología del intérprete Rhino de JavaScript de Mozilla. Si bien Rhino proporcionaba una manera conveniente para que Apps Script ejecutara secuencias de comandos de desarrolladores, también vinculaba 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 este problema, Apps Script ahora es compatible con el 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 habilitadas por V8 y cómo puedes habilitarlo para su uso en tus secuencias de comandos. En Migra secuencias de comandos a V8, se describen los pasos para migrar secuencias de comandos existentes a fin de usar el entorno de ejecución de V8.

Características del tiempo de ejecución V8

Las secuencias de comandos que usan 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 que funcionan con el 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 breve lista de las mejoras populares en la sintaxis 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 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 clases de métodos estáticos desde lugares en los que ya podrías llamar a métodos de biblioteca. Entre estos lugares, se incluyen los siguientes:

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

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

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.

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

La siguiente es una lista breve de 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 manera 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

Las clases proporcionan un medio para organizar conceptualmente el código con herencia. Las clases en V8 son principalmente sintácticas 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 asignaciones son una forma rápida de descomprimir 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 string que permiten expresiones incorporadas. Te permiten evitar declaraciones 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 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 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 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 string y simplificar las definiciones de string.

// 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 de la siguiente manera:

1. Abre el proyecto 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 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 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, configura el campo runtimeVersion con el valor V8.
6. En la parte superior, haz clic en Guardar proyecto save.

En Migra 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 original de Rhino, haz lo siguiente:

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

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 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, configura el campo runtimeVersion con 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 Cómo migrar secuencias de comandos a V8, se describen los pasos que debes seguir a fin de migrar una secuencia de comandos existente para usar V8. Esto implica habilitar el tiempo de ejecución V8 y verificar la secuencia de comandos en busca de 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 pasan 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, configura el campo runtimeVersion en su manifiesto como DEPRECATED_ES5. Puedes elegir 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 nuevas solicitudes de funciones.