# Recursos de runtime 1.0 do JavaScript para CloudFront Functions O ambiente de runtime do JavaScript do CloudFront Functions é compatível com o [ECMAScript (ES) versão 5.1](https://262.ecma-international.org/5.1/) e também é compatível com alguns recursos das versões ES 6 a 9. Ele também fornece alguns métodos não padronizados que não fazem parte das especificações ES. Os tópicos a seguir listam todos os recursos de idioma compatíveis. **Topics** + [Recursos principais](#writing-functions-javascript-features-core) + [Objetos primitivos](#writing-functions-javascript-features-primitive-objects) + [Objetos integrados](#writing-functions-javascript-features-builtin-objects) + [Tipos de erro](#writing-functions-javascript-features-error-types) + [Variáveis globais](#writing-functions-javascript-features-globals) + [Módulos integrados](#writing-functions-javascript-features-builtin-modules) + [Recursos restritos](#writing-functions-javascript-features-restricted-features) ## Recursos principais Os seguintes recursos principais do ES são compatíveis. **Tipos** Todos os tipos ES 5.1 são compatíveis. Isso inclui valores booleanos, números, cadeias de caracteres, objetos, matrizes, funções, construtores de funções e expressões regulares. **Operadores** Todos os operadores ES 5.1 são compatíveis. O operador de exponenciação ES 7 (`**`) é compatível. **Declarações** As instruções `const` e `let` não são compatíveis. As seguintes instruções ES 5.1 são compatíveis: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Instruções rotuladas **Literais** Os literais de modelo ES 6 são compatíveis: cadeias de várias linhas, interpolação de expressão e modelos de aninhamento. **Funções** Todos os recursos de função ES 5.1 são compatíveis. As funções de seta ES 6 são compatíveis, assim como a sintaxe de parâmetro de descanso ES 6. **Unicode** Texto de origem e literais de cadeias de caracteres podem conter caracteres codificados em Unicode. Sequências de escape de ponto de código Unicode de seis caracteres (por exemplo, `\uXXXX`) também são compatíveis. **Modo estrito** As funções operam no modo estrito por padrão, então você não precisa adicionar uma instrução `use strict` ao seu código de função. Elas não podem ser alteradas. ## Objetos primitivos Os seguintes objetos primitivos de ES são compatíveis. **Objeto** Os seguintes métodos ES 5.1 em objetos são compatíveis: + `create` (sem lista de propriedades) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Os seguintes métodos ES 6 em objetos são compatíveis: + `assign` + `is` + `prototype.setPrototypeOf` Os seguintes métodos ES 8 em objetos são compatíveis: + `entries` + `values` **String** Os seguintes métodos ES 5.1 em cadeias de caracteres são compatíveis: + `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` Os seguintes métodos ES 6 em cadeias de caracteres são compatíveis: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Os seguintes métodos ES 8 em cadeias de caracteres são compatíveis: + `prototype.padStart` + `prototype.padEnd` Os seguintes métodos ES 9 em cadeias de caracteres são compatíveis: + `prototype.trimStart` + `prototype.trimEnd` Os seguintes métodos não padronizados em cadeias de caracteres são compatíveis: + `prototype.bytesFrom(array | string, encoding)` Cria uma cadeia de caracteres de bytes de uma matriz de octetos ou uma cadeia de caracteres codificada. As opções de codificação de cadeia de caracteres são `hex`, `base64` e `base64url`. + `prototype.fromBytes(start[, end])` Cria uma cadeia de caracteres Unicode de uma cadeia de caracteres de bytes em que cada byte é substituído pelo ponto de código Unicode correspondente. + `prototype.fromUTF8(start[, end])` Cria uma cadeia de caracteres Unicode de uma cadeia de caracteres de bytes codificada UTF-8. Se a codificação estiver incorreta, ela retorna `null`. + `prototype.toBytes(start[, end])` Cria uma cadeia de caracteres de bytes de uma cadeia de caracteres Unicode. Todos os caracteres devem estar no intervalo de [0.255]. Se não, ele retorna `null`. + `prototype.toUTF8(start[, end])` Cria uma cadeia de caracteres de bytes codificada UTF-8 de uma cadeia de caracteres Unicode. **telefone** Todos os métodos ES 5.1 em números são compatíveis. Os seguintes métodos ES 6 em números são compatíveis: + `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 Os seguintes objetos integrados do ES são compatíveis. **Matemática** Todos os métodos matemáticos ES 5.1 são compatíveis. No ambiente de tempo de execução do CloudFront Functions, a implementação `Math.random()` usa o OpenBSD `arc4random` propagado com o carimbo de data/hora de quando a função é executada. Os seguintes métodos matemáticos ES 6 são compatíveis: + `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` **Data** Todos os recursos `Date` do ES 5.1 são compatíveis. Por razões de segurança, `Date` sempre retorna o mesmo valor, que seria o horário de início da função, durante o tempo de vida de uma única execução de função. Para obter mais informações, consulte [Recursos restritos](#writing-functions-javascript-features-restricted-features). **Função** Os métodos `apply`, `bind` e `call` são compatíveis. Os construtores de função não são compatíveis. **Expressões regulares** Todos os recursos de expressão regular ES 5.1 são compatíveis. A linguagem de expressão regular é compatível com Perl. Os grupos de captura nomeados ES 9 são compatíveis. **JSON** Todos os recursos JSON ES 5.1 são compatíveis, incluindo `parse` e `stringify`. **Array** Os seguintes métodos ES 5.1 em matrizes são compatíveis: + `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` Os seguintes métodos ES 6 em matrizes são compatíveis: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Os seguintes métodos ES 7 em matrizes são compatíveis: + `prototype.includes` **Matrizes digitadas** As seguintes matrizes ES 6 digitadas são compatíveis: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Os seguintes métodos em `ArrayBuffer` são compatíveis: + `prototype.isView` + `prototype.slice` **Promessa** Os seguintes métodos em promises são compatíveis: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Criptografia** O módulo criptográfico fornece auxiliares de código de autenticação de mensagens (HMAC) padrão e hash. Você pode carregar o módulo usando `require('crypto')`. O módulo expõe os seguintes métodos que se comportam exatamente como suas contrapartes Node.js: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Para mais informações, consulte [Criptográficos (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) na seção de módulos integrados. **Console** Este é um objeto auxiliar para depuração. Ele só é compatível com o método `log()` para gravar mensagens de log. O CloudFront Functions não é compatível com sintaxe de vírgula, como `console.log('a', 'b')`. Em vez disso, use o formato `console.log('a' + ' ' + 'b')`. ## Tipos de erro Os seguintes objetos de erro são compatíveis: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Variáveis globais O objeto `globalThis` é compatível. As seguintes funções globais do ES 5.1 são compatíveis: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` As seguintes restrições globais são válidas: + `NaN` + `Infinity` + `undefined` ## Módulos integrados Os seguintes módulos integrados são compatíveis: **Topics** + [Criptográficos (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) + [String de consulta](#writing-functions-javascript-features-builtin-modules-query-string) ### Criptográficos (hash e HMAC) O módulo criptográfico (`crypto`) fornece auxiliares de código de autenticação de mensagens (HMAC) padrão e hash. Você pode carregar o módulo usando `require('crypto')`. O módulo fornece os seguintes métodos que se comportam exatamente como suas contrapartes Node.js. **Métodos de hash** `crypto.createHash(algorithm)` Cria e retorna um objeto hash que você pode usar para gerar resumos de hash usando o algoritmo fornecido: `md5`, `sha1` ou `sha256`. `hash.update(data)` Atualiza o conteúdo de hash com os fornecido `data`. `hash.digest([encoding])` Calcula o resumo de todos os dados passados usando `hash.update()`. A codificação pode ser `hex`, `base64` ou `base64url`. **Métodos de HMAC** `crypto.createHmac(algorithm, secret key)` Cria e retorna um objeto HMAC que usa o `algorithm` e a `secret key` fornecidos. O algoritmo pode ser `md5`, `sha1` ou `sha256`. `hmac.update(data)` Atualiza o conteúdo HMAC com os fornecido `data`. `hmac.digest([encoding])` Calcula o resumo de todos os dados passados usando `hmac.update()`. A codificação pode ser `hex`, `base64` ou `base64url`. ### String de consulta **nota** O [objeto de evento CloudFront Functions](functions-event-structure.md) analisa automaticamente as cadeias de consulta de URL para você. Isso significa que na maioria dos casos você não precisa usar este módulo. O módulo cadeia de consulta (`querystring`) fornece métodos para analisar e formatar cadeias de consulta de URL. Você pode carregar o módulo usando `require('querystring')`. O módulo fornece os seguintes métodos: `querystring.escape(string)` O URL codifica a `string` fornecida, retornando uma cadeia de consulta escapada. O método é usado por `querystring.stringify()` e não deve ser usado diretamente. `querystring.parse(string[, separator[, equal[, options]]])` Analisa uma cadeia de consulta (`string`) e retorna um objeto. O parâmetro `separator` é uma substring para delimitar pares de chaves e valores na cadeia de consulta. O padrão é `&`. O parâmetro `equal` é uma substring para delimitar chaves e valores na cadeia de consulta. O padrão é `=`. O parâmetro `options` é um objeto com as seguintes chaves: `decodeURIComponent function` Uma função para decodificar caracteres codificados por percentual na cadeia de consulta. O padrão é `querystring.unescape()`. `maxKeys number` O número máximo de chaves a serem analisadas. O padrão é `1000`. Use um valor de `0` para remover as limitações para as chaves de contagem. Por padrão, os caracteres codificados por percentual dentro da cadeia de consulta são assumidos para usar a codificação UTF-8. Sequências UTF-8 inválidas são substituídas pelo caractere de substituição `U+FFFD`. Por exemplo, para a seguinte cadeia de consulta: ``` 'name=value&abc=xyz&abc=123' ``` O valor de retorno de `querystring.parse()` é: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` é um alias para `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializa um `object` e retorna uma cadeia de consulta. O parâmetro `separator` é uma substring para delimitar pares de chaves e valores na cadeia de consulta. O padrão é `&`. O parâmetro `equal` é uma substring para delimitar chaves e valores na cadeia de consulta. O padrão é `=`. O parâmetro `options` é um objeto com as seguintes chaves: `encodeURIComponent function` A função a ser usada para converter caracteres URL-inseguros para codificação percentual na cadeia de consulta. O padrão é `querystring.escape()`. Por padrão, os caracteres que exigem percentual de codificação dentro da cadeia de consulta são codificados como UTF-8. Para usar uma codificação diferente, especifique a opção `encodeURIComponent`. Por exemplo, para o seguinte código: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` O valor de retorno é: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` é um alias para `querystring.stringify()`. `querystring.unescape(string)` Decodifica caracteres codificados por porcentagem de URL na `string` fornecida, retornando uma cadeia de consulta sem escapamento. Esse método é usado por `querystring.parse()` e não deve ser usado diretamente. ## Recursos restritos Os seguintes recursos de linguagem JavaScript não são compatíveis ou são restritos devido a preocupações de segurança. **Avaliação dinâmica do código** A avaliação dinâmica do código não é compatível. Ambos os construtores `eval()` e `Function` lançam um erro se forem tentados. Por exemplo, `const sum = new Function('a', 'b', 'return a + b')` lança um erro. **Temporizadores ** As funções `setTimeout()`, `setImmediate()` e `clearTimeout()` não são compatíveis. Não há provisão para adiar ou renderizar dentro de uma execução de função. Sua função deve ser executada de forma síncrona até a conclusão. **Data e carimbos de data/hora** Por razões de segurança, não há acesso a temporizadores de alta resolução. Todos os métodos `Date` para consultar a hora atual sempre retornam o mesmo valor durante o tempo de vida de uma única execução de função. O carimbo de data/hora retornado é o momento em que a função começou a ser executada. Consequentemente, você não pode medir o tempo decorrido em sua função. **Acesso ao sistema de arquivos** Não há acesso ao sistema de arquivos. Por exemplo, não há módulo `fs` para acesso ao sistema de arquivos como no Node.js. **Acesso a processos** Não há acesso a processos. Por exemplo, não há um objeto global `process` para processar o acesso às informações como no Node.js. **Variáveis de ambiente** Não há acesso às variáveis de ambiente. Em vez disso, é possível usar o KeyValueStore do CloudFront para criar um datastore centralizado de pares de chave-valor para o CloudFront Functions. O KeyValueStore do CloudFront permite atualizações dinâmicas nos dados de configuração sem a necessidade de implantar alterações no código. É necessário usar o [JavaScript runtime 2.0](functions-javascript-runtime-20.md) para usar o KeyValueStore do CloudFront. Para obter mais informações, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Acesso à rede** Não há suporte para chamadas de rede. Por exemplo, XHR, HTTP (S) e socket não são compatíveis.