# Características del tiempo de ejecución de JavaScript para CloudFront Functions El entorno de tiempo de ejecución JavaScript de CloudFront Functions es compatible con la [versión 5.1 de ECMAScript (ES)](https://www.ecma-international.org/ecma-262/5.1/) y también admite algunas características de las versiones 6 a 12 de ES. Para obtener las características más actualizadas, le recomendamos que utilice el tiempo de ejecución 2.0 de JavaScript. Las características del tiempo de ejecución 2.0 de JavaScript presentan los siguientes cambios en comparación con la versión 1.0: + Están disponibles los métodos del módulo de búfer + No están disponibles los siguientes métodos de prototipos de cadenas no estándares: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + El módulo criptográfico presenta los siguientes cambios: + `hash.digest()`: el tipo de retorno se cambia a `Buffer` si no se proporciona ninguna codificación + `hmac.digest()`: el tipo de retorno se cambia a `Buffer` si no se proporciona ninguna codificación + Para obtener más información sobre nuevas características adicionales, consulte [Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [Características del tiempo de ejecución 1.0 de JavaScript](functions-javascript-runtime-10.md) + [Características del tiempo de ejecución 2.0 de JavaScript](functions-javascript-runtime-20.md) # Características del tiempo de ejecución 1.0 de JavaScript para CloudFront Functions El entorno de tiempo de ejecución JavaScript de CloudFront Functions es compatible con [la versión 5.1 de ECMAScript (ES)](https://262.ecma-international.org/5.1/) y también admite algunas características de las versiones 6 a 9 de ES. También proporciona algunos métodos no estándar que no forman parte de las especificaciones de ES. En los siguientes temas se mencionan todas las características de lenguaje admitidas. **Topics** + [ ## Características principales ](#writing-functions-javascript-features-core) + [ ## Objetos primitivos ](#writing-functions-javascript-features-primitive-objects) + [ ## Objetos integrados ](#writing-functions-javascript-features-builtin-objects) + [ ## Tipos de error ](#writing-functions-javascript-features-error-types) + [ ## Globals ](#writing-functions-javascript-features-globals) + [ ## Módulos integrados ](#writing-functions-javascript-features-builtin-modules) + [ ## Características restringidas ](#writing-functions-javascript-features-restricted-features) ## Características principales Se admiten las siguientes características principales de ES. **Types** Se admiten todos los tipos de ES 5.1. Esto incluye valores booleanos, números, cadenas, objetos, matrices, funciones, constructores de funciones y expresiones regulares. **Operadores** Se admiten todos los operadores de ES 5.1. Se admite el operador de exponenciación ES 7 (`**`). **Instrucciones** No se admiten las instrucciones `const` ni `let`. Se admiten las siguientes instrucciones de ES 5.1: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Instrucciones etiquetadas **Literales** Se admiten literales de plantilla de ES 6: cadenas de líneas múltiples, interpolación de expresiones y plantillas de anidamiento. **Funciones** Se admiten todas las características de función de ES 5.1. Se admiten las funciones flecha de ES 6 así como la sintaxis del parámetro rest de ES 6. **Unicode** El texto de origen y los literales de cadena pueden contener caracteres codificados en Unicode. También se admiten secuencias de escape de punto de código Unicode de seis caracteres (por ejemplo, `\uXXXX`). **Modo estricto** Las funciones operan en modo estricto de forma predeterminada, por lo que no necesita agregar una instrucción `use strict` en su código de función. Esto no se puede cambiar. ## Objetos primitivos Se admiten los siguientes objetos primitivos de ES. **Objeto** Se admiten los siguientes métodos de ES 5.1 en objetos: + `create` (sin lista de propiedades) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Se admiten los siguientes métodos de ES 6 en objetos: + `assign` + `is` + `prototype.setPrototypeOf` Se admiten los siguientes métodos de ES 8 en objetos: + `entries` + `values` **Cadena** Se admiten los siguientes métodos de ES 5.1 en cadenas: + `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` Se admiten los siguientes métodos de ES 6 en cadenas: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Se admiten los siguientes métodos de ES 8 en cadenas: + `prototype.padStart` + `prototype.padEnd` Se admiten los siguientes métodos de ES 9 en cadenas: + `prototype.trimStart` + `prototype.trimEnd` Se admiten los siguientes métodos no estándar en cadenas: + `prototype.bytesFrom(array | string, encoding)` Crea una cadena de bytes a partir de una matriz de octetos o una cadena codificada. Las opciones de codificación de cadenas son `hex`, `base64` y `base64url`. + `prototype.fromBytes(start[, end])` Crea una cadena Unicode a partir de una cadena de bytes donde cada byte se reemplaza con el punto de código Unicode correspondiente. + `prototype.fromUTF8(start[, end])` Crea una cadena Unicode a partir de una cadena de bytes codificada en UTF-8. Si la codificación es incorrecta, devuelve `null`. + `prototype.toBytes(start[, end])` Crea una cadena de bytes a partir de una cadena Unicode. Todos los caracteres deben estar comprendidos en el rango [0-255]. De lo contrario, devuelve `null`. + `prototype.toUTF8(start[, end])` Crea una cadena de bytes codificada en UTF-8 a partir de una cadena Unicode. **Número** Se admiten todos los métodos de ES 5.1 en números. Se admiten los siguientes métodos de ES 6 en números: + `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` ## Objetos integrados Se admiten los siguientes objetos integrados de ES. **Math** Se admiten todos los métodos matemáticos de ES 5.1. En el entorno de tiempo de ejecución de CloudFront Functions, la implementación de `Math.random()` utiliza `arc4random` de OpenBSD predefinido con la marca de tiempo de cuándo se ejecuta la función. Se admiten los siguientes métodos matemáticos de ES 6: + `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` **Fecha** Se admiten todas las características `Date` de ES 5.1. Por razones de seguridad, `Date` siempre devuelve el mismo valor (la hora de inicio de la función) durante la vida útil de la ejecución de una sola función. Para obtener más información, consulte [Características restringidas](#writing-functions-javascript-features-restricted-features). **Función** Se admiten los métodos `apply`, `bind` y `call`. Los constructores de funciones no son compatibles. **Expresiones regulares** Se admiten todas las características de expresión regular de ES 5.1. El lenguaje de expresión regular es compatible con Perl. Se admiten grupos de captura con nombre de ES 9. **JSON** Se admiten todas las características JSON de ES 5.1, incluidas `parse` y `stringify`. **Matriz** Se admiten los siguientes métodos de ES 5.1 en matrices: + `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` Se admiten los siguientes métodos de ES 6 en matrices: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Se admiten los siguientes métodos de ES 7 en matrices: + `prototype.includes` **Matrices con tipo** Se admiten las siguientes matrices con tipo de ES 6: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Se admiten los siguientes métodos en `ArrayBuffer`: + `prototype.isView` + `prototype.slice` **Promesa** Se admiten los siguientes métodos en promesas: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Cripto** El módulo criptográfico proporciona ayudantes de código de autenticación de mensajes (HMAC) estándar hashing y basado en hash. Puede cargar el módulo mediante `require('crypto')`. El módulo expone los siguientes métodos que se comportan exactamente como sus homólogos Node.js: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Para obtener más información, consulte [Cripto (hash y HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) en la sección módulos integrados. **Consola** Este es un objeto ayudante para la depuración. Solo admite el método `log()` para registrar mensajes de registro. CloudFront Functions no admite la sintaxis con comas, como `console.log('a', 'b')`. En su lugar, utilice el formato `console.log('a' + ' ' + 'b')`. ## Tipos de error Se admiten los siguientes objetos de error: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globals Se admite el objeto `globalThis`. Se admiten las siguientes características globales de ES 5.1: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Se admiten las siguientes constantes globales: + `NaN` + `Infinity` + `undefined` ## Módulos integrados Se admiten los siguientes módulos integrados: **Topics** + [ ### Cripto (hash y HMAC) ](#writing-functions-javascript-features-builtin-modules-crypto) + [ ### Cadena de consulta ](#writing-functions-javascript-features-builtin-modules-query-string) ### Cripto (hash y HMAC) El módulo criptográfico (`crypto`) proporciona ayudantes de código de autenticación de mensajes basado en hash (HMAC) y hashing estándar. Puede cargar el módulo mediante `require('crypto')`. El módulo proporciona los siguientes métodos que se comportan exactamente como sus homólogos Node.js. **Métodos de hashing** `crypto.createHash(algorithm)` Crea y devuelve un objeto hash que puede utilizar para generar resúmenes hash mediante el algoritmo dado: `md5`, `sha1` o `sha256`. `hash.update(data)` Actualiza el contenido hash con los dado `data`. `hash.digest([encoding])` Calcula el resumen de todos los datos pasados con `hash.update()`. La codificación puede ser `hex`, `base64` o `base64url`. **Métodos HMAC** `crypto.createHmac(algorithm, secret key)` Crea y devuelve un objeto HMAC que utiliza el `algorithm` y `secret key` dados. El algoritmo puede ser `md5`, `sha1` o `sha256`. `hmac.update(data)` Actualiza el contenido de HMAC con los dado `data`. `hmac.digest([encoding])` Calcula el resumen de todos los datos pasados con `hmac.update()`. La codificación puede ser `hex`, `base64` o `base64url`. ### Cadena de consulta **nota** El objeto [ de evento de CloudFront Functions ](functions-event-structure.md) analiza automáticamente las cadenas de consulta de URL. Eso significa que en la mayoría de los casos no necesita usar este módulo. El módulo de cadena de consulta (`querystring`) proporciona métodos para analizar y dar formato a las cadenas de consulta de URL. Puede cargar el módulo mediante `require('querystring')`. El módulo proporciona los siguientes métodos. `querystring.escape(string)` La URL codifica la `string` dada y devuelve una cadena de consulta escapada. El método es utilizado por `querystring.stringify()` y no debe utilizarse directamente. `querystring.parse(string[, separator[, equal[, options]]])` Analiza una cadena de consulta (`string`) y devuelve un objeto. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `decodeURIComponent function` Una función para decodificar caracteres codificados por porcentaje en la cadena de consulta. De forma predeterminada, es `querystring.unescape()`. `maxKeys number` El número máximo de claves que se analizan. De forma predeterminada, es `1000`. Utilice un valor de `0` para eliminar las limitaciones del recuento de claves. De forma predeterminada, se supone que los caracteres codificados con porcentaje dentro de la cadena de consulta utilizan la codificación UTF-8. Las secuencias UTF-8 no válidas se reemplazan por el carácter de reemplazo `U+FFFD`. Por ejemplo, para la siguiente cadena de consulta: ``` 'name=value&abc=xyz&abc=123' ``` El valor de retorno de `querystring.parse()` es: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` es un alias de `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializa un `object` y devuelve una cadena de consulta. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `encodeURIComponent function` La función que se va a utilizar para convertir caracteres no seguros de URL a codificación porcentual en la cadena de consulta. De forma predeterminada, es `querystring.escape()`. De forma predeterminada, los caracteres que requieren codificación porcentual dentro de la cadena de consulta se codifican como UTF-8. Para utilizar una codificación diferente, especifique la opción `encodeURIComponent`. Por ejemplo, el siguiente código: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` El valor de retorno es: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` es un alias de `querystring.stringify()`. `querystring.unescape(string)` Decodifica caracteres codificados con porcentaje de URL en la `string` dada y devuelve una cadena de consulta sin escapar. Este método es utilizado por `querystring.parse()` y no debe utilizarse directamente. ## Características restringidas Las siguientes características de lenguaje JavaScript no se admiten o están restringidas debido a cuestiones de seguridad. **Evaluación dinámica de código** No se admite la evaluación dinámica de código. Si se intenta, los constructores `eval()` y `Function` arrojan un error. Por ejemplo, `const sum = new Function('a', 'b', 'return a + b')` arroja un error. **Temporizadores** No se admiten las funciones `setTimeout()`, `setImmediate()` y `clearTimeout()`. No hay nada para posponer o producir dentro de una ejecución de función. La función debe ejecutarse de manera sincrónica hasta finalizar. **Fecha y marcas temporales** Por razones de seguridad, no hay acceso a temporizadores de alta resolución. Todos los métodos `Date` para consultar la hora actual siempre devuelven el mismo valor durante la vida útil de una sola función ejecutada. La marca temporal devuelta es la hora en que la función comenzó a ejecutarse. Por eso, no puede medir el tiempo transcurrido en la función. **Acceso al sistema de archivos** No hay acceso al sistema de archivos. Por ejemplo, no hay ningún módulo `fs` para el acceso al sistema de archivos como lo hay en Node.js. **Acceso al proceso** No hay acceso al proceso. Por ejemplo, no hay ningún objeto global `process` para procesar el acceso a la información como lo hay en Node.js. **Variables de entorno** No hay acceso a las variables de entorno. En su lugar, puede utilizar CloudFront KeyValueStore para crear un almacén de datos centralizado de pares clave-valor para las CloudFront Functions. CloudFront KeyValueStore habilita las actualizaciones dinámicas de los datos de configuración sin necesidad de implementar cambios en el código. Debe utilizar el [tiempo de ejecución de JavaScript 2.0](functions-javascript-runtime-20.md) para utilizar CloudFront KeyValueStore. Para obtener más información, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Acceso a la red** No se admiten las llamadas de red. Por ejemplo, no se admite XHR, HTTP (S) ni socket. # Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions El entorno de tiempo de ejecución JavaScript de CloudFront Functions es compatible con la [versión 5.1 de ECMAScript (ES)](https://262.ecma-international.org/5.1/) y también admite algunas características de las versiones 6 a 12 de ES. También proporciona algunos métodos no estándar que no forman parte de las especificaciones de ES. En los siguientes temas se enumeran todas las características admitidas en este tiempo de ejecución. **Topics** + [ ## Características principales ](#writing-functions-javascript-features-core-20) + [ ## Objetos primitivos ](#writing-functions-javascript-features-primitive-objects-20) + [ ## Objetos integrados ](#writing-functions-javascript-features-builtin-objects-20) + [ ## Tipos de error ](#writing-functions-javascript-features-error-types-20) + [ ## Globals ](#writing-functions-javascript-features-globals-20) + [ ## Módulos integrados ](#writing-functions-javascript-features-builtin-modules-20) + [ ## Características restringidas ](#writing-functions-javascript-features-restricted-features-20) ## Características principales Se admiten las siguientes características principales de ES. **Types** Se admiten todos los tipos de ES 5.1. Esto incluye valores booleanos, números, cadenas, objetos, matrices, funciones y expresiones regulares. **Operadores** Se admiten todos los operadores de ES 5.1. Se admite el operador de exponenciación ES 7 (`**`). **Instrucciones** Se admiten las siguientes instrucciones de ES 5.1: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` Se admiten las siguientes instrucciones de ES 6: + `const` + `let` Se admiten las siguientes instrucciones de ES 8: + `async` + `await` El tiempo de ejecución 2.0 de JavaScript admite `async`, `await`, `const` y `let`. `await` solo se puede usar dentro de funciones `async`. No se admiten argumentos ni cierres de `async`. **Literales** Se admiten literales de plantilla de ES 6: cadenas de líneas múltiples, interpolación de expresiones y plantillas de anidamiento. **Funciones** Se admiten todas las características de función de ES 5.1. Se admiten las funciones flecha de ES 6 así como la sintaxis del parámetro rest de ES 6. **Unicode** El texto de origen y los literales de cadena pueden contener caracteres codificados en Unicode. También se admiten secuencias de escape de punto de código Unicode de seis caracteres (por ejemplo, `\uXXXX`). **Modo estricto** Las funciones operan en modo estricto de forma predeterminada, por lo que no necesita agregar una instrucción `use strict` en su código de función. Esto no se puede cambiar. ## Objetos primitivos Se admiten los siguientes objetos primitivos de ES. **Objeto** Se admiten los siguientes métodos de ES 5.1 en objetos: + `Object.create()` (sin lista de propiedades) + `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()` Se admiten los siguientes métodos de ES 6 en objetos: + `Object.assign()` Se admiten los siguientes métodos de ES 8 en objetos: + `Object.entries()` + `Object.values()` Se admiten los siguientes métodos prototipo de ES 5.1 en objetos: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Se admiten los siguientes métodos prototipo de ES 6 en objetos: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **Cadena** Se admiten los siguientes métodos de ES 5.1 en cadenas: + `String.fromCharCode()` Se admiten los siguientes métodos de ES 6 en cadenas: + `String.fromCodePoint()` Se admiten los siguientes métodos prototipo de ES 5.1 en cadenas: + `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()` Se admiten los siguientes métodos prototipo de ES 6 en cadenas: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Se admiten los siguientes métodos prototipo de ES 8 en cadenas: + `String.prototype.padStart()` + `String.prototype.padEnd()` Se admiten los siguientes métodos prototipo de ES 9 en cadenas: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Se admiten los siguientes métodos prototipo de ES 12 en cadenas: + `String.prototype.replaceAll()` **nota** `String.prototype.replaceAll()` es una novedad en el tiempo de ejecución 2.0 de JavaScript. **Número** Se admiten TODOS los números de ES 5. Se admiten las siguientes propiedades de ES 6 en números: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Se admiten los siguientes métodos de ES 6 en números: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Se admiten los siguientes métodos prototipo de ES 5.1 en números: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Se admiten los separadores numéricos ES 12. Los separadores numéricos ES 12 son nuevos en el tiempo de ejecución 2.0 de JavaScript. ## Objetos integrados Se admiten los siguientes objetos integrados de ES. **Math** Se admiten todos los métodos matemáticos de ES 5.1. En el entorno de tiempo de ejecución de CloudFront Functions, la implementación de `Math.random()` utiliza `arc4random` de OpenBSD predefinido con la marca de tiempo de cuándo se ejecuta la función. Se admiten las siguientes propiedades matemáticas de ES 6: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Se admiten los siguientes métodos matemáticos de ES 6: + `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()` **Fecha** Se admiten todas las características `Date` de ES 5.1. Por razones de seguridad, `Date` siempre devuelve el mismo valor (la hora de inicio de la función) durante la vida útil de la ejecución de una sola función. Para obtener más información, consulte [Características restringidas](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Función** Se admiten los siguientes métodos prototipo de ES 5.1: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` Los constructores de funciones no son compatibles. **Expresiones regulares** Se admiten todas las características de expresión regular de ES 5.1. El lenguaje de expresión regular es compatible con Perl. Se admiten las siguientes características de acceso prototipo de ES 5.1: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **nota** `RegExp.prototype.sticky` y `RegExp.prototype.flags` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten los siguientes métodos prototipo de ES 5.1: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **nota** `RegExp.prototype[@@split]()` es una novedad en el tiempo de ejecución 2.0 de JavaScript. Se admiten las siguientes propiedades de instancia de ES 5.1: + `lastIndex` Se admiten grupos de captura con nombre de ES 9. **JSON** Se admiten los siguientes métodos matemáticos de ES 5.1: + `JSON.parse()` + `JSON.stringify()` **Matriz** Se admiten los siguientes métodos de ES 5.1 en matrices: + `Array.isArray()` Se admiten los siguientes métodos de ES 6 en matrices: + `Array.of()` Se admiten los siguientes métodos prototipo de ES 5.1: + `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()` Se admiten los siguientes métodos prototipo de ES 6 + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Se admiten los siguientes métodos prototipo de ES 7: + `Array.prototype.includes()` **Matrices con tipo** Se admiten los siguientes constructores de matrices con tipo de ES 6: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Se admiten los siguientes métodos matemáticos de ES 6: + `TypedArray.from()` + `TypedArray.of()` **nota** `TypedArray.from()` y `TypedArray.of()` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten los siguientes métodos prototipo de ES 6: + `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()` **nota** `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()` y `TypedArray.prototype.some()` son novedades en el tiempo de ejecución 2.0 de JavaScript. **ArrayBuffer** Se admiten los siguientes métodos de ES 6 en ArrayBuffer: + `isView()` Se admiten los siguientes métodos prototipo de ES 6 en ArrayBuffer: + `ArrayBuffer.prototype.slice()` **Promesa** Se admiten los siguientes métodos de ES 6 en promesas: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **nota** `Promise.all()`, `Promise.allSettled()`, `Promise.any()` y `Promise.race()` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten los siguientes métodos prototipos de ES 6 en promesas: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Se admiten los siguientes métodos prototipo de ES 6: + `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()` **nota** Todos los métodos prototipo de DataView ES 6 son nuevos en el tiempo de ejecución 2.0 de JavaScript. **Símbolo** Se admiten los siguientes métodos matemáticos de ES 6: + `Symbol.for()` + `Symbol.keyfor()` **nota** Todos los métodos de ES 6 de símbolos son nuevos en el tiempo de ejecución 2.0 de JavaScript. **Descodificador de texto** Se admiten los siguientes métodos prototipo: + `TextDecoder.prototype.decode()` Se admiten las siguientes propiedades de acceso prototipo: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **Codificador de texto** Se admiten los siguientes métodos prototipo: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` ## Tipos de error Se admiten los siguientes objetos de error: + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globals Se admite el objeto `globalThis`. Se admiten las siguientes características globales de ES 5.1: + `decodeURI()` + `decodeURIComponent()` + `encodeURI()` + `encodeURIComponent()` + `isFinite()` + `isNaN()` + `parseFloat()` + `parseInt()` Se admiten las siguientes características globales de ES 6: + `atob()` + `btoa()` **nota** `atob()` y `btoa()` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten las siguientes constantes globales: + `NaN` + `Infinity` + `undefined` + `arguments` ## Módulos integrados Se admiten los siguientes módulos integrados: **Topics** + [ ### Búfer ](#writing-functions-javascript-features-builtin-modules-buffer-20) + [ ### Cadena de consulta ](#writing-functions-javascript-features-builtin-modules-query-string-20) + [ ### Cripto ](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Búfer El módulo proporciona los siguientes métodos: + `Buffer.alloc(size[, fill[, encoding]])` Asignación de un `Buffer`. + `size`: tamaño del búfer. Introduzca un número entero. + `fill`: opcional. Introduzca una cadena, `Buffer`, Uint8Array o entero. El valor predeterminado es `0`. + `encoding`: opcional. Si `fill` es una cadena, introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.allocUnsafe(size)` Asigne un valor no inicializado `Buffer`. + `size`: introduzca un número entero. + `Buffer.byteLength(value[, encoding])` Devuelve la longitud de un valor, en bytes. + `value`: una cadena, `Buffer`, TypedArray, Dataview o Arraybuffer. + `encoding`: opcional. Si `value` es una cadena, introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.compare(buffer1, buffer2)` Compare dos `Buffer` para ayudar a ordenar las matrices. Devuelve `0` si son iguales, `-1` si `buffer1` aparece primero o `1` si `buffer2` aparece primero. + `buffer1`: introduzca un `Buffer`. + `buffer2`: introduzca un `Buffer` diferente. + `Buffer.concat(list[, totalLength])` Concatenar varios `Buffer`. Devuelve `0` si no hay ninguno. Devuelve hasta `totalLength`. + `list`: introduzca una lista de `Buffer`. Tenga en cuenta que esto se truncará a `totalLength`. + `totalLength`: opcional. Introduzca un número entero sin signo. Utilice la suma de las instancias de `Buffer` de la lista si está en blanco. + `Buffer.from(array)` Cree un `Buffer` a partir de una matriz. + `array`: introduzca una matriz de bytes de `0` a `255`. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Cree una vista desde `arrayBuffer`, empezando por el desfase `byteOffset` con la longitud `length`. + `arrayBuffer`: introduzca una matriz de `Buffer`. + `byteOffset`: introduzca un número entero. + `length`: opcional. Introduzca un número entero. + `Buffer.from(buffer)` Cree una copia del `Buffer`. + `buffer`: introduzca un `Buffer`. + `Buffer.from(object[, offsetOrEncoding[, length]])` Cree un `Buffer` a partir de un objeto. Devuelve `Buffer.from(object.valueOf(), offsetOrEncoding, length)` si `valueOf()` no es igual al objeto. + `object`: introduzca un objeto. + `offsetOrEncoding`: opcional. Introduzca un número entero o una cadena de codificación. + `length`: opcional. Introduzca un número entero. + `Buffer.from(string[, encoding])` Cree un `Buffer` a partir de una cadena. + `string`: introduzca una cadena. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.isBuffer(object)` Compruebe si `object` es un búfer. Devuelve `true` o `false`. + `object`: introduzca un objeto. + `Buffer.isEncoding(encoding)` Compruebe si `encoding` es compatible. Devuelve `true` o `false`. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. El módulo proporciona los siguientes métodos de prototipo de búfer. + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Compare `Buffer` con el objetivo. Devuelve `0` si son iguales, `1` si `buffer` aparece primero o `-1` si `target` aparece primero. + `target`: introduzca un `Buffer`. + `targetStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `targetEnd`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del `target`. + `sourceStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `sourceEnd`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del `Buffer`. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Copie el búfer a `target`. + `target`: introduzca un `Buffer` o una `Uint8Array`. + `targetStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `sourceStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `sourceEnd`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del `Buffer`. + `Buffer.prototype.equals(otherBuffer)` Compare `Buffer` con `otherBuffer`. Devuelve `true` o `false`. + `otherBuffer`: introduzca una cadena. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Rellene `Buffer` con `value`. + `value`: introduzca una cadena, un `Buffer` o un número entero. + `offset`: opcional. Introduzca un número entero. + `end`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Busque `value` en `Buffer`. Devuelve `true` o `false`. + `value`: introduzca una cadena, `Buffer`, `Uint8Array` o un número entero. + `byteOffset`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Busque el primer `value` en el `Buffer`. Devuelve `index` si se encuentra; devuelve `-1` si no se encuentra. + `value`: introduzca una cadena, `Buffer`, Unit8Array o un número entero comprendido entre 0 y 255. + `byteOffset`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones si `value` es una cadena: `utf8`, `hex`, `base64`, `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Busque el último `value` en el `Buffer`. Devuelve `index` si se encuentra; devuelve `-1` si no se encuentra. + `value`: introduzca una cadena, `Buffer`, Unit8Array o un número entero comprendido entre 0 y 255. + `byteOffset`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones si `value` es una cadena: `utf8`, `hex`, `base64`, `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.readInt8(offset)` Lea `Int8` en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readIntBE(offset, byteLength)` Lea el `Int` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: opcional. Introduzca un número entero comprendido entre `1` y `6`. + `Buffer.prototype.readInt16BE(offset)` Lea el `Int16` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readInt32BE(offset)` Lea el `Int32` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readIntLE(offset, byteLength)` Lea el `Int` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.readInt16LE(offset)` Lea el `Int16` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readInt32LE(offset)` Lea el `Int32` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUInt8(offset)` Lea `UInt8` en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUIntBE(offset, byteLength)` Lea el `UInt` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.readUInt16BE(offset)` Lea el `UInt16` como big-endian en `offset` desde `Buffer`. + + `offset`: introduzca un número entero. + `Buffer.prototype.readUInt32BE(offset)` Lea el `UInt32` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUIntLE(offset, byteLength)` Lea el `UInt` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.readUInt16LE(offset)` Lea el `UInt16` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUInt32LE(offset)` Lea el `UInt32` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readDoubleBE([offset])` Lea un doble de 64 bits como big-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.readDoubleLE([offset])` Lea un doble de 64 bits como little-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.readFloatBE([offset])` Lea un flotante de 32 bits como big-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.readFloatLE([offset])` Lea un flotante de 32 bits como little-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.subarray([start[, end]])` Devuelve una copia de `Buffer` desplazada y recortada con un nuevo `start` y `end`. + `start`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `end`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del búfer. + `Buffer.prototype.swap16()` Cambie el orden de los bytes de la matriz del `Buffer`, tratándolo como una matriz de números de 16 bits. La longitud de `Buffer` debe ser divisible entre 2 o recibirá un error. + `Buffer.prototype.swap32()` Cambie el orden de los bytes de la matriz del `Buffer`, tratándolo como una matriz de números de 32 bits. La longitud de `Buffer` debe ser divisible entre 4 o recibirá un error. + `Buffer.prototype.swap64()` Cambie el orden de los bytes de la matriz del `Buffer`, tratándolo como una matriz de números de 64 bits. La longitud de `Buffer` debe ser divisible entre 8 o recibirá un error. + `Buffer.prototype.toJSON()` Devuelve `Buffer` como JSON. + `Buffer.prototype.toString([encoding[, start[, end]]])` Convierte `Buffer`, de `start` a `end`, en una cadena codificada. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `start`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `end`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del búfer. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Escribe codificada la `string` en el `Buffer` si hay espacio, o una `string` truncada si no hay suficiente espacio. + `string`: introduzca una cadena. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `length`: opcional. Introduzca un número entero. El valor predeterminado es la longitud de la cadena. + `encoding`: opcional. Si lo desea, introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Escriba el `Int8` `value` de la `byteLength` en `offset` en `Buffer`. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeIntLE(offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Escriba el `UInt8` `value` de la `byteLength` en `offset` en `Buffer`. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeDoubleBE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. Se admiten los siguientes métodos de instancia: + `buffer[index]` Obtenga y establezca el octeto (byte) en `index` en `Buffer`. + Obtenga un número de `0` a `255`. O establezca un número de `0` a `255`. Se admiten las siguientes propiedades de instancia: + `buffer` Obtenga el objeto `ArrayBuffer` para el búfer. + `byteOffset` Obtenga el `byteOffset` del objeto `Arraybuffer` del búfer. + `length` Obtenga el recuento de bytes del búfer. **nota** Todos los métodos del módulo del búfer son nuevos en el tiempo de ejecución 2.0 de JavaScript. ### Cadena de consulta **nota** El objeto [ de evento de CloudFront Functions ](functions-event-structure.md) analiza automáticamente las cadenas de consulta de URL. Eso significa que en la mayoría de los casos no necesita usar este módulo. El módulo de cadena de consulta (`querystring`) proporciona métodos para analizar y dar formato a las cadenas de consulta de URL. Puede cargar el módulo mediante `require('querystring')`. El módulo proporciona los siguientes métodos. `querystring.escape(string)` La URL codifica la `string` dada y devuelve una cadena de consulta escapada. El método es utilizado por `querystring.stringify()` y no debe utilizarse directamente. `querystring.parse(string[, separator[, equal[, options]]])` Analiza una cadena de consulta (`string`) y devuelve un objeto. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `decodeURIComponent function` Una función para decodificar caracteres codificados por porcentaje en la cadena de consulta. De forma predeterminada, es `querystring.unescape()`. `maxKeys number` El número máximo de claves que se analizan. De forma predeterminada, es `1000`. Utilice un valor de `0` para eliminar las limitaciones del recuento de claves. De forma predeterminada, se supone que los caracteres codificados con porcentaje dentro de la cadena de consulta utilizan la codificación UTF-8. Las secuencias UTF-8 no válidas se reemplazan por el carácter de reemplazo `U+FFFD`. Por ejemplo, para la siguiente cadena de consulta: ``` 'name=value&abc=xyz&abc=123' ``` El valor de retorno de `querystring.parse()` es: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` es un alias de `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializa un `object` y devuelve una cadena de consulta. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `encodeURIComponent function` La función que se va a utilizar para convertir caracteres no seguros de URL a codificación porcentual en la cadena de consulta. De forma predeterminada, es `querystring.escape()`. De forma predeterminada, los caracteres que requieren codificación porcentual dentro de la cadena de consulta se codifican como UTF-8. Para utilizar una codificación diferente, especifique la opción `encodeURIComponent`. Por ejemplo, el siguiente código: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` El valor de retorno es: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` es un alias de `querystring.stringify()`. `querystring.unescape(string)` Decodifica caracteres codificados con porcentaje de URL en la `string` dada y devuelve una cadena de consulta sin escapar. Este método es utilizado por `querystring.parse()` y no debe utilizarse directamente. ### Cripto El módulo criptográfico (`crypto`) proporciona ayudantes de código de autenticación de mensajes basado en hash (HMAC) y hashing estándar. Puede cargar el módulo mediante `require('crypto')`. **Métodos de hashing** `crypto.createHash(algorithm)` Crea y devuelve un objeto hash que puede utilizar para generar resúmenes hash mediante el algoritmo dado: `md5`, `sha1` o `sha256`. `hash.update(data)` Actualiza el contenido hash con los dado `data`. `hash.digest([encoding])` Calcula el resumen de todos los datos pasados con `hash.update()`. La codificación puede ser `hex`, `base64` o `base64url`. **Métodos HMAC** `crypto.createHmac(algorithm, secret key)` Crea y devuelve un objeto HMAC que utiliza el `algorithm` y `secret key` dados. El algoritmo puede ser `md5`, `sha1` o `sha256`. `hmac.update(data)` Actualiza el contenido de HMAC con los dado `data`. `hmac.digest([encoding])` Calcula el resumen de todos los datos pasados con `hmac.update()`. La codificación puede ser `hex`, `base64` o `base64url`. ## Características restringidas Las siguientes características de lenguaje JavaScript no se admiten o están restringidas debido a cuestiones de seguridad. **Evaluación dinámica de código** No se admite la evaluación dinámica de código. Si se intenta, los constructores `eval()` y `Function` arrojan un error. Por ejemplo, `const sum = new Function('a', 'b', 'return a + b')` arroja un error. **Temporizadores** No se admiten las funciones `setTimeout()`, `setImmediate()` y `clearTimeout()`. No hay nada para posponer o producir dentro de una ejecución de función. La función debe ejecutarse de manera sincrónica hasta finalizar. **Fecha y marcas temporales** Por razones de seguridad, no hay acceso a temporizadores de alta resolución. Todos los métodos `Date` para consultar la hora actual siempre devuelven el mismo valor durante la vida útil de una sola función ejecutada. La marca temporal devuelta es la hora en que la función comenzó a ejecutarse. Por eso, no puede medir el tiempo transcurrido en la función. **Acceso al sistema de archivos** No hay acceso al sistema de archivos. Por ejemplo, no hay ningún módulo `fs` para el acceso al sistema de archivos como lo hay en Node.js. **Acceso al proceso** No hay acceso al proceso. Por ejemplo, no hay ningún objeto global `process` para procesar el acceso a la información como lo hay en Node.js. **Variables de entorno** No hay acceso a las variables de entorno. En su lugar, puede utilizar CloudFront KeyValueStore para crear un almacén de datos centralizado de pares clave-valor para las CloudFront Functions. CloudFront KeyValueStore habilita las actualizaciones dinámicas de los datos de configuración sin necesidad de implementar cambios en el código. Para obtener más información, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Acceso a la red** No se admiten las llamadas de red. Por ejemplo, no se admite XHR, HTTP (S) ni socket.