# Recursos de tempo de execução JavaScript para funções do CloudFront O ambiente de runtime do JavaScript do CloudFront Functions é compatível com o [ECMAScript (ES) versão 5.1](https://www.ecma-international.org/ecma-262/5.1/) e também é compatível com alguns recursos das versões 6 a 12 do ES. Para ter os recursos mais atualizados, recomendamos usar o JavaScript runtime 2.0. Os recursos do JavaScript runtime 2.0 têm as seguintes alterações em comparação com o 1.0: + Os métodos do módulo de buffer estão disponíveis. + Os seguintes métodos de protótipo de string não padrão não estão disponíveis: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + O módulo criptográfico tem as seguintes alterações: + `hash.digest()`: o tipo de retorno será alterado para `Buffer` se nenhuma codificação for fornecida. + `hmac.digest()`: o tipo de retorno será alterado para `Buffer` se nenhuma codificação for fornecida. + Para ter mais informações sobre novos recursos adicionais, consulte [Recursos de runtime 2.0 do JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [Recursos de runtime 1.0 do JavaScript](functions-javascript-runtime-10.md) + [Recursos de runtime 2.0 do JavaScript](functions-javascript-runtime-20.md) # 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. # Recursos de runtime 2.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 6 a 12 do ES. 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 compatíveis nesse runtime. **Topics** + [ ## Recursos principais ](#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 erro ](#writing-functions-javascript-features-error-types-20) + [ ## Variáveis globais ](#writing-functions-javascript-features-globals-20) + [ ## Módulos integrados ](#writing-functions-javascript-features-builtin-modules-20) + [ ## Recursos restritos ](#writing-functions-javascript-features-restricted-features-20) ## 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 boolianos, números, strings, objetos, matrizes, 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 seguintes instruções ES 5.1 são compatíveis: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` As seguintes instruções do ES 6 são compatíveis: + `const` + `let` As seguintes instruções do ES 8 são compatíveis: + `async` + `await` `async`, `await`, `const` e `let` são compatíveis com o runtime 2.0 do JavaScript. `await` pode ser usado apenas dentro de funções `async`. Encerramentos e argumentos `async` não são compatíveis. **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: + `Object.create()` (sem lista de propriedades) + `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()` Os seguintes métodos ES 6 em objetos são compatíveis: + `Object.assign()` Os seguintes métodos ES 8 em objetos são compatíveis: + `Object.entries()` + `Object.values()` Os seguintes métodos de protótipo do ES 5.1 em objetos são compatíveis: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Os seguintes métodos de protótipo do ES 6 em objetos são compatíveis: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **String** Os seguintes métodos ES 5.1 em cadeias de caracteres são compatíveis: + `String.fromCharCode()` Os seguintes métodos ES 6 em cadeias de caracteres são compatíveis: + `String.fromCodePoint()` Os seguintes métodos de protótipo do ES 5.1 em strings são compatíveis: + `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()` Os seguintes métodos de protótipo do ES 6 em strings são compatíveis: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Os seguintes métodos de protótipo do ES 8 em strings são compatíveis: + `String.prototype.padStart()` + `String.prototype.padEnd()` Os seguintes métodos de protótipo do ES 9 em strings são compatíveis: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Os seguintes métodos de protótipo do ES 12 em strings são compatíveis: + `String.prototype.replaceAll()` **nota** `String.prototype.replaceAll()` é um recurso novo no runtime 2.0 do JavaScript. **Número** Todos os números do ES 5 são compatíveis. As seguintes propriedades do ES 6 em números são compatíveis: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Os seguintes métodos ES 6 em números são compatíveis: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Os seguintes métodos de protótipo do ES 5.1 em números são compatíveis: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Separadores numéricos ES 12 são compatíveis. Os separadores numéricos ES 12 são novos no runtime 2.0 do JavaScript. ## 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. As seguintes propriedades matemáticas do ES 6 são compatíveis: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Os seguintes métodos matemáticos ES 6 são compatíveis: + `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()` **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](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Função** Os seguintes métodos de protótipo do ES 5.1 são compatíveis: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` 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. As seguintes propriedades do acessador de protótipos do ES 5.1 são compatíveis: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **nota** `RegExp.prototype.sticky` e `RegExp.prototype.flags` são recursos novos no runtime 2.0 do JavaScript. Os seguintes métodos de protótipo do ES 5.1 são compatíveis: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **nota** `RegExp.prototype[@@split]()` é um recurso novo no runtime 2.0 do JavaScript. As seguintes propriedades de instância do ES 5.1 são compatíveis: + `lastIndex` Os grupos de captura nomeados ES 9 são compatíveis. **JSON** Os seguintes métodos do ES 5.1 são compatíveis: + `JSON.parse()` + `JSON.stringify()` **Array** Os seguintes métodos ES 5.1 em matrizes são compatíveis: + `Array.isArray()` Os seguintes métodos ES 6 em matrizes são compatíveis: + `Array.of()` Os seguintes métodos de protótipo do ES 5.1 são compatíveis: + `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()` Os seguintes métodos de protótipo do ES 6 são compatíveis + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Os seguintes métodos de protótipo do ES 7 são compatíveis: + `Array.prototype.includes()` **Matrizes digitadas** Os seguintes construtores de matriz de tipo do ES 6 são compatíveis: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Os seguintes métodos do ES 6 são compatíveis: + `TypedArray.from()` + `TypedArray.of()` **nota** `TypedArray.from()` e `TypedArray.of()` são recursos novos no runtime 2.0 do JavaScript. Os seguintes métodos de protótipo do ES 6 são compatíveis + `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()` e `TypedArray.prototype.some()` são recursos novos no runtime 2.0 do JavaScript. **ArrayBuffer** Os seguintes métodos do ES 6 em ArrayBuffer são compatíveis: + `isView()` Os seguintes métodos de protótipo do ES 6 em ArrayBuffer são compatíveis: + `ArrayBuffer.prototype.slice()` **Promessa** Os seguintes métodos do ES 6 em promises são compatíveis: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **nota** `Promise.all()`, `Promise.allSettled()`, `Promise.any()` e `Promise.race()` são recursos novos no runtime 2.0 do JavaScript. Os seguintes métodos de protótipo do ES 6 em promises são compatíveis: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Os seguintes métodos de protótipo do ES 6 são compatíveis: + `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 os métodos de protótipo do Dataview ES 6 são novos no runtime 2.0 do JavaScript. **Símbolo** Os seguintes métodos do ES 6 são compatíveis: + `Symbol.for()` + `Symbol.keyfor()` **nota** Todos os métodos do Symbol ES 6 são novos no runtime 2.0 do JavaScript. **Decodificador de texto** Os seguintes métodos de protótipo são compatíveis: + `TextDecoder.prototype.decode()` As seguintes propriedades do acessador de protótipos são compatíveis: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **Codificador de texto** Os seguintes métodos de protótipo são compatíveis: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` ## Tipos de erro Os seguintes objetos de erro são compatíveis: + `Error` + `EvalError` + `InternalError` + `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 funções globais do ES 6 são compatíveis: + `atob()` + `btoa()` **nota** `atob()` e `btoa()` são recursos novos no runtime 2.0 do JavaScript. As seguintes restrições globais são válidas: + `NaN` + `Infinity` + `undefined` + `arguments` ## Módulos integrados Os seguintes módulos integrados são compatíveis: **Topics** + [ ### Buffer ](#writing-functions-javascript-features-builtin-modules-buffer-20) + [ ### String de consulta ](#writing-functions-javascript-features-builtin-modules-query-string-20) + [ ### Criptografia ](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Buffer O módulo oferece os seguintes métodos: + `Buffer.alloc(size[, fill[, encoding]])` Aloque um `Buffer`. + `size`: tamanho do buffer. Insira um número inteiro. + `fill`: opcional. Insira uma string, `Buffer`, Uint8Array ou um número inteiro. O padrão é `0`. + `encoding`: opcional. Quando `fill` for uma string, insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.allocUnsafe(size)` Aloque um `Buffer` não inicializado. + `size`: insira um número inteiro. + `Buffer.byteLength(value[, encoding])` Exibe o tamanho de um valor, em bytes. + `value`: uma string, `Buffer`, TypedArray, Dataview ou Arraybuffer. + `encoding`: opcional. Quando `value` for uma string, insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.compare(buffer1, buffer2)` Compare dois `Buffer`s para ajudar a classificar matrizes. Exibirá `0` se forem iguais, `-1` se `buffer1` vier primeiro ou `1` se `buffer2` vier primeiro. + `buffer1`: insira um `Buffer`. + `buffer2`: insira um `Buffer` diferente. + `Buffer.concat(list[, totalLength])` Concatene vários `Buffer`s. Exibirá `0` se for nenhum. Exibe até `totalLength`. + `list`: insira uma lista de `Buffer`s. Observe que isso será truncado para `totalLength`. + `totalLength`: opcional. Insira um número inteiro não assinado. Use a soma das instâncias de `Buffer` na lista se estiver em branco. + `Buffer.from(array)` Crie um `Buffer` por uma matriz. + `array`: insira uma matriz de bytes de `0` a `255`. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Crie uma visualização de `arrayBuffer` começando pelo deslocamento `byteOffset` com o tamanho `length`. + `arrayBuffer`: insira uma matriz `Buffer`. + `byteOffset`: insira um número inteiro. + `length`: opcional. Insira um número inteiro. + `Buffer.from(buffer)` Crie uma cópia do `Buffer`. + `buffer`: insira um `Buffer`. + `Buffer.from(object[, offsetOrEncoding[, length]])` Crie um `Buffer` por meio de um objeto. Exibirá `Buffer.from(object.valueOf(), offsetOrEncoding, length)` se `valueOf()` não for igual ao objeto. + `object`: insira um objeto. + `offsetOrEncoding`: opcional. Insira um número inteiro ou uma string de codificação. + `length`: opcional. Insira um número inteiro. + `Buffer.from(string[, encoding])` Crie um `Buffer` por meio de uma string. + `string`: insira uma string. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.isBuffer(object)` Confira se `object` é um buffer. Retorna `true` ou `false`. + `object`: insira um objeto. + `Buffer.isEncoding(encoding)` Confira se `encoding` é compatível. Retorna `true` ou `false`. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. O módulo oferece os seguintes métodos de protótipo de buffer: + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Compare `Buffer` com o destino. Exibirá `0` se forem iguais, `1` se `buffer` vier primeiro ou `-1` se `target` vier primeiro. + `target`: insira um `Buffer`. + `targetStart`: opcional. Insira um número inteiro. O padrão é 0. + `targetEnd`: opcional. Insira um número inteiro. O padrão é o tamanho do `target`. + `sourceStart`: opcional. Insira um número inteiro. O padrão é 0. + `sourceEnd`: opcional. Insira um número inteiro. O padrão é o tamanho do `Buffer`. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Copie o buffer em `target`. + `target`: insira um `Buffer` ou uma `Uint8Array`. + `targetStart`: opcional. Insira um número inteiro. O padrão é 0. + `sourceStart`: opcional. Insira um número inteiro. O padrão é 0. + `sourceEnd`: opcional. Insira um número inteiro. O padrão é o tamanho do `Buffer`. + `Buffer.prototype.equals(otherBuffer)` Compare `Buffer` com `otherBuffer`. Retorna `true` ou `false`. + `otherBuffer`: insira uma string. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Preencha `Buffer` com `value`. + `value`: insira uma string, um `Buffer` ou um número inteiro. + `offset`: opcional. Insira um número inteiro. + `end`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Pesquise `value` no `Buffer`. Retorna `true` ou `false`. + `value`: insira uma string, um `Buffer`, uma `Uint8Array` ou um número inteiro. + `byteOffset`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Procure o primeiro `value` em `Buffer`. Exibirá `index` se for encontrado; exibirá `-1` se não for encontrado. + `value`: insira uma string, `Buffer`, Unit8Array ou um número inteiro de 0 a 255. + `byteOffset`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções se `value` for uma string: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Procure o último `value` em `Buffer`. Exibirá `index` se for encontrado; exibirá `-1` se não for encontrado. + `value`: insira uma string, `Buffer`, Unit8Array ou um número inteiro de 0 a 255. + `byteOffset`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções se `value` for uma string: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.readInt8(offset)` Leia `Int8` em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readIntBE(offset, byteLength)` Leia `Int` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: opcional. Insira um número inteiro de `1` a `6`. + `Buffer.prototype.readInt16BE(offset)` Leia `Int16` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readInt32BE(offset)` Leia `Int32` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readIntLE(offset, byteLength)` Leia `Int` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.readInt16LE(offset)` Leia `Int16` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readInt32LE(offset)` Leia `Int32` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUInt8(offset)` Leia `UInt8` em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUIntBE(offset, byteLength)` Leia `UInt` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.readUInt16BE(offset)` Leia `UInt16` como big-endian em `offset` de `Buffer`. + + `offset`: insira um número inteiro. + `Buffer.prototype.readUInt32BE(offset)` Leia `UInt32` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUIntLE(offset, byteLength)` Leia `UInt` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.readUInt16LE(offset)` Leia `UInt16` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUInt32LE(offset)` Leia `UInt32` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readDoubleBE([offset])` Leia um double de 64 bits como big-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.readDoubleLE([offset])` Leia um double de 64 bits como little-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.readFloatBE([offset])` Leia um float de 32 bits como big-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.readFloatLE([offset])` Leia um float de 32 bits como little-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.subarray([start[, end]])` Exibe uma cópia do `Buffer` que está deslocado e recortado com novos `start` e `end`. + `start`: opcional. Insira um número inteiro. O padrão é 0. + `end`: opcional. Insira um número inteiro. O padrão é o tamanho do buffer. + `Buffer.prototype.swap16()` Troque a ordem de bytes da matriz de `Buffer` tratando-a como uma matriz de números de 16 bits. O tamanho do `Buffer` deve ser divisível por 2, ou você receberá um erro. + `Buffer.prototype.swap32()` Troque a ordem de bytes da matriz de `Buffer` tratando-a como uma matriz de números de 32 bits. O tamanho do `Buffer` deve ser divisível por 4, ou você receberá um erro. + `Buffer.prototype.swap64()` Troque a ordem de bytes da matriz de `Buffer` tratando-a como uma matriz de números de 64 bits. O tamanho do `Buffer` deve ser divisível por 8, ou você receberá um erro. + `Buffer.prototype.toJSON()` Exibe `Buffer` como JSON. + `Buffer.prototype.toString([encoding[, start[, end]]])` Converta `Buffer`, de `start` em `end` em string codificada. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` ou `base64url`. O padrão é `utf8`. + `start`: opcional. Insira um número inteiro. O padrão é 0. + `end`: opcional. Insira um número inteiro. O padrão é o tamanho do buffer. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Escreva `string` codificado em `Buffer` se houver espaço ou um `string` truncado se não houver espaço suficiente. + `string`: insira uma string. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `length`: opcional. Insira um número inteiro. O padrão é o tamanho da string. + `encoding`: opcional. Opcionalmente, insira uma das seguintes opções: `utf8`, `hex`, `base64` ou `base64url`. O padrão é `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Escreva `Int8` `value` de `byteLength` em `offset` para `Buffer`. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeIntLE(offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Escreva `UInt8` `value` de `byteLength` em `offset` para `Buffer`. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeDoubleBE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. Os seguintes métodos de instância são compatíveis: + `buffer[index]` Obtenha e defina o octeto (byte) em `index` em `Buffer`. + Obtenha um número de `0` a `255`. Ou defina um número de `0` a `255`. As seguintes propriedades de instância são compatíveis: + `buffer` Obtenha o objeto `ArrayBuffer` para o buffer. + `byteOffset` Obtenha o `byteOffset` do objeto `Arraybuffer` do buffer. + `length` Obtenha a contagem de bytes do buffer. **nota** Todos os métodos do módulo de buffer são novos no runtime 2.0 do JavaScript. ### 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. ### Criptografia 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')`. **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`. ## 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. 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.