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 d'exécution pour CloudFront Functions L'environnement JavaScript d'exécution CloudFront Functions est compatible avec [ECMAScript (ES) version 5.1](https://www.ecma-international.org/ecma-262/5.1/) et prend également en charge certaines fonctionnalités des versions ES 6 à 12. Pour la plupart des up-to-date fonctionnalités, nous vous recommandons JavaScript d'utiliser Runtime 2.0. Les fonctionnalités JavaScript d'exécution 2.0 présentent les modifications suivantes par rapport à la version 1.0 : + Les méthodes du module Buffer sont disponibles + Les méthodes de prototype de chaîne non standard suivantes ne sont pas disponibles : + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + Voici les nouveautés du module cryptographique : + `hash.digest()` : le type de retour est remplacé par `Buffer` si aucun encodage n’est fourni + `hmac.digest()` : le type de retour est remplacé par `Buffer` si aucun encodage n’est fourni + Pour plus d’informations sur les nouvelles fonctionnalités supplémentaires, consultez [JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [JavaScript fonctionnalités de Runtime 1.0](functions-javascript-runtime-10.md) + [JavaScript fonctionnalités de Runtime 2.0](functions-javascript-runtime-20.md) # 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. # JavaScript fonctionnalités d'exécution 2.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 à 12. Il fournit également des méthodes non standard qui ne font pas partie des spécifications ES. Les rubriques suivantes répertorient toutes les fonctionnalités de cet environnement d’exécution. **Topics** + [ ## Fonctions de base ](#writing-functions-javascript-features-core-20) + [ ## Objets primitifs ](#writing-functions-javascript-features-primitive-objects-20) + [ ## Objets intégrés ](#writing-functions-javascript-features-builtin-objects-20) + [ ## Types d’erreurs ](#writing-functions-javascript-features-error-types-20) + [ ## Globals ](#writing-functions-javascript-features-globals-20) + [ ## Modules intégrés ](#writing-functions-javascript-features-builtin-modules-20) + [ ## Fonctions limitées ](#writing-functions-javascript-features-restricted-features-20) ## 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 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 ES 5.1 suivantes sont prises en charge : + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` Les instructions ES 6 suivantes sont prises en charge : + `const` + `let` Les instructions ES 8 suivantes sont prises en charge : + `async` + `await` `async`, `await``const`, et `let` sont pris en charge dans JavaScript Runtime 2.0. `await` ne peut être utilisé qu’à l’intérieur de fonctions `async`. Les arguments et fermetures `async` ne sont pas pris en charge. **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 : + `Object.create()` (sans liste de propriétés) + `Object.defineProperties()` + `Object.defineProperty()` + `Object.freeze()` + `Object.getOwnPropertyDescriptor()` + `Object.getOwnPropertyDescriptors()` + `Object.getOwnPropertyNames()` + `Object.getPrototypeOf()` + `Object.isExtensible()` + `Object.isFrozen()` + `Object.isSealed()` + `Object.keys()` + `Object.preventExtensions()` + `Object.seal()` Les méthodes ES 6 suivantes sur les objets sont prises en charge : + `Object.assign()` Les méthodes ES 8 suivantes sur les objets sont prises en charge : + `Object.entries()` + `Object.values()` Les méthodes de prototype d’ES 5.1 suivantes sur les objets sont prises en charge : + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Les méthodes de prototype d’ES 6 suivantes sur les objets sont prises en charge : + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **String** Les méthodes ES 5.1 suivantes sur les chaînes sont prises en charge : + `String.fromCharCode()` Les méthodes ES 6 suivantes sur les chaînes sont prises en charge : + `String.fromCodePoint()` Les méthodes de prototype d’ES 5.1 suivantes sur les chaînes sont prises en charge : + `String.prototype.charAt()` + `String.prototype.concat()` + `String.prototype.indexOf()` + `String.prototype.lastIndexOf()` + `String.prototype.match()` + `String.prototype.replace()` + `String.prototype.search()` + `String.prototype.slice()` + `String.prototype.split()` + `String.prototype.substr()` + `String.prototype.substring()` + `String.prototype.toLowerCase()` + `String.prototype.trim()` + `String.prototype.toUpperCase()` Les méthodes de prototype d’ES 6 suivantes sur les chaînes sont prises en charge : + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Les méthodes de prototype d’ES 8 suivantes sur les chaînes sont prises en charge : + `String.prototype.padStart()` + `String.prototype.padEnd()` Les méthodes de prototype d’ES 9 suivantes sur les chaînes sont prises en charge : + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Les méthodes de prototype d’ES 12 suivantes sur les chaînes sont prises en charge : + `String.prototype.replaceAll()` **Note** `String.prototype.replaceAll()`est nouveau dans JavaScript Runtime 2.0. **Number** TOUS les nombres d’ES 5 sont pris en charge. Les propriétés d’ES 6 suivantes sur les nombres sont prises en charge : + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Les méthodes ES 6 suivantes sur les nombres sont prises en charge : + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Les méthodes de prototype d’ES 5.1 suivantes sur les nombres sont prises en charge : + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Les séparateurs numériques d’ES 12 sont pris en charge. Les séparateurs numériques ES 12 sont nouveaux dans JavaScript Runtime 2.0. ## 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 propriétés mathématiques d’ES 6 suivantes sont prises en charge : + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Les méthodes mathématiques ES 6 suivantes sont prises en charge : + `Math.abs()` + `Math.acos()` + `Math.acosh()` + `Math.asin()` + `Math.asinh()` + `Math.atan()` + `Math.atan2()` + `Math.atanh()` + `Math.cbrt()` + `Math.ceil()` + `Math.clz32()` + `Math.cos()` + `Math.cosh()` + `Math.exp()` + `Math.expm1()` + `Math.floor()` + `Math.fround()` + `Math.hypot()` + `Math.imul()` + `Math.log()` + `Math.log1p()` + `Math.log2()` + `Math.log10()` + `Math.max()` + `Math.min()` + `Math.pow()` + `Math.random()` + `Math.round()` + `Math.sign()` + `Math.sinh()` + `Math.sin()` + `Math.sqrt()` + `Math.tan()` + `Math.tanh()` + `Math.trunc()` **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](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Fonction** Les méthodes de prototype d’ES 5.1 suivantes sont prises en charge : + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` 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 propriétés d’accesseur de prototype d’ES 5.1 suivantes sont prises en charge : + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **Note** `RegExp.prototype.sticky`et `RegExp.prototype.flags` sont nouveaux dans JavaScript Runtime 2.0. Les méthodes de prototype d’ES 5.1 suivantes sont prises en charge : + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **Note** `RegExp.prototype[@@split]()`est nouveau dans JavaScript Runtime 2.0. Les propriétés d’instance d’ES 5.1 suivantes sont prises en charge : + `lastIndex` Les groupes de capture nommés ES 9 sont pris en charge. **JSON** Les méthodes d’ES 5.1 suivantes sont prises en charge : + `JSON.parse()` + `JSON.stringify()` **Array** Les méthodes ES 5.1 suivantes sur les tableaux sont prises en charge : + `Array.isArray()` Les méthodes ES 6 suivantes sur les tableaux sont prises en charge : + `Array.of()` Les méthodes de prototype d’ES 5.1 suivantes sont prises en charge : + `Array.prototype.concat()` + `Array.prototype.every()` + `Array.prototype.filter()` + `Array.prototype.forEach()` + `Array.prototype.indexOf()` + `Array.prototype.join()` + `Array.prototype.lastIndexOf()` + `Array.prototype.map()` + `Array.prototype.pop()` + `Array.prototype.push()` + `Array.prototype.reduce()` + `Array.prototype.reduceRight()` + `Array.prototype.reverse()` + `Array.prototype.shift()` + `Array.prototype.slice()` + `Array.prototype.some()` + `Array.prototype.sort()` + `Array.prototype.splice()` + `Array.prototype.unshift()` Les méthodes de prototype d’ES 6 suivantes sont prises en charge : + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Les méthodes de prototype d’ES 7 suivantes sont prises en charge : + `Array.prototype.includes()` **Tableaux typés** Les constructeurs de tableaux typés d’ES 6 suivants sont pris en charge : + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Les méthodes d’ES 6 suivantes sont prises en charge : + `TypedArray.from()` + `TypedArray.of()` **Note** `TypedArray.from()`et `TypedArray.of()` sont nouveaux dans JavaScript Runtime 2.0. Les méthodes de prototype d’ES 6 suivantes sont prises en charge : + `TypedArray.prototype.copyWithin()` + `TypedArray.prototype.every()` + `TypedArray.prototype.fill()` + `TypedArray.prototype.filter()` + `TypedArray.prototype.find()` + `TypedArray.prototype.findIndex()` + `TypedArray.prototype.forEach()` + `TypedArray.prototype.includes()` + `TypedArray.prototype.indexOf()` + `TypedArray.prototype.join()` + `TypedArray.prototype.lastIndexOf()` + `TypedArray.prototype.map()` + `TypedArray.prototype.reduce()` + `TypedArray.prototype.reduceRight()` + `TypedArray.prototype.reverse()` + `TypedArray.prototype.some()` + `TypedArray.prototype.set()` + `TypedArray.prototype.slice()` + `TypedArray.prototype.sort()` + `TypedArray.prototype.subarray()` + `TypedArray.prototype.toString()` **Note** `TypedArray.prototype.every()`,`TypedArray.prototype.fill()`,`TypedArray.prototype.filter()`,`TypedArray.prototype.find()`,`TypedArray.prototype.findIndex()`,,`TypedArray.prototype.forEach()`,`TypedArray.prototype.includes()`,`TypedArray.prototype.indexOf()`,`TypedArray.prototype.join()`,`TypedArray.prototype.lastIndexOf()`,`TypedArray.prototype.map()`,`TypedArray.prototype.reduce()`,`TypedArray.prototype.reduceRight()`,`TypedArray.prototype.reverse()`, et `TypedArray.prototype.some()` sont nouveaux dans JavaScript Runtime 2.0. **ArrayBuffer** Les méthodes ES 6 suivantes ArrayBuffer sont prises en charge : + `isView()` Les méthodes de prototypage ES 6 suivantes ArrayBuffer sont prises en charge : + `ArrayBuffer.prototype.slice()` **Promesse** Les méthodes d’ES 6 suivantes sur les promesses sont prises en charge : + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **Note** `Promise.all()`, `Promise.allSettled()``Promise.any()`, et `Promise.race()` sont nouveaux dans JavaScript Runtime 2.0. Les méthodes de prototype d’ES 6 suivantes sur les promesses sont prises en charge : + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Les méthodes de prototype d’ES 6 suivantes sont prises en charge : + `DataView.prototype.getFloat32()` + `DataView.prototype.getFloat64()` + `DataView.prototype.getInt16()` + `DataView.prototype.getInt32()` + `DataView.prototype.getInt8()` + `DataView.prototype.getUint16()` + `DataView.prototype.getUint32()` + `DataView.prototype.getUint8()` + `DataView.prototype.setFloat32()` + `DataView.prototype.setFloat64()` + `DataView.prototype.setInt16()` + `DataView.prototype.setInt32()` + `DataView.prototype.setInt8()` + `DataView.prototype.setUint16()` + `DataView.prototype.setUint32()` + `DataView.prototype.setUint8()` **Note** Toutes les méthodes de prototypage de Dataview ES 6 sont nouvelles dans JavaScript Runtime 2.0. **Symbol** Les méthodes d’ES 6 suivantes sont prises en charge : + `Symbol.for()` + `Symbol.keyfor()` **Note** Toutes les méthodes Symbol ES 6 sont nouvelles dans JavaScript Runtime 2.0. **TextDecoder** Les méthodes de prototype suivantes sont prises en charge : + `TextDecoder.prototype.decode()` Les propriétés d’accesseur de prototype suivantes sont prises en charge : + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **TextEncoder** Les méthodes de prototype suivantes sont prises en charge : + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` **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` + `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 fonctions globales d’ES 6 suivantes sont prises en charge : + `atob()` + `btoa()` **Note** `atob()`et `btoa()` sont nouveaux dans JavaScript Runtime 2.0. Les constantes globales suivantes sont prises en charge : + `NaN` + `Infinity` + `undefined` + `arguments` ## Modules intégrés Les modules intégrés suivants sont pris en charge. **Topics** + [ ### Buffer ](#writing-functions-javascript-features-builtin-modules-buffer-20) + [ ### Chaîne de requête ](#writing-functions-javascript-features-builtin-modules-query-string-20) + [ ### Cryptographie ](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Buffer Le module fournit les méthodes suivantes : + `Buffer.alloc(size[, fill[, encoding]])` Allouez un élément `Buffer`. + `size` : taille du tampon. Entrez un entier. + `fill`: Facultatif. Entrez une chaîne, un élément `Buffer`, un élément Uint8Array ou un entier. La valeur par défaut est `0`. + `encoding`: Facultatif. Quand `fill` est une chaîne, entrez l’une des valeurs suivantes : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. + `Buffer.allocUnsafe(size)` Allouez un élément `Buffer` non initialisé. + `size` : entrez un entier. + `Buffer.byteLength(value[, encoding])` Renvoie la longueur d’une valeur, en octets. + `value`: chaîne, `Buffer` TypedArray, Dataview ou Arraybuffer. + `encoding`: Facultatif. Quand `value` est une chaîne, entrez l’une des valeurs suivantes : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. + `Buffer.compare(buffer1, buffer2)` Comparez deux éléments `Buffer` pour faciliter le tri des tableaux. Renvoie `0` s’ils sont identiques, `-1` si `buffer1` figure en premier, ou `1` si `buffer2` figure en premier. + `buffer1` : entrez un élément `Buffer`. + `buffer2` : entrez un autre élément `Buffer`. + `Buffer.concat(list[, totalLength])` Concaténez plusieurs éléments `Buffer`. Renvoie `0` s’il n’y en a aucun. Renvoie jusqu’à `totalLength`. + `list` : entrez une liste d’éléments `Buffer`. Notez que cela sera tronqué à `totalLength`. + `totalLength`: Facultatif. Entrez un entier non signé. Utilisez la somme des instances `Buffer` dans la liste si le paramètre est vide. + `Buffer.from(array)` Créez un élément `Buffer` à partir d’un tableau. + `array` : entrez un tableau d’octets de `0` à `255`. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Créez une vue à partir de `arrayBuffer`, en commençant par le décalage `byteOffset` avec la longueur `length`. + `arrayBuffer` : entrez un tableau `Buffer`. + `byteOffset` : entrez un entier. + `length`: Facultatif. Entrez un entier. + `Buffer.from(buffer)` Créez une copie de l’élément `Buffer`. + `buffer` : entrez un élément `Buffer`. + `Buffer.from(object[, offsetOrEncoding[, length]])` Créez un élément `Buffer` à partir d’un objet. Renvoie `Buffer.from(object.valueOf(), offsetOrEncoding, length)` si `valueOf()` n’est pas égal à l’objet. + `object` : entrez un objet. + `offsetOrEncoding`: Facultatif. Entrez un entier ou une chaîne d’encodage. + `length`: Facultatif. Entrez un entier. + `Buffer.from(string[, encoding])` Créez un élément `Buffer` à partir d’une chaîne. + `string` : entrez une chaîne. + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. + `Buffer.isBuffer(object)` Vérifiez si `object` est un tampon. Renvoie `true` ou `false`. + `object` : entrez un objet. + `Buffer.isEncoding(encoding)` Vérifiez si `encoding` est pris en charge. Renvoie `true` ou `false`. + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. Le module fournit les méthodes de prototype de tampon suivantes : + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Comparez `Buffer` avec la cible. Renvoie `0` s’ils sont identiques, `1` si `buffer` figure en premier, ou `-1` si `target` figure en premier. + `target` : entrez un élément `Buffer`. + `targetStart`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `targetEnd`: Facultatif. Entrez un entier. La valeur par défaut est la longueur `target`. + `sourceStart`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `sourceEnd`: Facultatif. Entrez un entier. La valeur par défaut est la longueur de `Buffer`. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Copiez le tampon dans `target`. + `target` : entrez un élément `Buffer` ou `Uint8Array`. + `targetStart`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `sourceStart`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `sourceEnd`: Facultatif. Entrez un entier. La valeur par défaut est la longueur de `Buffer`. + `Buffer.prototype.equals(otherBuffer)` Comparez `Buffer` à `otherBuffer`. Renvoie `true` ou `false`. + `otherBuffer` : entrez une chaîne. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Remplissez `Buffer` avec `value`. + `value` : entrez une chaîne, `Buffer` ou un entier. + `offset`: Facultatif. Entrez un entier. + `end`: Facultatif. Entrez un entier. + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Recherchez `value` dans `Buffer`. Renvoie `true` ou `false`. + `value` : entrez une chaîne, un élément `Buffer`, `Uint8Array` ou un entier. + `byteOffset`: Facultatif. Entrez un entier. + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Recherchez le premier élément `value` dans `Buffer`. Retourne `index` s’il est trouvé ou `-1` dans le cas contraire. + `value` : entrez une chaîne, `Buffer`, Unit8Array ou un entier compris entre 0 et 255. + `byteOffset`: Facultatif. Entrez un entier. + `encoding`: Facultatif. Entrez l’un des éléments suivants si `value` est une chaîne : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Recherchez le dernier élément `value` dans `Buffer`. Retourne `index` s’il est trouvé ou `-1` dans le cas contraire. + `value` : entrez une chaîne, `Buffer`, Unit8Array ou un entier compris entre 0 et 255. + `byteOffset`: Facultatif. Entrez un entier. + `encoding`: Facultatif. Entrez l’un des éléments suivants si `value` est une chaîne : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`. + `Buffer.prototype.readInt8(offset)` Lisez `Int8` à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readIntBE(offset, byteLength)` Lisez `Int` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `byteLength`: Facultatif. Entrez un entier compris entre `1` et `6`. + `Buffer.prototype.readInt16BE(offset)` Lisez `Int16` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readInt32BE(offset)` Lisez `Int32` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readIntLE(offset, byteLength)` Lisez `Int` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.readInt16LE(offset)` Lisez `Int16` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readInt32LE(offset)` Lisez `Int32` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readUInt8(offset)` Lisez `UInt8` à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readUIntBE(offset, byteLength)` Lisez `UInt` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.readUInt16BE(offset)` Lisez `UInt16` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + + `offset` : entrez un entier. + `Buffer.prototype.readUInt32BE(offset)` Lisez `UInt32` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readUIntLE(offset, byteLength)` Lisez `UInt` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.readUInt16LE(offset)` Lisez `UInt16` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readUInt32LE(offset)` Lisez `UInt32` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset` : entrez un entier. + `Buffer.prototype.readDoubleBE([offset])` Lisez une valeur double 64 bits dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + `offset`: Facultatif. Entrez un entier. + `Buffer.prototype.readDoubleLE([offset])` Lisez une valeur double 64 bits dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset`: Facultatif. Entrez un entier. + `Buffer.prototype.readFloatBE([offset])` Lisez une valeur float 32 bits dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`. + `offset`: Facultatif. Entrez un entier. + `Buffer.prototype.readFloatLE([offset])` Lisez une valeur float 32 bits dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`. + `offset`: Facultatif. Entrez un entier. + `Buffer.prototype.subarray([start[, end]])` Renvoie une copie de l’élément `Buffer` décalée et recadrée avec de nouveaux éléments `start` et `end`. + `start`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `end`: Facultatif. Entrez un entier. La valeur par défaut est la longueur du tampon. + `Buffer.prototype.swap16()` Échangez l’ordre des octets du tableau `Buffer` en le traitant comme un tableau de nombres de 16 bits. La longueur de `Buffer` doit être divisible par 2, sans quoi vous recevrez une erreur. + `Buffer.prototype.swap32()` Échangez l’ordre des octets du tableau `Buffer` en le traitant comme un tableau de nombres de 32 bits. La longueur de `Buffer` doit être divisible par 4, sans quoi vous recevrez une erreur. + `Buffer.prototype.swap64()` Échangez l’ordre des octets du tableau `Buffer` en le traitant comme un tableau de nombres de 64 bits. La longueur de `Buffer` doit être divisible par 8, sans quoi vous recevrez une erreur. + `Buffer.prototype.toJSON()` Renvoie l’élément `Buffer` au format JSON. + `Buffer.prototype.toString([encoding[, start[, end]]])` Convertissez l’élément `Buffer`, de `start` à `end`, en chaîne encodée. + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64` ou `base64url`. La valeur par défaut est `utf8`. + `start`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `end`: Facultatif. Entrez un entier. La valeur par défaut est la longueur du tampon. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Écrivez l’élément `string` encodé dans `Buffer` s’il y a de l’espace, ou un élément `string` tronqué s’il n’y a pas assez d’espace. + `string` : entrez une chaîne. + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `length`: Facultatif. Entrez un entier. La valeur par défaut est la longueur de la chaîne. + `encoding`: Facultatif. Entrez éventuellement l’un des éléments suivants : `utf8`, `hex`, `base64` ou `base64url`. La valeur par défaut est `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Écrivez l’élément `value` `Int8` de `byteLength` à la position `offset` dans l’élément `Buffer`. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeIntLE(offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Écrivez l’élément `value` `UInt8` de `byteLength` à la position `offset` dans `Buffer`. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `value` : entrez un entier. + `offset` : entrez un entier. + `byteLength` : entrez un entier entre `1` et `6`. + `Buffer.prototype.writeDoubleBE(value, [offset])` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `value` : entrez un entier. + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste. + `value` : entrez un entier. + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste. + `value` : entrez un entier. + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0. Les méthodes d’instance suivantes sont prises en charge : + `buffer[index]` Obtenez et définissez l’octet (byte) à la position `index` dans l’élément `Buffer`. + Obtenez un nombre entre `0` et `255`. Ou définissez un nombre entre `0` et `255`. Les propriétés d’instance suivantes sont prises en charge : + `buffer` Obtenez l’objet `ArrayBuffer` pour le tampon. + `byteOffset` Obtenez l’élément `byteOffset` de l’objet `Arraybuffer` du tampon. + `length` Obtenez le nombre d’octets du tampon. **Note** Toutes les méthodes du module Buffer sont nouvelles dans JavaScript Runtime 2.0. ### 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. ### Cryptographie 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')`. **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`. ## 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. 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.