--- sourceDocument: Yokohama Créer ou modifier des applications sourceDocumentLink: https://servicenow-prod.fluidtopics.net/r/fr-FR/yokohama/application-development Release : - yokohama ft:locale : - fr-FR ft:publication_title : - Yokohama Créer ou modifier des applications ft:clusterId : - cadev bundleId : - cadev workflow : - Creator --- Considérations relatives au changement de mode JavaScript ========================================================= Considérations relatives au changement de mode JavaScript {#ariaid-title1} ========================================================================== * Rversion finale: Yokohama * * Mis à jour 30 janv. 2025 * * ![](https://www.servicenow.com/docs/portal-asset/ico-clock) 3 minutes de lecture Le changement de mode JavaScript pour une application ou un script peut modifier le comportement des scripts existants. Passez en revue quelques exemples de changements de comportement avant de changer de mode JavaScript ou pour résoudre les problèmes que vous rencontrez après le changement. Pour plus d'informations sur chaque mode JavaScript, reportez-vous aux sections [Modes JavaScript](https://servicenow-prod.fluidtopics.net/jqTunIAW7zVZYRJblr966A "Le mode JavaScript est un paramètre de conception et d’exécution pour les applications et les scripts personnalisés. Pour prendre en charge les scripts côté serveur existants et les nouveaux scripts développés selon la norme ECMAScript 2021, le moteur JavaScript dispose de trois modes : ECMAScript 2021 (ES12), normes ES5 et compatibilité.") et [Prise en charge de la fonctionnalité du moteur JavaScript](https://servicenow-prod.fluidtopics.net/5g6iblzQkIWDeF_7i6y6Dw "Comparez les fonctionnalités ECMAScript entre les modes JavaScript ECMAScript 2021 (ES12) et ES5 Standards dans Yokohama. Les deux modes prennent en charge un sous-ensemble de fonctionnalités ECMAScript."). Ce tableau met en évidence comment le comportement JavaScript a évolué de l'environnement pré-ES5 indulgent et sujet aux erreurs, à l'environnement ES5 plus strict et plus prévisible, et enfin à l'environnement plus riche en fonctionnalités d'ES12 (ECMAScript 2021). {#considerations-switching-javascript-mode__table_r4b_j4r_fcc__entry__4} | Fonctionnalité | Mode de compatibilité | Mode standard ES5 | ECMAScript 2021 (ES12) | |------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Objet des arguments | L'objet `arguments` existe, mais il n'y a pas de `mode strict`, donc les modifications se répercutent sur `les arguments`. Impressions: *** Script: [object Arguments] *** Script: [object Arguments] *** Script: [object Arguments] *** Script: 123 {#considerations-switching-javascript-mode__codeblock_xph_2vz_pcc} | En mode strict, l'objet arguments ne reflète pas les modifications de paramètres et génère une erreur. Impressions: sn_es5: 123 sn_es5: undefined sn_es5: [object Arguments] sn_es5: 123 {#considerations-switching-javascript-mode__codeblock_yph_2vz_pcc} | Identique à ES5. | | Remplacements booléens | Les booléens primitifs (`vrai`, `faux`) peuvent être remplacés, provoquant un comportement inattendu. | Les booléens primitifs sont plus protégés, bien qu'ils puissent toujours être remplacés lorsqu'ils sont affectés à des variables. | Identique à ES5, mais le mode strict permet d'éviter certaines affectations. L'expression conditionnelle doit être écrite sous la forme suivante : (cond_expr instanceof Boolean ? cond_expr.valueOf() : cond_expr). {#considerations-switching-javascript-mode__codeblock_zph_2vz_pcc} | | Exception pour erreurs de syntaxe | Les erreurs de syntaxe lèvent des exceptions lors de l'exécution. La gestion des erreurs est incohérente. Exemple : Javascript compiler exception: unterminated string literal (null.null.script; line 1) in: var b = ' {#considerations-switching-javascript-mode__codeblock_aqh_2vz_pcc} | Gestion plus cohérente des erreurs de syntaxe, en particulier en mode strict. Exemple : Evaluator: com.glide.script.RhinoEcmaError: unterminated string literal script : Line(1) column(9) ==> 1: var b = ' {#considerations-switching-javascript-mode__codeblock_bqh_2vz_pcc} | La même chose que l'ES5, mais avec une maniabilité plus robuste et des messages d'erreur plus clairs dans les moteurs mis à jour. Exemple : SyntaxError: Unterminated string constant at line 1 ==> 1: var b = ' {#considerations-switching-javascript-mode__codeblock_cqh_2vz_pcc} | | Incrémenter et décrémenter | Autorisé sur les variables, mais peut se comporter de façon inattendue avec des expressions complexes. Impressions: *** Script: c: 1 *** Script: gr.related_incidents: 1 *** Script: 2 *** Script: 3 {#considerations-switching-javascript-mode__codeblock_dqh_2vz_pcc} | Amélioration de la clarté, mais toujours autorisée sur les variables (`var`, `let`, `const`). Impressions: sn_es5: c: 0 sn_es5: gr.related_incidents: 1 sn_es5: 1 sn_es5: 2 {#considerations-switching-javascript-mode__codeblock_eqh_2vz_pcc} | La même chose que ES5, avec des règles plus strictes dans certains contextes (par exemple, `const`). | | Continuations de lignes | Autorisé avec une barre oblique inverse (`\`) mais déconseillé en raison de problèmes de lisibilité. Dans cet exemple, les trois fonctions sont appelées. var expr = doFoo(); // do foo doBar(); // do bar finish(); // all done eval(expr); {#considerations-switching-javascript-mode__codeblock_fqh_2vz_pcc} | Identique au mode de compatibilité ; Aucun changement dans la gestion des continuations de ligne. Dans l'exemple précédent, ES5 n'appelle que la première fonction et traite tout ce qui suit le premier commentaire, y compris la nouvelle ligne, comme un commentaire jusqu'à la fin de l'expression. | C'est la même chose que ES5, mais les littéraux de modèle offrent une alternative plus lisible. | | Points-virgules manquants | L'insertion automatique de points-virgules (ASI) conduisait souvent à un comportement inattendu. | Lève une erreur de syntaxe lorsqu'un point-virgule est manquant. | Identique à ES5. Les pratiques mises à jour encouragent les points-virgules explicites. | | Fonctions inexistantes | L'appel d'une fonction inexistante lève une `ReferenceError`. | Lève une `TypeError` si une non-fonction est appelée. | Lève une EcmaError lorsqu'une fonction inexistante est appelée ou qu'une propriété est référencée. | | Propriétés inexistantes | L'accès à une propriété inexistante renvoie `un nombre indéfini` ; Aucune erreur n'a été générée. | Identique à pré-ES5. | Identique au mode Compatibilité et au mode ES5 Standards. | | Littéraux numériques | Littéraux décimaux et hexadécimaux de base. | Introduction de règles d'analyse plus strictes et d'une meilleure gestion des littéraux numériques. | Ajout de littéraux binaires (`0b`), octaux (`0o`) et BigInt (`123n`). | | Mot clé réservé en tant que propriété | L'utilisation de mots clés réservés n'est pas possible. | Les mots-clés réservés peuvent être utilisés comme noms de propriétés sans erreur, par exemple, `obj.for`. Imprime l'objet lorsqu'il est renvoyé. | Identique à ES5. | | Traiter let et yield comme des mots clés | `let` et `yield` ne sont pas des mots-clés et ne peuvent être utilisés que comme identifiants. | `let` est présenté comme un mot-clé. `Le rendement` est réservé en mode strict. | Les deux sont des mots-clés. Les utiliser comme identificateurs entraîne des erreurs de syntaxe. | [Tableau 1. Différences de comportement en mode JavaScript] {#considerations-switching-javascript-mode__table_r4b_j4r_fcc}