Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Format de script Amazon Lex V2 prend en charge les ECMAScript fonctionnalités suivantes pour définir les grammaires. Amazon Lex V2 prend en charge les ECMAScript fonctionnalités suivantes lors de la spécification de balises dans la grammaire. `tag-format`doit être envoyé `semantics/1.0` lorsque des ECMAScript balises sont utilisées dans la grammaire. Pour plus d'informations, consultez la spécification du [langage ECMA-262 ECMAScript 2021](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/). ``` ``` **Topics** + [ # Déclaration variable ](ecma-variable.md) + [ # Expressions ](ecma-expression.md) + [ # Si déclaration ](ecma-if.md) + [ # Déclaration Switch ](ecma-switch.md) + [ # Déclarations de fonctions ](ecma-function.md) + [ # Déclaration d'itération ](ecma-iteration.md) + [ # Déclaration de blocage ](ecma-block.md) + [ # Commentaires ](ecma-comments.md) + [ # Déclarations non étayées ](ecma-unsupported.md) Ce document contient du contenu de la ECMAScript norme (disponible à l'adresse [https://www.ecma-international). org/publications-and-standards/standards/ecma-262/)](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/). Le document de spécification ECMAScript linguistique est disponible auprès d'Ecma International sous la licence suivante. ## Texte de licence © 2020 Ecma International Ce document peut être copié, publié et distribué à d'autres, et certaines œuvres dérivées de celui-ci peuvent être préparées, copiées, publiées et distribuées, en tout ou en partie, à condition que l'avis de copyright ci-dessus et cette licence de droit d'auteur et cette clause de non-responsabilité soient inclus sur toutes ces copies et œuvres dérivées. Les seules œuvres dérivées autorisées en vertu de cette licence de droit d'auteur et de cette clause de non-responsabilité sont les suivantes : (i) les œuvres qui incorporent tout ou partie de ce document dans le but de fournir des commentaires ou des explications (comme une version annotée du document), (ii) les œuvres qui incorporent tout ou partie de ce document dans le but d'intégrer des fonctionnalités garantissant l'accessibilité, (iii) des traductions de ce document dans des langues autres que l'anglais et dans différents formats et (iv) fonctionne en utilisant cette spécification dans des produits conformes aux normes en implémentant (par exemple, en copiant et collant totalement ou partiellement) les fonctionnalités qu'elle contient. Cependant, le contenu de ce document lui-même ne peut être modifié d'aucune façon, y compris en supprimant l'avis de copyright ou les références à Ecma International, sauf si cela est nécessaire pour le traduire dans des langues autres que l'anglais ou dans un format différent. La version officielle d'un document d'Ecma International est la version en langue anglaise du site Web d'Ecma International. En cas de divergence entre une version traduite et la version officielle, c'est la version officielle qui prévaut. Les autorisations limitées accordées ci-dessus sont perpétuelles et ne seront pas révoquées par Ecma International, ses successeurs ou ayants droit. Ce document et les informations qu'il contient sont fournis « TELS QUELS » et ECMA INTERNATIONAL DÉCLINE TOUTE GARANTIE, EXPRESSE OU IMPLICITE, Y COMPRIS, MAIS SANS S'Y LIMITER, TOUTE GARANTIE SELON LAQUELLE L'UTILISATION DES INFORMATIONS CONTENUES DANS CE DOCUMENT N'ENFREINDRA AUCUN DROIT DE PROPRIÉTÉ NI AUCUNE GARANTIE IMPLICITE DE QUALITÉ MARCHANDE OU D'ADÉQUATION À UN USAGE PARTICULIER. » # Déclaration variable Une instruction de variable définit une ou plusieurs variables. ``` var x = 10; var x = 10, var y = ; ``` # Expressions Vous pouvez ajouter des chaînes d'expressions pour exécuter des fonctions dans Amazon Lex V2. Ce tableau présente la syntaxe et des exemples qui peuvent être utilisés dans les expressions SRGS. | Type d’expression | Syntaxe | Exemple | Pris en charge ? | | --- | --- | --- | --- | | Expression régulière littérale | Chaîne littérale contenant des caractères spéciaux [regex](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) valides |

"^\d\.$"

var x = function calc() {
    return 10;
}

delete obj.property;

void (2 == '2');

typeof 42;

var fruits = ["apple"];
fruits[0];

out.value

new Date('1994-10-11')

var x=10; x++;

var x=10; x--;

var x=10; ++x;

var x=10; --x;

+x / -x;

const a = 5;
console.log( ~a );

!(a > 0 || b > 0)

(x + y) * (a / b)

(a + b) - (a - (a + b))

(a >> b) >>> c

if (a > b) { ... }

fruits[0] in otherFruits;

if (a == b) { ... }

a & b / a ^ b / a | b

if (a && (b ||c)) { ...}

a > b ? obj.prop : 0

out.value = "string";

a *= 10;

a <<= 10;

| Oui | | Identifiant | identifierSequence[où *IdentifierSequence* est une séquence de caractères valides](https://developer.mozilla.org/en-US/docs/Glossary/Identifier) |

fruits=[10, 20, 30];

x = null;

x = true;

a = 'hello',
b = "world";

111.11 e+12

0x123ABC

| Oui | | Littéral octal | O [0-7] |

"O51"

v = [a, b, c];

out = {value: 1, flag: false};

x + (x + y)

| Oui | # Si déclaration Vous pouvez ajouter des instructions if pour exécuter des fonctions dans Amazon Lex V2. Cet exemple montre la syntaxe qui peut être utilisée dans les expressions SRGS. ``` if (expressions) { statements; } else { statements; } ``` **Remarque :** Dans l'exemple précédent, `expressions` `statements` il doit s'agir de l'un des modèles pris en charge par ce document. # Déclaration Switch Vous pouvez ajouter des instructions switch pour exécuter des fonctions dans Amazon Lex V2. Cet exemple montre la syntaxe qui peut être utilisée dans les expressions SRGS. ``` switch (expression) { case (expression): statements . . . default: statements } ``` **Remarque :** Dans l'exemple précédent, `expressions` `statements` il doit s'agir de l'un des modèles pris en charge par ce document. # Déclarations de fonctions Vous pouvez ajouter des déclarations de fonction pour exécuter des fonctions dans Amazon Lex V2. Cet exemple montre la syntaxe qui peut être utilisée dans les expressions SRGS. ``` function functionIdentifier([parameterList, ...]) { } ``` # Déclaration d'itération Les instructions d'itération peuvent être l'une des suivantes : ``` // Do..While statement do { statements } while (expressions) // While Loop while (expressions) { statements } // For Loop for ([initialization]; [condition]; [final-expression]) statement // For..In for (variable in object) { statement } ``` # Déclaration de blocage Vous pouvez ajouter des blocs d'instructions pour exécuter des fonctions dans Amazon Lex V2. Cet exemple montre la syntaxe qui peut être utilisée dans les expressions SRGS. ``` { statements } // Example { x = 10; if (x > 10) { console.log("greater than 10"); } } ``` **Remarque :** Dans l'exemple précédent, le bloc `statements` fourni doit être l'un des blocs pris en charge par ce document. # Commentaires Vous pouvez ajouter des commentaires dans Amazon Lex V2. Cet exemple montre la syntaxe qui peut être utilisée dans les expressions SRGS. ``` // Single Line Comments "// " // Multineline comments /** **/ ``` # Déclarations non étayées Amazon Lex V2 ne prend pas en charge les ECMAScript fonctionnalités suivantes. **Topics** + [ ## Déclaration vide ](#ecma-unsupported-empty) + [ ## Poursuivre la déclaration ](#ecma-unsupported-continue) + [ ## Déclaration de rupture ](#ecma-unsupported-break) + [ ## Déclaration de retour ](#ecma-unsupported-return) + [ ## Lancer une déclaration ](#ecma-unsupported-throw) + [ ## Déclaration d'essai ](#ecma-unsupported-try) + [ ## Déclaration du débogueur ](#ecma-unsupported-debugger) + [ ## Déclaration étiquetée ](#ecma-unsupported-labelled) + [ ## Déclaration de classe ](#ecma-unsupported-class) ## Déclaration vide L'instruction vide est utilisée pour ne fournir aucune instruction. La syntaxe d'une instruction vide est la suivante : ``` ; ``` ## Poursuivre la déclaration L'instruction continue sans étiquette est prise en charge par le[Déclaration d'itération](ecma-iteration.md). L'instruction continue avec étiquette n'est pas prise en charge. ``` // continue with label // this allows the program to jump to a // labelled statement (see labelled statement below) continue ; ``` ## Déclaration de rupture L'instruction break sans étiquette est prise en charge par le[Déclaration d'itération](ecma-iteration.md). L'instruction break avec étiquette n'est pas prise en charge. ``` // break with label // this allows the program to break out of a // labelled statement (see labelled statement below) break ; ``` ## Déclaration de retour ``` return expression; ``` ## Lancer une déclaration L'instruction throw est utilisée pour lancer une exception définie par l'utilisateur. ``` throw expression; ``` ## Déclaration d'essai ``` try { statements } catch (expression) { statements } finally { statements } ``` ## Déclaration du débogueur L'instruction debugger est utilisée pour invoquer la fonctionnalité de débogage fournie par l'environnement. ``` debugger; ``` ## Déclaration étiquetée L'instruction étiquetée peut être utilisée avec les `continue` instructions `break` or. ``` label: statements // Example let str = ''; loop1: for (let i = 0; i < 5; i++) { if (i === 1) { continue loop1; } str = str + i; } console.log(str); ``` ## Déclaration de classe ``` class Rectangle { constructor(height, width) { this.height = height; this.width = width; } } ```