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