Présentation de l'environnement d'exécution V8

Dans Apps Script et JavaScript, un environnement d'exécution (runtime) contient le moteur JavaScript qui analyse et exécute le code du script. L'environnement d'exécution fournit des règles régissant l'accès à la mémoire, la manière dont le programme peut interagir avec le système d’exploitation de l’ordinateur et quelle syntaxe de programme est légale. Chaque site Web dispose d'un environnement d'exécution pour JavaScript.

Auparavant, Apps Script s'appuyait sur l'environnement JavaScript Rhino JavaScript de Mozilla. un interprète. Rhino offre un moyen pratique d'exécuter Apps Script de développeurs, il a aussi lié Apps Script à une version JavaScript spécifique (ES5). Développeurs Apps Script Impossible d'utiliser une syntaxe et des fonctionnalités JavaScript plus modernes dans les scripts utilisant Rhino de l'environnement d'exécution.

Pour résoudre ce problème, Apps Script est désormais compatible avec le SDK Environnement d'exécution V8 qui alimente Chrome et Node.js. Vous pouvez migrer des scripts existants vers V8 afin de tirer parti de la syntaxe et des fonctionnalités modernes de JavaScript.

Cette page décrit les nouvelles fonctionnalités proposées par V8 et explique comment l'activer. pour les utiliser dans vos scripts. Migrer des scripts vers V8 décrit les étapes à suivre pour migrer des scripts existants vers l'environnement d'exécution V8.

Fonctionnalités de l'environnement d'exécution V8

Les scripts qui utilisent l'environnement d'exécution V8 peuvent exploiter les fonctionnalités suivantes : fonctionnalités:

Syntaxe ECMAScript moderne

Vous pouvez utiliser une version moderne du langage ECMAScript dans les scripts fournis par l'environnement d'exécution V8. Cette syntaxe comprend let, const et de nombreuses autres fonctionnalités populaires.

Consultez des exemples de syntaxe V8 pour obtenir une courte liste les améliorations de syntaxe que vous pouvez apporter à l'aide de l'environnement d'exécution V8.

Amélioration de la détection des fonctions

La détection des fonctions Apps Script a été améliorée pour les scripts utilisant V8. Les nouvelles l'environnement d'exécution reconnaît les formats de définition de fonction suivants:

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

Appeler des méthodes d'objet à partir de déclencheurs et de rappels

Les scripts utilisant V8 peuvent appeler des méthodes d'objet et des méthodes statiques de classe à partir d'emplacements où vous pouviez déjà appeler des méthodes de bibliothèque. Ces lieux incluent les suivantes:

• Déclencheurs du fichier manifeste des modules complémentaires Google Workspace
• Déclencheurs installables
• Éléments de menu dans Google Workspace les éditeurs
• Les fonctions de rappel utilisateur, telles que celles décrites dans le document Exemple de code ScriptApp.newStateToken().

L'exemple V8 suivant montre comment utiliser des méthodes d'objet lors de la construction éléments de menu dans 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');
  }
}

Afficher les journaux

Apps Script propose deux services de journalisation : service Logger et console. Ces deux services écrire des journaux sur le même Service Stackdriver Logging.

Pour afficher les journaux Logger et console, en haut de l'éditeur de script, cliquez sur Journal d'exécution.

Afficher les exécutions

Pour afficher l'historique d'exécution de votre script, ouvrez le projet Apps Script et, sur Sur la gauche, cliquez sur Exécutions playlist_play.

Exemples de syntaxe V8

Voici une courte liste des caractéristiques syntaxiques populaires à l'aide de l'environnement d'exécution V8.

let et const

let et const Les mots clés vous permettent de définir des variables locales de portée bloc constantes, respectivement.

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

Fonctions fléchées

Fonctions fléchées fournissent un moyen compact de définir des fonctions dans des expressions.

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

Classes

Cours offrent un moyen d'organiser le code de manière conceptuelle avec l'héritage. Cours dans V8 sont principalement des sucres syntaxiques par rapport à l'héritage basé sur le prototype 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)
      

Déstructuration des attributions

Déstructuration de l'attribution Les expressions constituent un moyen rapide de désimbriquer les valeurs de tableaux et d'objets dans variables distinctes.

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


      

Littéraux de modèle

Littéraux de modèle sont des littéraux de chaîne qui autorisent les expressions intégrées. Elles vous permettent d'éviter des instructions de concaténation de chaîne plus complexes.

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


      

Paramètres par défaut

Paramètres par défaut vous permettent de spécifier des valeurs par défaut pour les paramètres de la fonction la déclaration. Cela peut simplifier le code dans le corps de la fonction, car cela supprime devez attribuer explicitement des valeurs par défaut aux paramètres manquants.

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

      

Chaînes multilignes

Vous pouvez définir chaînes multilignes en utilisant la même syntaxe que les littéraux de modèle. Comme pour des littéraux de modèle, cette syntaxe vous permet d'éviter les concaténations de chaînes et de simplifier de chaînes de caractères.

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

Activer l'environnement d'exécution V8

Si un script utilise l'environnement d'exécution Rhino, vous pouvez le faire passer à V8 en en procédant comme suit:

1. Ouvrez le projet Apps Script.
2. Sur la gauche, cliquez sur Paramètres du projet settings.
3. Cochez la case Activer l'environnement d'exécution Chrome V8.

Vous pouvez également spécifier l'environnement d'exécution du script directement en modifier le fichier manifeste du script :

1. Ouvrez le projet Apps Script.
2. Sur la gauche, cliquez sur Paramètres du projet settings.
3. Cochez la case Afficher le fichier manifeste "appsscript.json" dans l'éditeur.
4. À gauche, cliquez sur Montage code > appsscript.json
5. Dans le fichier manifeste appsscript.json, définissez runtimeVersion sur la valeur V8.
6. En haut, cliquez sur Enregistrer le projet save.

Pour en savoir plus, consultez la section Migrer des scripts vers la version 8. autres étapes à suivre pour vous assurer que votre script fonctionne bien avec V8.

Activer l'environnement d'exécution Rhino

Si votre script utilise V8 et que vous devez le modifier pour utiliser l'original Dans l'environnement d'exécution Rhino, procédez comme suit:

1. Ouvrez le projet Apps Script.
2. Sur la gauche, cliquez sur Paramètres du projet settings.
3. Décochez la case Activer l'environnement d'exécution Chrome V8.

Vous pouvez également modifier le fichier manifeste de votre script:

1. Ouvrez le projet Apps Script.
2. Sur la gauche, cliquez sur Paramètres du projet settings.
3. Cochez la case Afficher le fichier manifeste "appsscript.json" dans l'éditeur.
4. À gauche, cliquez sur Montage code > appsscript.json
5. Dans le fichier manifeste appsscript.json, définissez runtimeVersion sur la valeur DEPRECATED_ES5.
6. En haut, cliquez sur Enregistrer le projet save.

Comment migrer des scripts existants ?

La page Migrer des scripts vers V8 décrit les étapes à suivre pour migrer un script existant vers utilisez V8. Cela implique d'activer l'environnement d'exécution V8 et de vérifier le script toute incompatibilité connue.

Migration automatique de scripts vers V8

À partir du 18 février 2020, Google commencera à migrer progressivement qui réussissent notre test de compatibilité automatisé vers V8. Scripts concernés continuent à fonctionner normalement après la migration.

Si vous souhaitez désactiver la migration automatique pour un script, définissez le paramètre runtimeVersion dans son fichier manifeste sur DEPRECATED_ES5. Vous pouvez choisir de migrer le script vers V8 à tout moment par la suite.

Comment signaler des bugs ?

Le guide d'assistance explique comment programmer de l'aide sur Stack Overflow, rechercher des rapports de problèmes existants, signaler de nouveaux bugs et de nouvelles demandes de fonctionnalités.