

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

# Funzionalità di runtime supportate
<a name="supported-features"></a>

Le sezioni seguenti descrivono il set di funzionalità supportate del runtime APPSYNC\$1JS.

## Caratteristiche principali
<a name="core-features"></a>

Sono supportate le seguenti funzionalità principali.

------
#### [ Types ]

Sono supportati i seguenti tipi:
+ numeri
+ stringhe
+ booleani
+ objects
+ matrici
+ funzioni

------
#### [ Operators ]

Gli operatori sono supportati, tra cui:
+ operatori matematici standard (`+``-`,`/`,`%`,`*`, ecc.)
+ operatore di coalescenza nullo () `??`
+ Concatenamento opzionale () `?.`
+ operatori bit per bit
+ `void`e operatori `typeof`
+ operatori di diffusione (`...`)

I seguenti operatori non sono supportati:
+ operatori unari (`++`,`--`, e`~`)
+ Operatore `in`
**Nota**  
Utilizzate l'`Object.hasOwn`operatore per verificare se la proprietà specificata si trova nell'oggetto specificato.

------
#### [ Statements ]

Sono supportate le seguenti istruzioni:
+ `const`
+ `let`
+ `var`
+ `break`
+ `else`
+ `for-in`
+ `for-of` 
+ `if`
+ `return`
+ `switch`
+ sintassi diffusa

Le seguenti non sono supportate:
+ `catch`
+ `continue`
+ `do-while`
+ `finally`
+ `for(initialization; condition; afterthought)`
**Nota**  
Le eccezioni sono `for-in` e `for-of` le espressioni, che sono supportate.
+ `throw`
+ `try`
+ `while`
+ dichiarazioni etichettate

------
#### [ Literals ]

Sono supportati i seguenti [valori letterali del modello](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) ES 6:
+ Stringhe multilinea
+ Interpolazione delle espressioni
+ Modelli di nidificazione

------
#### [ Functions ]

È supportata la seguente sintassi della funzione:
+ Le dichiarazioni di funzione sono supportate.
+ Le funzioni a freccia ES 6 sono supportate.
+ È supportata la sintassi dei parametri rest di ES 6.

------
#### [ Strict mode ]

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
<a name="primitive-objects"></a>

Sono supportati i seguenti oggetti primitivi di ES e le relative funzioni.

------
#### [ Object ]

Sono supportati i seguenti oggetti:
+ `Object.assign()`
+ `Object.entries()` 
+ `Object.hasOwn()`
+ `Object.keys()` 
+ `Object.values()`
+ `delete` 

------
#### [ String ]

Sono supportate le seguenti stringhe:
+  `String.prototype.length()` 
+  `String.prototype.charAt()` 
+  `String.prototype.concat()` 
+  `String.prototype.endsWith()` 
+  `String.prototype.indexOf()` 
+  `String.prototype.lastIndexOf()` 
+  `String.raw()` 
+  `String.prototype.replace()`
**Nota**  
Le espressioni regolari non sono supportate.   
Tuttavia, i costrutti di espressioni regolari in stile Java sono supportati nel parametro fornito. [Per ulteriori informazioni, vedete Pattern.](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
+ `String.prototype.replaceAll()`
**Nota**  
Le espressioni regolari non sono supportate.  
Tuttavia, i costrutti di espressioni regolari in stile Java sono supportati nel parametro fornito. [Per ulteriori informazioni, vedete Pattern.](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
+  `String.prototype.slice()` 
+  `String.prototype.split()` 
+  `String.prototype.startsWith()` 
+  `String.prototype.toLowerCase()` 
+  `String.prototype.toUpperCase()` 
+  `String.prototype.trim()` 
+  `String.prototype.trimEnd()` 
+  `String.prototype.trimStart()` 

------
#### [ Number ]

Sono supportati i seguenti numeri:
+  `Number.isFinite` 
+  `Number.isNaN` 

------

## Oggetti e funzioni incorporati
<a name="built-in-objects-functions"></a>

Sono supportate le funzioni e gli oggetti seguenti.

------
#### [ Math ]

Sono supportate le seguenti funzioni matematiche:
+  `Math.random()` 
+  `Math.min()` 
+  `Math.max()` 
+  `Math.round()` 
+  `Math.floor()` 
+  `Math.ceil()` 

------
#### [ Array ]

Sono supportati i seguenti metodi di matrice:
+ `Array.prototype.length` 
+ `Array.prototype.concat()` 
+ `Array.prototype.fill()` 
+ `Array.prototype.flat()` 
+ `Array.prototype.indexOf()` 
+ `Array.prototype.join()` 
+ `Array.prototype.lastIndexOf()` 
+ `Array.prototype.pop()` 
+ `Array.prototype.push()` 
+ `Array.prototype.reverse()` 
+ `Array.prototype.shift()` 
+ `Array.prototype.slice()` 
+ `Array.prototype.sort()`
**Nota**  
`Array.prototype.sort()`non supporta argomenti.
+ `Array.prototype.splice()` 
+ `Array.prototype.unshift()`
+ `Array.prototype.forEach()`
+ `Array.prototype.map()`
+ `Array.prototype.flatMap()`
+ `Array.prototype.filter()`
+ `Array.prototype.reduce()`
+ `Array.prototype.reduceRight()`
+ `Array.prototype.find()`
+ `Array.prototype.some()`
+ `Array.prototype.every()`
+ `Array.prototype.findIndex()`
+ `Array.prototype.findLast()`
+ `Array.prototype.findLastIndex()`
+ `delete` 

------
#### [ Console ]

L'oggetto console è disponibile per il debug. Durante l'esecuzione delle query in tempo reale, log/error le istruzioni della console vengono inviate ad Amazon CloudWatch Logs (se la registrazione è abilitata). Durante la valutazione del codice con`evaluateCode`, le istruzioni di log vengono restituite nella risposta al comando.
+ `console.error()`
+ `console.log()`

------
#### [ Function ]
+ I `call` metodi `apply``bind`, e non sono supportati.
+ I costruttori di funzioni non sono supportati.
+ Il passaggio di una funzione come argomento non è supportato.
+ Le chiamate di funzioni ricorsive non sono supportate.

------
#### [ JSON ]

Sono supportati i seguenti metodi JSON:
+ `JSON.parse()`
**Nota**  
Restituisce una stringa vuota se la stringa analizzata non è un formato JSON valido.
+ `JSON.stringify()`

------
#### [ Promises ]

I processi asincroni non sono supportati e le promesse non sono supportate.

**Nota**  
L'accesso alla rete e al file system non è supportato nel `APPSYNC_JS` runtime di. AWS AppSync AWS AppSync gestisce tutte le operazioni di I/O in base alle richieste effettuate dal AWS AppSync resolver o dalla funzione. AWS AppSync 

------

## Elementi globali
<a name="globals"></a>

Sono supportate le seguenti costanti globali:
+  `NaN` 
+  `Infinity` 
+  `undefined`
+ [https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html)
+ [https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)
+ `runtime`

## Tipi di errore
<a name="error-types"></a>

Il lancio di errori con non `throw` è supportato. È possibile restituire un errore utilizzando `util.error()` la funzione. È possibile includere un errore nella risposta GraphQL utilizzando la `util.appendError` funzione.

Per ulteriori informazioni, consulta [Error utils](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js).