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. # JavaScript fonctionnalités de Runtime 1.0 pour CloudFront Functions L'environnement JavaScript d'exécution CloudFront Functions est compatible avec [ECMAScript (ES) version 5.1](https://262.ecma-international.org/5.1/) et prend également en charge certaines fonctionnalités des versions ES 6 à 9. Il fournit également des méthodes non standard qui ne font pas partie des spécifications ES. Les rubriques suivantes répertorient toutes les fonctions de langages prises en charge. **Topics** + [Fonctions de base](#writing-functions-javascript-features-core) + [Objets primitifs](#writing-functions-javascript-features-primitive-objects) + [Objets intégrés](#writing-functions-javascript-features-builtin-objects) + [Types d’erreurs](#writing-functions-javascript-features-error-types) + [Globals](#writing-functions-javascript-features-globals) + [Modules intégrés](#writing-functions-javascript-features-builtin-modules) + [Fonctions limitées](#writing-functions-javascript-features-restricted-features) ## Fonctions de base Les fonctions de base suivantes d'ES sont prises en charge. **Types** Tous les types ES 5.1 sont pris en charge, notamment les valeurs booléennes, les nombres, les chaînes, les objets, les tableaux, les fonctions, les constructeurs de fonctions et les expressions régulières. **Opérateurs** Tous les opérateurs ES 5.1 sont pris en charge. L’opérateur d’exponentiation ES 7 (`**`) est pris en charge. **Instructions** Les instructions `const` et `let` ne sont pas prises en charge. Les instructions ES 5.1 suivantes sont prises en charge : + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Instructions étiquetées **Littéraux** Les littéraux de modèles ES 6 sont pris en charge : chaînes multiligne, interpolation d'expression et modèles d'imbrication. **Fonctions** Toutes les fonctions ES 5.1 sont prises en charge. Les fonctions de flèche ES 6 ainsi que la syntaxe des paramètres du reste ES 6 sont prises en charge. **Unicode** Le texte source et les littéraux de chaînes peuvent contenir des caractères Unicode. Les séquences d’échappement de points de code Unicode de six caractères (par exemple `\uXXXX`) sont également prises en charge. **Mode strict** Les fonctions opèrent en mode strict par défaut. Vous n’avez donc pas besoin d’ajouter une instruction `use strict` dans votre code de fonction. Elles ne peuvent pas être modifiées. ## Objets primitifs Les objets primitifs suivants d'ES sont pris en charge. **Objet** Les méthodes ES 5.1 suivantes sur les objets sont prises en charge : + `create` (sans liste de propriétés) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Les méthodes ES 6 suivantes sur les objets sont prises en charge : + `assign` + `is` + `prototype.setPrototypeOf` Les méthodes ES 8 suivantes sur les objets sont prises en charge : + `entries` + `values` **String** Les méthodes ES 5.1 suivantes sur les chaînes sont prises en charge : + `fromCharCode` + `prototype.charAt` + `prototype.concat` + `prototype.indexOf` + `prototype.lastIndexOf` + `prototype.match` + `prototype.replace` + `prototype.search` + `prototype.slice` + `prototype.split` + `prototype.substr` + `prototype.substring` + `prototype.toLowerCase` + `prototype.trim` + `prototype.toUpperCase` Les méthodes ES 6 suivantes sur les chaînes sont prises en charge : + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Les méthodes ES 8 suivantes sur les chaînes sont prises en charge : + `prototype.padStart` + `prototype.padEnd` Les méthodes ES 9 suivantes sur les chaînes sont prises en charge : + `prototype.trimStart` + `prototype.trimEnd` Les méthodes non standard suivantes sur les chaînes sont prises en charge : + `prototype.bytesFrom(array | string, encoding)` Crée une chaîne d'octets à partir d'un tableau d'octets ou d'une chaîne encodée. Les options d'encodage de chaînes sont `hex`, `base64` et `base64url`. + `prototype.fromBytes(start[, end])` Crée une chaîne Unicode à partir d'une chaîne d'octets où chaque octet est remplacé par le point de code Unicode correspondant. + `prototype.fromUTF8(start[, end])` Crée une chaîne Unicode à partir d'une chaîne d'octets encodée en UTF-8. Si l'encodage est incorrect, il renvoie `null`. + `prototype.toBytes(start[, end])` Crée une chaîne d'octets à partir d'une chaîne Unicode. Tous les caractères doivent être dans la plage [0,255]. Dans le cas contraire, `null` est renvoyé. + `prototype.toUTF8(start[, end])` Crée une chaîne d'octets encodée en UTF-8 à partir d'une chaîne Unicode. **Nombre** Toutes les méthodes ES 5.1 sur les nombres sont prises en charge. Les méthodes ES 6 suivantes sur les nombres sont prises en charge : + `isFinite` + `isInteger` + `isNaN` + `isSafeInteger` + `parseFloat` + `parseInt` + `prototype.toExponential` + `prototype.toFixed` + `prototype.toPrecision` + `EPSILON` + `MAX_SAFE_INTEGER` + `MAX_VALUE` + `MIN_SAFE_INTEGER` + `MIN_VALUE` + `NEGATIVE_INFINITY` + `NaN` + `POSITIVE_INFINITY` ## Objets intégrés Les objets intégrés suivants d'ES sont pris en charge. **Mathématiques** Toutes les méthodes mathématiques ES 5.1 sont prises en charge. Dans l'environnement d'exécution de CloudFront Functions, l'`Math.random()`implémentation utilise `arc4random` OpenBSD prédéfini avec l'horodatage de l'exécution de la fonction. Les méthodes mathématiques ES 6 suivantes sont prises en charge : + `acosh` + `asinh` + `atanh` + `cbrt` + `clz32` + `cosh` + `expm1` + `fround` + `hypot` + `imul` + `log10` + `log1p` + `log2` + `sign` + `sinh` + `tanh` + `trunc` + `E` + `LN10` + `LN2` + `LOG10E` + `LOG2E` + `PI` + `SQRT1_2` + `SQRT2` **Date** Toutes les fonctions `Date` ES 5.1 sont prises en charge. Pour des raisons de sécurité, `Date` renvoie toujours la même valeur (l’heure de début de la fonction) pendant la durée de vie d’une même exécution de la fonction. Pour plus d’informations, consultez [Fonctions limitées](#writing-functions-javascript-features-restricted-features). **Fonction** Les méthodes `apply`, `bind` et `call` sont prises en charge. Les constructeurs de fonctions ne sont pas pris en charge. **Expressions régulières** Toutes les fonctions d'expression régulière ES 5.1 sont prises en charge. Le langage d’expression régulière est compatible Perl. Les groupes de capture nommés ES 9 sont pris en charge. **JSON** Toutes les fonctions JSON ES 5.1 sont prises en charge, notamment `parse` et `stringify`. **Array** Les méthodes ES 5.1 suivantes sur les tableaux sont prises en charge : + `isArray` + `prototype.concat` + `prototype.every` + `prototype.filter` + `prototype.forEach` + `prototype.indexOf` + `prototype.join` + `prototype.lastIndexOf` + `prototype.map` + `prototype.pop` + `prototype.push` + `prototype.reduce` + `prototype.reduceRight` + `prototype.reverse` + `prototype.shift` + `prototype.slice` + `prototype.some` + `prototype.sort` + `prototype.splice` + `prototype.unshift` Les méthodes ES 6 suivantes sur les tableaux sont prises en charge : + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Les méthodes ES 7 suivantes sur les tableaux sont prises en charge : + `prototype.includes` **Tableaux typés** Les tableaux typés ES 6 suivants sont pris en charge : + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Les méthodes suivantes sur `ArrayBuffer` sont prises en charge : + `prototype.isView` + `prototype.slice` **Promesse** Les méthodes suivantes sur les promesses sont prises en charge : + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Cryptographie** Le module cryptographique fournit des aides standard en matière de hachage et de code d'authentification de message basé sur le hachage (HMAC). Vous pouvez charger le module en utilisant `require('crypto')`. Le module fournit les méthodes suivantes, qui se comportent exactement comme leurs homologues Node.js : + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Pour plus d'informations, consultez [Cryptographie (hachage et HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) dans la section Modules intégrés. **Console** Il s'agit d'un objet d'aide pour le débogage. Il ne prend en charge que la méthode `log()`, pour enregistrer les messages de journaux. CloudFront Les fonctions ne prennent pas en charge la syntaxe des virgules, telle que`console.log('a', 'b')`. Utilisez plutôt le format `console.log('a' + ' ' + 'b')`. ## Types d’erreurs Les objets d’erreurs suivants sont pris en charge : + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globals L’objet `globalThis` est pris en charge. Les fonctions globales ES 5.1 suivantes sont prises en charge : + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Les constantes globales suivantes sont prises en charge : + `NaN` + `Infinity` + `undefined` ## Modules intégrés Les modules intégrés suivants sont pris en charge. **Topics** + [Cryptographie (hachage et HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) + [Chaîne de requête](#writing-functions-javascript-features-builtin-modules-query-string) ### Cryptographie (hachage et HMAC) Le module cryptographique (`crypto`) fournit des aides standard en matière de hachage et de code d’authentification de message basé sur le hachage (HMAC). Vous pouvez charger le module en utilisant `require('crypto')`. Le module fournit les méthodes suivantes, qui se comportent exactement comme leurs homologues Node.js. **Méthodes de hachage** `crypto.createHash(algorithm)` Crée et renvoie un objet de hachage que vous pouvez utiliser pour générer des résumés de hachage à l’aide de l’algorithme donné : `md5`, `sha1` ou `sha256`. `hash.update(data)` Met à jour le contenu de hachage avec les `data` données `hash.digest([encoding])` Calcule le résumé de toutes les données transmises à l’aide de `hash.update()`. L’encodage peut être `hex`, `base64` ou `base64url`. **Méthodes HMAC** `crypto.createHmac(algorithm, secret key)` Crée et renvoie un objet HMAC qui utilise le `algorithm` et la `secret key` donnés. L’algorithme peut être `md5`, `sha1` ou `sha256`. `hmac.update(data)` Met à jour le contenu HMAC avec les `data` données. `hmac.digest([encoding])` Calcule le résumé de toutes les données transmises à l’aide de `hmac.update()`. L’encodage peut être `hex`, `base64` ou `base64url`. ### Chaîne de requête **Note** L'[objet d'événement CloudFront Functions](functions-event-structure.md) analyse automatiquement les chaînes de requête d'URL pour vous. Cela signifie que, dans la plupart des cas, vous n'avez pas besoin d'utiliser ce module. Le module de chaînes de requêtes (`querystring`) fournit des méthodes d’analyse et de formatage des chaînes de requêtes URL. Vous pouvez charger le module en utilisant `require('querystring')`. Le module fournit les méthodes suivantes : `querystring.escape(string)` Encode par URL la `string` donnée, en renvoyant une chaîne de requêtes échappée. La méthode est utilisée par `querystring.stringify()` et ne doit pas être utilisée directement. `querystring.parse(string[, separator[, equal[, options]]])` Analyse une chaîne de requêtes (`string`) et renvoie un objet. Le paramètre `separator` est une sous-chaîne permettant de délimiter les paires clé-valeur dans la chaîne de requêtes. Par défaut, il s’agit de `&`. Le paramètre `equal` est une sous-chaîne permettant de délimiter les clés et les valeurs dans la chaîne de requêtes. Par défaut, il s’agit de `=`. Le paramètre `options` est un objet avec les clés suivantes : `decodeURIComponent function` Fonction pour décoder les caractères encodés en pourcentage dans la chaîne de requêtes. Par défaut, il s’agit de `querystring.unescape()`. `maxKeys number` Nombre maximal de clés à analyser. Par défaut, il s’agit de `1000`. Utilisez une valeur de `0` pour supprimer les limitations pour le comptage des clés. Par défaut, les caractères encodés en pourcentage dans la chaîne de requêtes sont supposés utiliser l'encodage UTF-8. Les séquences UTF-8 non valides sont remplacées par le caractère de remplacement `U+FFFD`. Par exemple, pour la chaîne de requêtes suivante : ``` 'name=value&abc=xyz&abc=123' ``` La valeur renvoyée de `querystring.parse()` est : ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` est un alias pour `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Sérialise un `object` et renvoie une chaîne de requêtes. Le paramètre `separator` est une sous-chaîne permettant de délimiter les paires clé-valeur dans la chaîne de requêtes. Par défaut, il s’agit de `&`. Le paramètre `equal` est une sous-chaîne permettant de délimiter les clés et les valeurs dans la chaîne de requêtes. Par défaut, il s’agit de `=`. Le paramètre `options` est un objet avec les clés suivantes : `encodeURIComponent function` Fonction à utiliser pour convertir des caractères non sûrs pour une URL en encodage en pourcentage dans la chaîne de requêtes. Par défaut, il s’agit de `querystring.escape()`. Par défaut, les caractères qui nécessitent un encodage en pourcentage dans la chaîne de requêtes sont encodés en UTF-8. Pour utiliser un encodage différent, spécifiez l’option `encodeURIComponent`. Par exemple, pour le code suivant : ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` La valeur renvoyée est : ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` est un alias pour `querystring.stringify()`. `querystring.unescape(string)` Décode les caractères encodés en pourcentage URL dans la `string` donnée, en renvoyant une chaîne de requêtes non échappée. Cette méthode est utilisée par `querystring.parse()` et ne doit pas être utilisée directement. ## Fonctions limitées Les fonctionnalités JavaScript linguistiques suivantes ne sont pas prises en charge ou sont restreintes pour des raisons de sécurité. **Évaluation dynamique du code** L'évaluation dynamique du code n'est pas prise en charge. Les deux constructeurs `eval()` et `Function` renvoient une erreur en cas de tentative. Par exemple, `const sum = new Function('a', 'b', 'return a + b')` renvoie une erreur. **Temporisateurs** Les fonctions `setTimeout()`, `setImmediate()` et `clearTimeout()` ne sont pas prises en charge. Il n'y a aucune disposition relative au report ou au produit dans une exécution de fonction. Votre fonction doit s'exécuter de manière synchrone jusqu'à la fin. **Horodatages** Pour des raisons de sécurité, il n'y a pas d'accès aux temporisateurs haute résolution. Toutes les méthodes `Date` pour interroger l’heure actuelle retournent toujours la même valeur pendant la durée de vie d’une même exécution de la fonction. L'horodatage renvoyé est l'heure à laquelle la fonction a commencé à s'exécuter. Par conséquent, vous ne pouvez pas mesurer le temps écoulé dans votre fonction. **Accès au système de fichiers** Il n’y a pas d’accès au système de fichiers. Par exemple, il n’y a pas de module `fs` pour l’accès au système de fichiers comme dans Node.js. **Accès au traitement** Il n’y a aucun accès au traitement. Par exemple, il n’existe pas d’objet global `process` pour accéder aux informations de traitement, comme c’est le cas dans Node.js. **Variables d’environnement** Il n’y a aucun accès aux variables d’environnement. Vous pouvez plutôt créer une banque CloudFront KeyValueStore de données centralisée de paires clé-valeur pour vos fonctions. CloudFront CloudFront KeyValueStore permet des mises à jour dynamiques de vos données de configuration sans qu'il soit nécessaire de déployer des modifications de code. Vous devez utiliser [JavaScript Runtime 2.0](functions-javascript-runtime-20.md) pour utiliser CloudFront KeyValueStore. Pour de plus amples informations, veuillez consulter [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Accès réseau** Les appels réseau ne sont pas pris en charge. Par exemple, XHR, HTTP(S) et socket ne sont pas pris en charge.