JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions - Amazon CloudFront
Fonctions de baseObjets primitifsObjets intégrésTypes d’erreursGlobalsModules intégrésFonctions limitées

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 2.0 pour CloudFront Functions

L'environnement JavaScript d'exécution CloudFront Functions est compatible avec ECMAScript (ES) version 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.

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 :

  • async

  • await

  • const

  • let

    Note

    async, awaitconst, et let sont nouveaux dans JavaScript Runtime 2.0.

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.

Nombre

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.

Note

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.

Note

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.

Note

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.

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.stickyet 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()

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.

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 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.

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.