Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # JavaScript Funzionalità di runtime 1.0 per CloudFront Functions L'ambiente JavaScript di runtime di CloudFront Functions è conforme alla [versione 5.1 ECMAScript (ES)](https://262.ecma-international.org/5.1/) e supporta anche alcune funzionalità delle versioni ES da 6 a 9. Fornisce anche alcuni metodi non standard che non fanno parte delle specifiche ES. Negli argomenti seguenti sono elencate tutte le funzionalità linguistiche supportate. **Topics** + [Caratteristiche principali](#writing-functions-javascript-features-core) + [Oggetti primitivi](#writing-functions-javascript-features-primitive-objects) + [Oggetti incorporati](#writing-functions-javascript-features-builtin-objects) + [Tipi di errore](#writing-functions-javascript-features-error-types) + [Elementi globali](#writing-functions-javascript-features-globals) + [Moduli incorporati](#writing-functions-javascript-features-builtin-modules) + [Funzionalità con restrizioni](#writing-functions-javascript-features-restricted-features) ## Caratteristiche principali Sono supportate le seguenti caratteristiche principali di ES. **Tipi** Sono supportati tutti i tipi ES 5.1. Tra questi vi sono valori booleani, numeri, stringhe, oggetti, matrici, funzioni, costruttori di funzioni ed espressioni regolari. **Operatori** Sono supportati tutti gli operatori ES 5.1. È supportato l'operatore esponenziale ES 7 (`**`). **Dichiarazioni** Le istruzioni `const` e `let` non sono supportate. Sono supportate le seguenti istruzioni ES 5.1: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Istruzioni etichettate **Valori letterali** Sono supportati i valori letterali modello ES 6: stringhe multilinea, interpolazione di espressioni e modelli di nidificazione. **Funzioni** Sono supportate tutte le funzioni ES 5.1. Sono supportate le funzioni freccia ES 6 ed è supportata la sintassi del parametro rest ES 6. **Unicode** Il testo di origine e i valori letterali stringa possono contenere caratteri codificati in Unicode. Sono supportate anche sequenze di escape dei punti di codice Unicode di sei caratteri (ad esempio, `\uXXXX`). **Modalità rigorosa** Le funzioni funzionano in modalità rigorosa per impostazione predefinita, quindi non è necessario aggiungere una istruzione `use strict` nel codice funzione. Non possono essere modificate. ## Oggetti primitivi Sono supportati i seguenti oggetti primitivi di ES. **Oggetto** Sono supportati i seguenti metodi ES 5.1 sugli oggetti: + `create` (senza elenco delle proprietà) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Sono supportati i seguenti metodi ES 6 sugli oggetti: + `assign` + `is` + `prototype.setPrototypeOf` Sono supportati i seguenti metodi ES 8 sugli oggetti: + `entries` + `values` **Stringa** Sono supportati i seguenti metodi ES 5.1 sulle stringhe: + `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` Sono supportati i seguenti metodi ES 6 sulle stringhe: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Sono supportati i seguenti metodi ES 8 sulle stringhe: + `prototype.padStart` + `prototype.padEnd` Sono supportati i seguenti metodi ES 9 sulle stringhe: + `prototype.trimStart` + `prototype.trimEnd` Sono supportati i seguenti metodi non standard sulle stringhe: + `prototype.bytesFrom(array | string, encoding)` Crea una stringa di byte da un array di ottetti o da una stringa codificata. Le opzioni di codifica delle stringhe sono `hex`, `base64` e `base64url`. + `prototype.fromBytes(start[, end])` Crea una stringa Unicode da una stringa di byte in cui ogni byte viene sostituito con il corrispondente punto di codice Unicode. + `prototype.fromUTF8(start[, end])` Crea una stringa Unicode da una stringa di byte codificata UTF-8. Se la codifica non è corretta, viene restituito `null`. + `prototype.toBytes(start[, end])` Crea una stringa di byte da una stringa Unicode. Tutti i caratteri devono essere compresi nell'intervallo [0,255]. In caso contrario, restituisce `null`. + `prototype.toUTF8(start[, end])` Crea una stringa di byte codificata UTF-8 da una stringa Unicode. **Numero** Sono supportati tutti i metodi ES 5.1 sui numeri. Sono supportati i seguenti metodi ES 6 sui numeri: + `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` ## Oggetti incorporati Sono supportati i seguenti oggetti incorporati di ES. **Math** Sono supportati tutti i metodi matematici ES 5.1. Nell'ambiente di runtime di CloudFront Functions, l'`Math.random()`implementazione utilizza `arc4random` OpenBSD con il timestamp di quando la funzione viene eseguita. Sono supportati i seguenti metodi matematici 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` **Data** Sono supportate tutte le funzioni `Date` ES 5.1. Per motivi di sicurezza, restituisce `Date` sempre lo stesso valore, ovvero l'ora di inizio della funzione, durante la durata di una singola esecuzione di una funzione. Per ulteriori informazioni, consulta [Funzionalità con restrizioni](#writing-functions-javascript-features-restricted-features). **Funzione** Sono supportati i metodi `apply`, `bind` e `call`. I costruttori di funzioni non sono supportati. **Espressioni regolari** Sono supportate tutte le funzioni di espressione regolare ES 5.1. Il linguaggio delle espressioni regolari è compatibile con Perl. Sono supportati i gruppi di acquisizione denominati di ES 9. **JSON** Sono supportate tutte le funzionalità JSON di ES 5.1, incluso `parse` e `stringify`. **Array** Sono supportati i seguenti metodi ES 5.1 sugli array: + `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` Sono supportati i seguenti metodi ES 6 sugli array: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Sono supportati i seguenti metodi ES 7 sugli array: + `prototype.includes` **Array tipizzati** Sono supportati i seguenti array tipizzati 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** Sono supportati i seguenti metodi su `ArrayBuffer`: + `prototype.isView` + `prototype.slice` **Promessa** Sono supportati i seguenti metodi sulle promesse: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Crittografia** Il modulo di crittografia fornisce helper standard hash e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`. Il modulo espone i seguenti metodi che si comportano esattamente come le loro controparti Node.js: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Per ulteriori informazioni, consulta [Crittografia (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) nella sezione dei moduli incorporati. **Console** Questo è un oggetto helper per il debug. Supporta solo il metodo `log()` per registrare i messaggi di log. CloudFront Le funzioni non supportano la sintassi delle virgole, ad esempio. `console.log('a', 'b')` Utilizzare invece il formato `console.log('a' + ' ' + 'b')`. ## Tipi di errore Sono supportati i seguenti oggetti di errore: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Elementi globali L'oggetto `globalThis` è supportato. Sono supportate le seguenti funzioni globali ES 5.1: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Sono supportate le seguenti costanti globali: + `NaN` + `Infinity` + `undefined` ## Moduli incorporati Sono supportati i seguenti moduli incorporati: **Topics** + [Crittografia (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) + [Stringa di query](#writing-functions-javascript-features-builtin-modules-query-string) ### Crittografia (hash e HMAC) Il modulo di crittografia (`crypto`) fornisce helper di hashing standard e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`. Il modulo fornisce i seguenti metodi che si comportano esattamente come le controparti Node.js. **Metodi di hashing** `crypto.createHash(algorithm)` Crea e restituisce un oggetto hash che è possibile utilizzare per generare digest hash utilizzando il dato algoritmo: `md5`, `sha1`, o `sha256`. `hash.update(data)` Aggiorna il contenuto hash con il dato `data`. `hash.digest([encoding])` Calcola il digest di tutti i dati passati tramite `hash.update()`. La codifica può essere `hex`, `base64` o `base64url`. **Metodi HMAC** `crypto.createHmac(algorithm, secret key)` Crea e restituisce un oggetto HMAC che utilizza il dato `algorithm` e `secret key`. L'algoritmo può essere `md5`, `sha1` o `sha256`. `hmac.update(data)` Aggiorna il contenuto HMAC con il dato `data`. `hmac.digest([encoding])` Calcola il digest di tutti i dati passati tramite `hmac.update()`. La codifica può essere `hex`, `base64` o `base64url`. ### Stringa di query **Nota** L'[oggetto evento CloudFront Functions](functions-event-structure.md) analizza automaticamente le stringhe di query URL per voi. Ciò significa che nella maggior parte dei casi non è necessario utilizzare questo modulo. Il modulo stringa di query (`querystring`) fornisce metodi per l'analisi e la formattazione delle stringhe di query URL. È possibile caricare il modulo usando `require('querystring')`. Il modulo fornisce i metodi seguenti: `querystring.escape(string)` URL che codifica il dato `string`, restituendo una stringa di query con escape. Il metodo viene utilizzato da `querystring.stringify()` e non deve essere utilizzato direttamente. `querystring.parse(string[, separator[, equal[, options]]])` Analizza una stringa di query (`string`) e restituisce un oggetto. Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`. Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`. Il parametro `options` è un oggetto con le seguenti chiavi: `decodeURIComponent function` Un funzione per decodificare i caratteri codificati in percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.unescape()`. `maxKeys number` Il numero massimo di chiavi da analizzare. Per impostazione predefinita, tale valore è `1000`. Utilizza un valore `0` per rimuovere le limitazioni per il conteggio delle chiavi. Per impostazione predefinita, si presuppone che i caratteri con codifica in percentuale all'interno della stringa di query utilizzino la codifica UTF-8. Le sequenze UTF-8 non valide vengono sostituite con il carattere sostitutivo `U+FFFD`. Ad esempio, per la seguente stringa di query: ``` 'name=value&abc=xyz&abc=123' ``` Il valore restituito di `querystring.parse()` è: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` è un alias per `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializza un `object` e restituisce una stringa di query. Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`. Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`. Il parametro `options` è un oggetto con le seguenti chiavi: `encodeURIComponent function` La funzione da utilizzare per convertire caratteri non sicuri dell’URL in codifica percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.escape()`. Per impostazione predefinita, i caratteri che richiedono la codifica percentuale all'interno della stringa di query sono codificati come UTF-8. Per utilizzare una codifica diversa, specifica l'opzione `encodeURIComponent`. Ad esempio, per il seguente codice: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Il valore restituito è: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` è un alias per `querystring.stringify()`. `querystring.unescape(string)` Decodifica i caratteri codificati in percentuale URL nel dato `string`, restituendo una stringa di query senza escape. Questo metodo viene utilizzato da `querystring.parse()` e non deve essere utilizzato direttamente. ## Funzionalità con restrizioni Le seguenti funzionalità JavaScript linguistiche non sono supportate o sono limitate a causa di problemi di sicurezza. **Valutazione dinamica del codice** La valutazione dinamica del codice non è supportata. Entrambi i costruttori `eval()` e `Function` generano un errore se tentato. Ad esempio, `const sum = new Function('a', 'b', 'return a + b')` genera un errore. **Timer** Le funzioni `setTimeout()`, `setImmediate()` e `clearTimeout()` non sono supportate. Non vi è alcuna disposizione per differire o cedere all'interno di un'esecuzione di funzione. La funzione deve essere eseguita in modo sincrono fino al completamento. **Data e timestamp** Per motivi di sicurezza, non è possibile accedere ai timer ad alta risoluzione. Tutti i metodi `Date` per interrogare l'ora corrente restituiscono sempre lo stesso valore durante la durata di una singola esecuzione di funzione. Il timestamp restituito è il momento in cui la funzione ha iniziato l'esecuzione. Di conseguenza, non è possibile misurare il tempo trascorso nella vostra funzione. **Accesso al file system** Nessun accesso al file system. Ad esempio, non esiste un modulo `fs` per l'accesso al file system come invece è presente in Node.js. **Accesso al processo** Non è possibile accedere al processo. Ad esempio, non esiste un oggetto globale `process` per l’elaborazione dell’accesso alle informazioni come in Node.js. **Variabili di ambiente** Non è possibile accedere alle variabili d’ambiente. Puoi invece utilizzarlo CloudFront KeyValueStore per creare un datastore centralizzato di coppie chiave-valore per le tue Funzioni. CloudFront CloudFront KeyValueStore consente aggiornamenti dinamici ai dati di configurazione senza dover implementare modifiche al codice. È necessario utilizzare [JavaScript runtime 2.0](functions-javascript-runtime-20.md) per utilizzare. CloudFront KeyValueStore Per ulteriori informazioni, consulta [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Accesso alla rete** Non è disponibile alcun supporto per le chiamate di rete. Ad esempio, XHR, HTTP(S) e socket non sono supportati.