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 concernant l'accès à la mémoire, la manière dont le programme peut interagir avec le système d'exploitation de l'ordinateur et la syntaxe du programme autorisée. Chaque navigateur Web dispose d'un environnement d'exécution pour JavaScript.
Auparavant, Apps Script était fourni par l'interpréteur JavaScript Rhino de Mozilla. Si Rhino permettait à Apps Script d'exécuter facilement des scripts pour les développeurs, il l'a également associé à une version JavaScript spécifique (ES5). Les développeurs Apps Script ne peuvent pas utiliser la syntaxe et les 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 des scripts existants vers la version 8 afin de bénéficier de la syntaxe et des fonctionnalités JavaScript modernes.
Cette page décrit les nouvelles fonctionnalités activées par V8 et explique comment l'activer dans vos scripts. La page 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 bénéficier des fonctionnalités suivantes:
Syntaxe ECMAScript moderne
Vous pouvez utiliser la syntaxe ECMAScript moderne dans les scripts fournis par l'environnement d'exécution V8. Cette syntaxe inclut let, const et de nombreuses autres fonctionnalités populaires.
Consultez les exemples de syntaxe V8 pour obtenir une courte liste des améliorations de syntaxe populaires 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. Le nouvel 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. Voici quelques exemples:
- Déclencheurs du fichier manifeste des modules complémentaires Google Workspace
- Déclencheurs installables
- Éléments de menu dans Google Workspace les éditeurs
- Fonctions de rappel utilisateur, telles que celles décrites dans l'exemple de code
ScriptApp.newStateToken().
L'exemple V8 suivant illustre 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 les journaux sur le même service Stackdriver Logging.
Pour afficher les journaux Logger et console, cliquez sur Journal d'exécution en haut de l'éditeur de script.
Afficher les exécutions
Pour afficher l'historique d'exécution de votre script, ouvrez le projet Apps Script et, à gauche, cliquez sur Exécutions .
Exemples de syntaxe V8
Vous trouverez ci-dessous une courte liste des 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, respectivement, de définir des variables locales de champ d'application de bloc et des constantes de champ d'application 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 fléchées
Les 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
Les classes permettent d'organiser le code de manière conceptuelle avec l'héritage. Les classes de V8 sont principalement un sucre syntaxique par rapport à l'héritage basé sur des prototypes 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
Les expressions d'attribution de déstructuration constituent un moyen rapide de décompresser les valeurs de tableaux et d'objets en 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
Les littéraux de modèle sont des littéraux de chaîne qui permettent les expressions intégrées. Elles vous permettent d'éviter les instructions de concaténation 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
L'option Paramètres par défaut vous permet 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 en utilisant la même syntaxe que les littéraux de modèle. Comme pour les littéraux de modèle, cette syntaxe vous permet d'éviter les concaténations de chaînes et de simplifier les définitions de chaîne.
// 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 procédant comme suit:
- Ouvrez le projet Apps Script.
- Sur la gauche, cliquez sur Paramètres du projet .
- Cochez la case Activer l'environnement d'exécution Chrome V8.
Vous pouvez également spécifier directement l'environnement d'exécution du script en modifiant le fichier manifeste du script:
- Ouvrez le projet Apps Script.
- Sur la gauche, cliquez sur Paramètres du projet .
- Cochez la case Afficher le fichier manifeste "appsscript.json" dans l'éditeur.
- À gauche, cliquez sur Éditeur >
appsscript.json. - Dans le fichier manifeste
appsscript.json, définissez le champruntimeVersionsur la valeurV8. - En haut, cliquez sur Enregistrer le projet .
La section Migrer des scripts vers V8 décrit 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 modifier pour utiliser l'environnement d'exécution Rhino d'origine, procédez comme suit:
- Ouvrez le projet Apps Script.
- Sur la gauche, cliquez sur Paramètres du projet .
- Décochez la case Activer l'environnement d'exécution Chrome V8.
Vous pouvez également modifier le fichier manifeste de votre script:
- Ouvrez le projet Apps Script.
- Sur la gauche, cliquez sur Paramètres du projet .
- Cochez la case Afficher le fichier manifeste "appsscript.json" dans l'éditeur.
- À gauche, cliquez sur Éditeur >
appsscript.json. - Dans le fichier manifeste
appsscript.json, définissez le champruntimeVersionsur la valeurDEPRECATED_ES5. - En haut, cliquez sur Enregistrer le projet .
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. Cela implique d'activer l'environnement d'exécution V8 et de vérifier que le script ne présente aucune incompatibilité connue.
Migration automatique de scripts vers V8
À partir du 18 février 2020, Google commencera à migrer progressivement les scripts existants qui réussissent notre test de compatibilité automatisé vers la version 8. Les scripts concernés continuent à fonctionner normalement après la migration.
Si vous souhaitez désactiver la migration automatique d'un script, définissez le champ runtimeVersion de son fichier manifeste sur DEPRECATED_ES5. Vous pouvez ensuite choisir de migrer manuellement le script vers V8 à tout moment par la suite.
Comment signaler des bugs ?
Le guide d'assistance explique comment obtenir de l'aide pour la programmation sur Stack Overflow, rechercher des rapports de problèmes existants, signaler de nouveaux bugs et envoyer de nouvelles demandes de fonctionnalités.