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

Dans Apps Script et JavaScript, un environnement d'exécution ou environnement d'exécution contient le moteur JavaScript qui analyse et exécute le code de script. L'environnement d'exécution fournit des règles sur la manière dont la mémoire est accessible, la manière dont le programme peut interagir avec le système d'exploitation de l'ordinateur et la syntaxe de programme autorisée. Chaque navigateur Web dispose d'un environnement d'exécution pour JavaScript.

Historiquement, Apps Script était basé sur l'interprète JavaScript Rhino de Mozilla. Bien que Rhino ait permis à Apps Script d'exécuter facilement les scripts des développeurs, il a également lié Apps Script à une version JavaScript spécifique (ES5). Les développeurs Apps Script ne peuvent pas utiliser de syntaxe et de fonctionnalités JavaScript plus modernes dans les scripts utilisant l'environnement d'exécution Rhino.

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

Cette page décrit les nouvelles fonctionnalités activées par V8 et comment activer V8 pour l'utiliser dans vos scripts. Migrer des scripts vers V8 décrit la procédure à 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:

Syntaxe ECMAScript moderne

Vous pouvez utiliser la syntaxe ECMAScript moderne dans les scripts exécutés par l'environnement d'exécution V8. Cette syntaxe inclut let, const et de nombreuses autres fonctionnalités populaires.

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

Amélioration de la détection des fonctions

La détection des fonctions Apps Script est améliorée pour les scripts utilisant V8. Le nouveau runtime 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'endroits où vous pouviez déjà appeler des méthodes de bibliothèque. Ces lieux incluent les suivants:

• Déclencheurs de fichier manifeste des modules complémentaires Google Workspace
• Déclencheurs installables
• Éléments de menu dans les Google Workspace éditeurs
• Fonctions de rappel utilisateur, comme celle décrite dans l'exemple de code ScriptApp.newStateToken().

L'exemple V8 suivant montre l'utilisation de méthodes d'objet lors de la création d'é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 fournit deux services de journalisation: le service Logger et la classe console. Ces deux services écrivent des journaux dans 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 la gauche, cliquez sur Exécutions playlist_play.

Exemples de syntaxe V8

Vous trouverez ci-dessous une courte liste de fonctionnalités syntaxiques populaires disponibles pour les scripts utilisant l'environnement d'exécution V8.

let et const

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

// 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 de flèche

Les fonctions flèche permettent de définir des fonctions de manière compacte 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

Les classes permettent d'organiser conceptuellement le code avec l'héritage. Les classes dans V8 sont principalement un sucre syntaxique 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éstructurer des devoirs

Les expressions d'attribution de déstructuration permettent de dépaqueter rapidement les valeurs de tableaux et d'objets dans des 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


      

Litérales de modèle

Les littléraux de modèle sont des littéraux de chaîne qui permettent d'intégrer des expressions. Ils vous permettent d'éviter les instructions de concatenaison de chaînes 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

Les paramètres par défaut vous permettent de spécifier des valeurs par défaut pour les paramètres de fonction dans la déclaration de fonction. Cela peut simplifier le code dans le corps de la fonction, car il n'est plus nécessaire d'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 des chaînes multilignes à l'aide de la même syntaxe que les chaînes littérales de modèle. Comme pour les littéraux de modèle, cette syntaxe vous permet d'éviter les concatenations de chaînes et de simplifier les définitions de chaînes.

// 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 passer à V8 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'exécution de Chrome V8.

Vous pouvez également spécifier l'environnement d'exécution du script directement en modifiant 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. Sur la gauche, cliquez sur Éditeur code > appsscript.json.
5. Dans le fichier manifeste appsscript.json, définissez le champ runtimeVersion sur la valeur V8.
6. En haut de l'écran, cliquez sur Enregistrer le projet save.

Migrer des scripts vers V8 explique les autres étapes à suivre pour vous assurer que votre script fonctionne correctement avec V8.

Activer l'environnement d'exécution Rhino

Si votre script utilise V8 et que vous devez le configurer pour qu'il utilise l'environnement d'exécution Rhino d'origine, 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'exécution de 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. Sur la gauche, cliquez sur Éditeur code > appsscript.json.
5. Dans le fichier manifeste appsscript.json, définissez le champ runtimeVersion sur la valeur DEPRECATED_ES5.
6. En haut de l'écran, cliquez sur Enregistrer le projet save.

Comment migrer des scripts existants ?

Le guide Migrer des scripts vers V8 décrit la procédure à suivre pour migrer un script existant vers V8. Pour ce faire, activez l'environnement d'exécution V8 et vérifiez le script pour détecter d'éventuelles incompatibilités connues.

Migration automatique des scripts vers V8

À partir du 18 février 2020, Google commencera à migrer progressivement les scripts existants qui passent notre test de compatibilité automatique vers la version 8. Les scripts concernés continuent de fonctionner normalement après la migration.

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

Comment signaler un bug ?

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