> For the complete documentation index, see [llms.txt](https://swift.unicorndonkeys.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://swift.unicorndonkeys.com/riferimento-del-linguaggio/struttura-lessicale.md). # Struttura lessicale (Lexical Structure) Usa i componenti di livello più basso della sintassi. La *struttura lessicale* di Swift descrive quali sequenze di caratteri formano token validi del linguaggio. Questi token validi costituiscono i mattoni di livello più basso del linguaggio e vengono usati per descrivere il resto del linguaggio nei capitoli successivi. Un token è costituito da un identificatore, una parola chiave, un segno di punteggiatura, un letterale o un operatore. Nella maggior parte dei casi, i token vengono generati dai caratteri di un file sorgente Swift considerando la sottostringa più lunga possibile del testo in input, entro i vincoli della grammatica specificati di seguito. Questo comportamento è chiamato *longest match* (corrispondenza più lunga) o *maximal munch*. ## Spazi bianchi e commenti Gli spazi bianchi hanno due usi: separare i token nel file sorgente e distinguere tra operatori prefissi, postfissi e infissi (vedi [Operatori](/riferimento-del-linguaggio/struttura-lessicale.md#operatori)), ma per il resto vengono ignorati. I caratteri seguenti sono considerati spazi bianchi: spazio (U+0020), avanzamento di riga (U+000A), ritorno a capo (U+000D), tabulazione orizzontale (U+0009), tabulazione verticale (U+000B), avanzamento di pagina (U+000C) e null (U+0000). I commenti vengono trattati dal compilatore come spazi bianchi. I commenti su una sola riga iniziano con `//` e proseguono fino a un avanzamento di riga (U+000A) o a un ritorno a capo (U+000D). I commenti su più righe iniziano con `/*` e terminano con `*/`. L'annidamento dei commenti su più righe è consentito, ma i marcatori dei commenti devono essere bilanciati. I commenti possono contenere formattazione e markup aggiuntivi, come descritto in [Markup Formatting Reference](https://developer.apple.com/library/content/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html). {% hint style="info" %} **Grammatica degli spazi bianchi:** *whitespace* → *whitespace-item* *whitespace?*\ *whitespace-item* → *line-break*\ *whitespace-item* → *inline-space*\ *whitespace-item* → *comment*\ *whitespace-item* → *multiline-comment*\ *whitespace-item* → U+0000, U+000B, or U+000C *line-break* → U+000A\ *line-break* → U+000D\ *line-break* → U+000D followed by U+000A *inline-spaces* → *inline-space* *inline-spaces?*\ *inline-space* → U+0009 or U+0020 *comment* → **`//`** *comment-text* *line-break*\ *multiline-comment* → **`/*`** *multiline-comment-text* **`*/`** *comment-text* → *comment-text-item* *comment-text?*\ *comment-text-item* → Any Unicode scalar value except U+000A or U+000D *multiline-comment-text* → *multiline-comment-text-item* *multiline-comment-text?*\ *multiline-comment-text-item* → *multiline-comment*\ *multiline-comment-text-item* → *comment-text-item*\ *multiline-comment-text-item* → Any Unicode scalar value except **`/*`** or **`*/`** {% endhint %} ## Identificatori Gli *identificatori* iniziano con una lettera maiuscola o minuscola dalla A alla Z, un trattino basso (`_`), un carattere Unicode alfanumerico non combinante nel Basic Multilingual Plane, oppure un carattere al di fuori del Basic Multilingual Plane che non si trovi in una Private Use Area. Dopo il primo carattere, sono consentiti anche cifre e caratteri Unicode combinanti. Tratta come internal gli identificatori che iniziano con un trattino basso, i subscript la cui prima etichetta dell'argomento inizia con un trattino basso, e gli inizializzatori la cui prima etichetta dell'argomento inizia con un trattino basso, anche se la loro dichiarazione ha il modificatore del livello di accesso `public`. Questa convenzione permette agli autori di framework di contrassegnare parte di un'API con cui i client non devono interagire né da cui devono dipendere, anche se qualche limitazione richiede che la dichiarazione sia public. Inoltre, gli identificatori che iniziano con due trattini bassi sono riservati al compilatore Swift e alla libreria standard. Per usare una parola riservata come identificatore o per includere caratteri speciali come gli spazi bianchi, metti un backtick (\`) prima e dopo di esso. Per esempio, `class`, `100` e `model & test` non sono identificatori validi, ma `` `class` ``, `` `100` `` e `` `model & test` `` sono validi. I backtick non sono considerati parte dell'identificatore; `` `x` `` e `x` hanno lo stesso significato. Un identificatore grezzo (raw identifier) può contenere qualsiasi valore scalare Unicode tranne i seguenti: * Backtick (`` ` ``) * Barra rovesciata (`\`) * Null (U+0000) * Tabulazione orizzontale (U+0009) * Avanzamento di riga (U+000A) * Tabulazione verticale (U+000B) * Ritorno a capo (U+000D) * Riga successiva (U+0085) * Spazio unificatore (U+00A0) * Segno di spazio ogham (U+1680) * En quad (U+2000) * Em quad (U+2001) * Spazio en (U+2002) * Spazio em (U+2003) * Spazio da un terzo di em (U+2004) * Spazio da un quarto di em (U+2005) * Spazio da un sesto di em (U+2006) * Spazio per cifre (U+2007) * Spazio di punteggiatura (U+2008) * Spazio sottile (U+2009) * Spazio capillare (U+200A) * Separatore di riga (U+2028) * Separatore di paragrafo (U+2029) * Spazio unificatore stretto (U+202F) * Spazio matematico medio (U+205F) * Spazio ideografico (U+3000) Gli identificatori grezzi possono contenere spazi bianchi, ma non possono essere costituiti solo da spazi bianchi. In un identificatore grezzo, un segno da sinistra a destra (U+200E) o un segno da destra a sinistra (U+200F) è consentito ed è considerato spazio bianco. Gli identificatori grezzi possono contenere caratteri operatore, come descritto in [Operatori](/riferimento-del-linguaggio/struttura-lessicale.md#operatori), ma non possono essere costituiti solo da caratteri operatore. {% hint style="info" %} **Nota:** Prima di Swift 6.2, scrivere dei backtick prima e dopo un identificatore era noto come *identificatore con escape* (escaped identifier), ed era limitato all'uso di una parola chiave come identificatore. {% endhint %} All'interno di una closure senza nomi di parametri espliciti, i parametri sono implicitamente chiamati `$0`, `$1`, `$2` e così via. Questi nomi sono identificatori validi nell'ambito della closure. Il compilatore sintetizza identificatori che iniziano con il simbolo del dollaro (`$`) per le proprietà che hanno una proiezione di property wrapper. Il tuo codice può interagire con questi identificatori, ma non puoi dichiarare identificatori con quel prefisso. Per maggiori informazioni, vedi la sezione [propertyWrapper](/riferimento-del-linguaggio/attributi.md#propertywrapper) del capitolo [Attributi](/riferimento-del-linguaggio/attributi.md). {% hint style="info" %} **Grammatica di un identificatore:** *identifier* → *identifier-head* *identifier-characters?*\ *identifier* → *raw-identifier*\ *identifier* → *implicit-parameter-name*\ *identifier* → *property-wrapper-projection*\ *identifier-list* → *identifier* | *identifier* **`,`** *identifier-list* *identifier-head* → Upper- or lowercase letter A through Z\ *identifier-head* → **`_`**\ *identifier-head* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA\ *identifier-head* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF\ *identifier-head* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF\ *identifier-head* → U+1E00–U+1FFF\ *identifier-head* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F\ *identifier-head* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793\ *identifier-head* → U+2C00–U+2DFF or U+2E80–U+2FFF\ *identifier-head* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF\ *identifier-head* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44\ *identifier-head* → U+FE47–U+FFFD\ *identifier-head* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD\ *identifier-head* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD\ *identifier-head* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD\ *identifier-head* → U+D0000–U+DFFFD or U+E0000–U+EFFFD *identifier-character* → *decimal-digit*\ *identifier-character* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F\ *identifier-character* → *identifier-head*\ *identifier-characters* → *identifier-character* *identifier-characters?* *implicit-parameter-name* → **`$`** *decimal-digits*\ *property-wrapper-projection* → **`$`** *identifier-characters* *raw-identifier* → **`` ` ``** *raw-identifier-characters* **`` ` ``**\ *raw-identifier-character* → Any Unicode scalar value except **`` ` ``**, **`\`**, U+0000, U+000A, or U+000D *raw-identifier-characters* → *raw-identifier-character* *raw-identifier-characters?* {% endhint %} ## Parole chiave e punteggiatura Le parole chiave seguenti sono riservate e non possono essere usate come identificatori, a meno che non siano racchiuse tra backtick, come descritto sopra in [Identificatori](/riferimento-del-linguaggio/struttura-lessicale.md#identificatori). Le parole chiave diverse da `inout`, `var` e `let` possono essere usate come nomi di parametri nella dichiarazione o nella chiamata di una funzione senza essere racchiuse tra backtick. Quando un membro ha lo stesso nome di una parola chiave, i riferimenti a quel membro non hanno bisogno di essere racchiusi tra backtick, tranne quando c'è ambiguità tra il riferimento al membro e l'uso della parola chiave — per esempio, `self`, `Type` e `Protocol` hanno un significato speciale in un'espressione di membro esplicita, quindi devono essere racchiuse tra backtick in quel contesto. * Parole chiave usate nelle dichiarazioni: `associatedtype`, `borrowing`, `class`, `consuming`, `deinit`, `enum`, `extension`, `fileprivate`, `func`, `import`, `init`, `inout`, `internal`, `let`, `nonisolated`, `open`, `operator`, `precedencegroup`, `private`, `protocol`, `public`, `rethrows`, `static`, `struct`, `subscript`, `typealias` e `var`. * Parole chiave usate nelle istruzioni: `break`, `case`, `catch`, `continue`, `default`, `defer`, `do`, `else`, `fallthrough`, `for`, `guard`, `if`, `in`, `repeat`, `return`, `switch`, `throw`, `where` e `while`. * Parole chiave usate nelle espressioni e nei tipi: `Any`, `as`, `await`, `catch`, `false`, `is`, `nil`, `rethrows`, `self`, `Self`, `super`, `throw`, `throws`, `true` e `try`. * Parole chiave usate nei pattern: `_`. * Parole chiave che iniziano con un cancelletto (`#`): `#available`, `#colorLiteral`, `#else`, `#elseif`, `#endif`, `#fileLiteral`, `#if`, `#imageLiteral`, `#keyPath`, `#selector`, `#sourceLocation`, `#unavailable`. {% hint style="info" %} **Nota:** Prima di Swift 5.9, le parole chiave seguenti erano riservate: `#column`, `#dsohandle`, `#error`, `#fileID`, `#filePath`, `#file`, `#function`, `#line` e `#warning`. Ora sono implementate come macro nella libreria standard di Swift: [`column`](https://developer.apple.com/documentation/swift/column\(\)), [`dsohandle`](https://developer.apple.com/documentation/swift/dsohandle\(\)), [`error(_:)`](https://developer.apple.com/documentation/swift/error\(_:\)), [`fileID`](https://developer.apple.com/documentation/swift/fileID\(\)), [`filePath`](https://developer.apple.com/documentation/swift/filePath\(\)), [`file`](https://developer.apple.com/documentation/swift/file\(\)), [`function`](https://developer.apple.com/documentation/swift/function\(\)), [`line`](https://developer.apple.com/documentation/swift/line\(\)) e [`warning(_:)`](https://developer.apple.com/documentation/swift/warning\(_:\)). {% endhint %} * Parole chiave riservate in contesti particolari: `associativity`, `async`, `convenience`, `didSet`, `dynamic`, `final`, `get`, `indirect`, `infix`, `lazy`, `left`, `mutating`, `none`, `nonmutating`, `optional`, `override`, `package`, `postfix`, `precedence`, `prefix`, `Protocol`, `required`, `right`, `set`, `some`, `Type`, `unowned`, `weak` e `willSet`. Al di fuori del contesto in cui compaiono nella grammatica, possono essere usate come identificatori. I token seguenti sono riservati come punteggiatura e non possono essere usati come operatori personalizzati: `(`, `)`, `{`, `}`, `[`, `]`, `.`, `,`, `:`, `;`, `=`, `@`, `#`, `&` (come operatore prefisso), `->`, `` ` ``, `?` e `!` (come operatore postfisso). ## Letterali Un *letterale* è la rappresentazione nel codice sorgente di un valore di un tipo, come un numero o una stringa. Ecco alcuni esempi di letterali: ```swift 42 // Letterale intero 3.14159 // Letterale in virgola mobile "Hello, world!" // Letterale stringa /Hello, .*/ // Letterale espressione regolare true // Letterale booleano ``` Un letterale non ha un tipo di per sé. Invece, un letterale viene analizzato come avente precisione infinita e l'inferenza di tipo di Swift tenta di inferire un tipo per il letterale. Per esempio, nella dichiarazione `let x: Int8 = 42`, Swift usa l'annotazione di tipo esplicita (`: Int8`) per inferire che il tipo del letterale intero `42` è `Int8`. Se non sono disponibili informazioni di tipo adeguate, Swift inferisce che il tipo del letterale è uno dei tipi letterali predefiniti definiti nella libreria standard di Swift ed elencati nella tabella seguente. Quando specifichi l'annotazione di tipo per un valore letterale, il tipo dell'annotazione deve essere un tipo che può essere istanziato a partire da quel valore letterale. Cioè, il tipo deve essere conforme ai protocolli della libreria standard di Swift elencati nella tabella seguente. | Letterale | Tipo predefinito | Protocollo | | -------------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Intero | `Int` | `ExpressibleByIntegerLiteral` | | In virgola mobile | `Double` | `ExpressibleByFloatLiteral` | | Stringa | `String` | `ExpressibleByStringLiteral`, `ExpressibleByUnicodeScalarLiteral` per i letterali stringa che contengono un solo scalare Unicode, `ExpressibleByExtendedGraphemeClusterLiteral` per i letterali stringa che contengono un solo cluster di grafemi esteso | | Espressione regolare | `Regex` | Nessuno | | Booleano | `Bool` | `ExpressibleByBooleanLiteral` | Per esempio, nella dichiarazione `let str = "Hello, world"`, il tipo predefinito inferito per il letterale stringa `"Hello, world"` è `String`. Inoltre, `Int8` è conforme al protocollo `ExpressibleByIntegerLiteral`, e quindi può essere usato nell'annotazione di tipo per il letterale intero `42` nella dichiarazione `let x: Int8 = 42`. {% hint style="info" %} **Grammatica di un letterale:** *literal* → *numeric-literal* | *string-literal* | *regular-expression-literal* | *boolean-literal* | *nil-literal* *numeric-literal* → *signed-integer-literal* | *signed-floating-point-literal*\ *boolean-literal* → **`true`** | **`false`**\ *nil-literal* → **`nil`** {% endhint %} ### Letterali interi I *letterali interi* rappresentano valori interi di precisione non specificata. Per impostazione predefinita, i letterali interi sono espressi in decimale; puoi specificare una base alternativa usando un prefisso. I letterali binari iniziano con `0b`, i letterali ottali iniziano con `0o`, e i letterali esadecimali iniziano con `0x`. I letterali decimali contengono le cifre da `0` a `9`. I letterali binari contengono `0` e `1`, i letterali ottali contengono le cifre da `0` a `7`, e i letterali esadecimali contengono le cifre da `0` a `9` e le lettere da `A` a `F`, maiuscole o minuscole. I letterali interi negativi si esprimono anteponendo un segno meno (`-`) a un letterale intero, come in `-42`. I trattini bassi (`_`) sono consentiti tra le cifre per la leggibilità, ma vengono ignorati e quindi non influiscono sul valore del letterale. I letterali interi possono iniziare con zeri iniziali (`0`), ma anche questi vengono ignorati e non influiscono sulla base né sul valore del letterale. Salvo diversa indicazione, il tipo predefinito inferito per un letterale intero è il tipo `Int` della libreria standard di Swift. La libreria standard di Swift definisce anche tipi per varie dimensioni di interi con e senza segno, come descritto in [Interi](/guida-al-linguaggio/le-basi.md#interi). {% hint style="info" %} **Grammatica di un letterale intero:** *signed-integer-literal* → **`-`***?* *integer-literal* *integer-literal* → *binary-literal*\ *integer-literal* → *octal-literal*\ *integer-literal* → *decimal-literal*\ *integer-literal* → *hexadecimal-literal* *binary-literal* → **`0b`** *binary-digit* *binary-literal-characters?*\ *binary-digit* → Digit 0 or 1\ *binary-literal-character* → *binary-digit* | **`_`**\ *binary-literal-characters* → *binary-literal-character* *binary-literal-characters?* *octal-literal* → **`0o`** *octal-digit* *octal-literal-characters?*\ *octal-digit* → Digit 0 through 7\ *octal-literal-character* → *octal-digit* | **`_`**\ *octal-literal-characters* → *octal-literal-character* *octal-literal-characters?* *decimal-literal* → *decimal-digit* *decimal-literal-characters?*\ *decimal-digit* → Digit 0 through 9\ *decimal-digits* → *decimal-digit* *decimal-digits?*\ *decimal-literal-character* → *decimal-digit* | **`_`**\ *decimal-literal-characters* → *decimal-literal-character* *decimal-literal-characters?* *hexadecimal-literal* → **`0x`** *hexadecimal-digit* *hexadecimal-literal-characters?*\ *hexadecimal-digit* → Digit 0 through 9, a through f, or A through F\ *hexadecimal-literal-character* → *hexadecimal-digit* | **`_`**\ *hexadecimal-literal-characters* → *hexadecimal-literal-character* *hexadecimal-literal-characters?* {% endhint %} ### Letterali in virgola mobile I *letterali in virgola mobile* rappresentano valori in virgola mobile di precisione non specificata. Per impostazione predefinita, i letterali in virgola mobile sono espressi in decimale (senza prefisso), ma possono anche essere espressi in esadecimale (con un prefisso `0x`). I letterali decimali in virgola mobile sono costituiti da una sequenza di cifre decimali seguita da una frazione decimale, da un esponente decimale o da entrambi. La frazione decimale è costituita da un punto decimale (`.`) seguito da una sequenza di cifre decimali. L'esponente è costituito da un prefisso `e` maiuscolo o minuscolo seguito da una sequenza di cifre decimali che indica per quale potenza di 10 viene moltiplicato il valore che precede la `e`. Per esempio, `1.25e2` rappresenta 1,25 x 10², che vale `125.0`. Analogamente, `1.25e-2` rappresenta 1,25 x 10⁻², che vale `0.0125`. I letterali esadecimali in virgola mobile sono costituiti da un prefisso `0x`, seguito da una frazione esadecimale opzionale, seguita da un esponente esadecimale. La frazione esadecimale è costituita da un punto decimale seguito da una sequenza di cifre esadecimali. L'esponente è costituito da un prefisso `p` maiuscolo o minuscolo seguito da una sequenza di cifre decimali che indica per quale potenza di 2 viene moltiplicato il valore che precede la `p`. Per esempio, `0xFp2` rappresenta 15 x 2², che vale `60`. Analogamente, `0xFp-2` rappresenta 15 x 2⁻², che vale `3.75`. I letterali in virgola mobile negativi si esprimono anteponendo un segno meno (`-`) a un letterale in virgola mobile, come in `-42.5`. I trattini bassi (`_`) sono consentiti tra le cifre per la leggibilità, ma vengono ignorati e quindi non influiscono sul valore del letterale. I letterali in virgola mobile possono iniziare con zeri iniziali (`0`), ma anche questi vengono ignorati e non influiscono sulla base né sul valore del letterale. Salvo diversa indicazione, il tipo predefinito inferito per un letterale in virgola mobile è il tipo `Double` della libreria standard di Swift, che rappresenta un numero in virgola mobile a 64 bit. La libreria standard di Swift definisce anche un tipo `Float`, che rappresenta un numero in virgola mobile a 32 bit. {% hint style="info" %} **Grammatica di un letterale in virgola mobile:** *signed-floating-point-literal* → > **`-`***?* *floating-point-literal* *floating-point-literal* → *decimal-literal* *decimal-fraction?* *decimal-exponent?*\ *floating-point-literal* → *hexadecimal-literal* *hexadecimal-fraction?* *hexadecimal-exponent* *decimal-fraction* → **`.`** *decimal-literal*\ *decimal-exponent* → *floating-point-e* *sign?* *decimal-literal* *hexadecimal-fraction* → **`.`** *hexadecimal-digit* *hexadecimal-literal-characters?*\ *hexadecimal-exponent* → *floating-point-p* *sign?* *decimal-literal* *floating-point-e* → **`e`** | **`E`**\ *floating-point-p* → **`p`** | **`P`**\ *sign* → **`+`** | **`-`** {% endhint %} ### Letterali stringa Un letterale stringa è una sequenza di caratteri racchiusa tra virgolette. Un letterale stringa su una sola riga è racchiuso tra virgolette doppie e ha la forma seguente: ```swift "<#characters#>" ``` I letterali stringa non possono contenere una virgoletta doppia senza escape (`"`), una barra rovesciata senza escape (`\`), un ritorno a capo o un avanzamento di riga. Un letterale stringa su più righe è racchiuso tra tre virgolette doppie e ha la forma seguente: ```swift """ <#characters#> """ ``` A differenza di un letterale stringa su una sola riga, un letterale stringa su più righe può contenere virgolette doppie senza escape (`"`), ritorni a capo e avanzamenti di riga. Non può contenere tre virgolette doppie senza escape una accanto all'altra. L'interruzione di riga dopo le `"""` che aprono il letterale stringa su più righe non fa parte della stringa. Anche l'interruzione di riga prima delle `"""` che chiudono il letterale non fa parte della stringa. Per creare un letterale stringa su più righe che inizi o termini con un avanzamento di riga, scrivi una riga vuota come prima o ultima riga. Un letterale stringa su più righe può essere indentato usando qualsiasi combinazione di spazi e tabulazioni; questa indentazione non viene inclusa nella stringa. Sono le `"""` che chiudono il letterale a determinare l'indentazione: ogni riga non vuota del letterale deve iniziare esattamente con la stessa indentazione che compare prima delle `"""` di chiusura; non avviene alcuna conversione tra tabulazioni e spazi. Puoi includere spazi e tabulazioni aggiuntivi dopo quell'indentazione; quegli spazi e quelle tabulazioni compaiono nella stringa. Le interruzioni di riga in un letterale stringa su più righe vengono normalizzate in modo da usare il carattere di avanzamento di riga. Anche se il tuo file sorgente contiene un misto di ritorni a capo e avanzamenti di riga, tutte le interruzioni di riga nella stringa saranno uguali. In un letterale stringa su più righe, scrivere una barra rovesciata (`\`) alla fine di una riga omette quell'interruzione di riga dalla stringa. Viene omesso anche qualsiasi spazio bianco tra la barra rovesciata e l'interruzione di riga. Puoi usare questa sintassi per mandare a capo forzatamente un letterale stringa su più righe nel tuo codice sorgente, senza cambiare il valore della stringa risultante. I caratteri speciali possono essere inclusi nei letterali stringa sia nella forma su una sola riga sia in quella su più righe usando le seguenti sequenze di escape: * Carattere null (`\0`) * Barra rovesciata (`\\`) * Tabulazione orizzontale (`\t`) * Avanzamento di riga (`\n`) * Ritorno a capo (`\r`) * Virgoletta doppia (`\"`) * Virgoletta singola (`\'`) * Scalare Unicode (`\u{`*n*`}`), dove *n* è un numero esadecimale composto da una a otto cifre Il valore di un'espressione può essere inserito in un letterale stringa collocando l'espressione tra parentesi dopo una barra rovesciata (`\`). L'espressione interpolata può contenere un letterale stringa, ma non può contenere una barra rovesciata senza escape, un ritorno a capo o un avanzamento di riga. Per esempio, tutti i letterali stringa seguenti hanno lo stesso valore: ```swift "1 2 3" "1 2 \("3")" "1 2 \(3)" "1 2 \(1 + 2)" let x = 3; "1 2 \(x)" ``` Una stringa delimitata da delimitatori estesi è una sequenza di caratteri racchiusa tra virgolette e da un insieme bilanciato di uno o più cancelletti (`#`). Una stringa delimitata da delimitatori estesi ha le forme seguenti: ```swift #"<#characters#>"# #""" <#characters#> """# ``` I caratteri speciali in una stringa delimitata da delimitatori estesi compaiono nella stringa risultante come caratteri normali anziché come caratteri speciali. Puoi usare i delimitatori estesi per creare stringhe con caratteri che normalmente avrebbero un effetto speciale, come generare un'interpolazione di stringa, iniziare una sequenza di escape o terminare la stringa. L'esempio seguente mostra un letterale stringa e una stringa delimitata da delimitatori estesi che creano valori stringa equivalenti: ```swift let string = #"\(x) \ " \u{2603}"# let escaped = "\\(x) \\ \" \\u{2603}" print(string) // Stampa "\(x) \ " \u{2603}". print(string == escaped) // Stampa "true". ``` Se usi più di un cancelletto per formare una stringa delimitata da delimitatori estesi, non inserire spazi bianchi tra i cancelletti: ```swift print(###"Line 1\###nLine 2"###) // OK print(# # #"Line 1\# # #nLine 2"# # #) // Errore ``` I letterali stringa su più righe che crei usando i delimitatori estesi hanno gli stessi requisiti di indentazione dei normali letterali stringa su più righe. Il tipo predefinito inferito per un letterale stringa è `String`. Per maggiori informazioni sul tipo `String`, vedi [Stringhe e caratteri](/guida-al-linguaggio/stringhe-e-caratteri.md) e [`String`](https://developer.apple.com/documentation/swift/string). I letterali stringa concatenati tramite l'operatore `+` vengono concatenati in fase di compilazione. Per esempio, i valori di `textA` e `textB` nell'esempio seguente sono identici — non viene eseguita alcuna concatenazione in fase di esecuzione. ```swift let textA = "Hello " + "world" let textB = "Hello world" ``` {% hint style="info" %} **Grammatica di un letterale stringa:** *string-literal* → *static-string-literal* | *interpolated-string-literal* *string-literal-opening-delimiter* → *extended-string-literal-delimiter?* **`"`**\ *string-literal-closing-delimiter* → **`"`** *extended-string-literal-delimiter?* *static-string-literal* → *string-literal-opening-delimiter* *quoted-text?* *string-literal-closing-delimiter*\ *static-string-literal* → *multiline-string-literal-opening-delimiter* *multiline-quoted-text?* *multiline-string-literal-closing-delimiter* *multiline-string-literal-opening-delimiter* → *extended-string-literal-delimiter?* **`"""`**\ *multiline-string-literal-closing-delimiter* → **`"""`** *extended-string-literal-delimiter?*\ *extended-string-literal-delimiter* → **`#`** *extended-string-literal-delimiter?* *quoted-text* → *quoted-text-item* *quoted-text?*\ *quoted-text-item* → *escaped-character*\ *quoted-text-item* → Any Unicode scalar value except **`"`**, **`\`**, U+000A, or U+000D *multiline-quoted-text* → *multiline-quoted-text-item* *multiline-quoted-text?*\ *multiline-quoted-text-item* → *escaped-character*\ *multiline-quoted-text-item* → Any Unicode scalar value except **`\`**\ *multiline-quoted-text-item* → *escaped-newline* *interpolated-string-literal* → *string-literal-opening-delimiter* *interpolated-text?* *string-literal-closing-delimiter*\ *interpolated-string-literal* → *multiline-string-literal-opening-delimiter* *multiline-interpolated-text?* *multiline-string-literal-closing-delimiter* *interpolated-text* → *interpolated-text-item* *interpolated-text?*\ *interpolated-text-item* → **`\(`** *expression* **`)`** | *quoted-text-item* *multiline-interpolated-text* → *multiline-interpolated-text-item* *multiline-interpolated-text?*\ *multiline-interpolated-text-item* → **`\(`** *expression* **`)`** | *multiline-quoted-text-item* *escape-sequence* → **`\`** *extended-string-literal-delimiter*\ *escaped-character* → *escape-sequence* **`0`** | *escape-sequence* **`\`** | *escape-sequence* **`t`** | *escape-sequence* **`n`** | *escape-sequence* **`r`** | *escape-sequence* **`"`** | *escape-sequence* **`'`**\ *escaped-character* → *escape-sequence* **`u`** **`{`** *unicode-scalar-digits* **`}`**\ *unicode-scalar-digits* → Between one and eight hexadecimal digits *escaped-newline* → *escape-sequence* *inline-spaces?* *line-break* {% endhint %} ### Letterali espressione regolare Un letterale espressione regolare è una sequenza di caratteri racchiusa tra barre (`/`) con la forma seguente: ```swift /<#regular expression#>/ ``` I letterali espressione regolare non devono iniziare con una tabulazione o uno spazio senza escape, e non possono contenere una barra senza escape (`/`), un ritorno a capo o un avanzamento di riga. All'interno di un letterale espressione regolare, una barra rovesciata è intesa come parte di quell'espressione regolare, e non semplicemente come carattere di escape come nei letterali stringa. Indica che il carattere speciale seguente deve essere interpretato letteralmente, oppure che il carattere non speciale seguente deve essere interpretato in modo speciale. Per esempio, `/\(/` corrisponde a una singola parentesi tonda aperta e `/\d/` corrisponde a una singola cifra. Un letterale espressione regolare delimitato da delimitatori estesi è una sequenza di caratteri racchiusa tra barre (`/`) e da un insieme bilanciato di uno o più cancelletti (`#`). Un letterale espressione regolare delimitato da delimitatori estesi ha le forme seguenti: ```swift #/<#regular expression#>/# #/ <#regular expression#> /# ``` Un letterale espressione regolare che usa delimitatori estesi può iniziare con uno spazio o una tabulazione senza escape, contenere barre senza escape (`/`) ed estendersi su più righe. Per un letterale espressione regolare su più righe, il delimitatore di apertura deve trovarsi alla fine di una riga, e il delimitatore di chiusura deve trovarsi su una riga a sé. All'interno di un letterale espressione regolare su più righe, la sintassi estesa delle espressioni regolari è abilitata per impostazione predefinita — nello specifico, gli spazi bianchi vengono ignorati e i commenti sono consentiti. Se usi più di un cancelletto per formare un letterale espressione regolare delimitato da delimitatori estesi, non inserire spazi bianchi tra i cancelletti: ```swift let regex1 = ##/abc/## // OK let regex2 = # #/abc/# # // Errore ``` Se hai bisogno di creare un letterale espressione regolare vuoto, devi usare la sintassi con delimitatori estesi. {% hint style="info" %} **Grammatica di un letterale espressione regolare:** *regular-expression-literal* → *regular-expression-literal-opening-delimiter* *regular-expression* *regular-expression-literal-closing-delimiter*\ *regular-expression* → Any regular expression *regular-expression-literal-opening-delimiter* → *extended-regular-expression-literal-delimiter?* **`/`**\ *regular-expression-literal-closing-delimiter* → **`/`** *extended-regular-expression-literal-delimiter?* *extended-regular-expression-literal-delimiter* → **`#`** *extended-regular-expression-literal-delimiter?* {% endhint %} ## Operatori La libreria standard di Swift definisce diversi operatori a tua disposizione, molti dei quali sono discussi in [Operatori di base](/guida-al-linguaggio/operatori-di-base.md) e in [Operatori avanzati](/guida-al-linguaggio/operatori-avanzati.md). Questa sezione descrive quali caratteri possono essere usati per definire operatori personalizzati. Gli operatori personalizzati possono iniziare con uno dei caratteri ASCII `/`, `=`, `-`, `+`, `!`, `*`, `%`, `<`, `>`, `&`, `|`, `^`, `?` o `~`, oppure con uno dei caratteri Unicode definiti nella grammatica seguente (che comprendono caratteri dei blocchi Unicode *Mathematical Operators*, *Miscellaneous Symbols* e *Dingbats*, tra gli altri). Dopo il primo carattere, sono consentiti anche caratteri Unicode combinanti. Puoi anche definire operatori personalizzati che iniziano con un punto (`.`). Questi operatori possono contenere ulteriori punti. Per esempio, `.+.` viene trattato come un unico operatore. Se un operatore non inizia con un punto, non può contenere un punto altrove. Per esempio, `+.+` viene trattato come l'operatore `+` seguito dall'operatore `.+`. Sebbene tu possa definire operatori personalizzati che contengono un punto interrogativo (`?`), essi non possono essere costituiti da un solo carattere punto interrogativo. Inoltre, sebbene gli operatori possano contenere un punto esclamativo (`!`), gli operatori postfissi non possono iniziare né con un punto interrogativo né con un punto esclamativo. {% hint style="info" %} **Nota:** I token `=`, `->`, `//`, `/*`, `*/`, `.`, gli operatori prefissi `<`, `&` e `?`, l'operatore infisso `?`, e gli operatori postfissi `>`, `!` e `?` sono riservati. Questi token non possono essere sottoposti a overload, né possono essere usati come operatori personalizzati. {% endhint %} Gli spazi bianchi attorno a un operatore vengono usati per determinare se un operatore è usato come operatore prefisso, postfisso o infisso. Questo comportamento segue le regole seguenti: * Se un operatore ha spazi bianchi su entrambi i lati o su nessuno dei due, viene trattato come operatore infisso. Per esempio, l'operatore `+++` in `a+++b` e `a +++ b` viene trattato come operatore infisso. * Se un operatore ha spazi bianchi solo sul lato sinistro, viene trattato come operatore unario prefisso. Per esempio, l'operatore `+++` in `a +++b` viene trattato come operatore unario prefisso. * Se un operatore ha spazi bianchi solo sul lato destro, viene trattato come operatore unario postfisso. Per esempio, l'operatore `+++` in `a+++ b` viene trattato come operatore unario postfisso. * Se un operatore non ha spazi bianchi a sinistra ma è seguito immediatamente da un punto (`.`), viene trattato come operatore unario postfisso. Per esempio, l'operatore `+++` in `a+++.b` viene trattato come operatore unario postfisso (`a+++ .b` anziché `a +++ .b`). Ai fini di queste regole, anche i caratteri `(`, `[` e `{` prima di un operatore, i caratteri `)`, `]` e `}` dopo un operatore, e i caratteri `,`, `;` e `:` sono considerati spazi bianchi. Se l'operatore predefinito `!` o `?` non ha spazi bianchi a sinistra, viene trattato come operatore postfisso, indipendentemente dal fatto che abbia spazi bianchi a destra. Per usare `?` come operatore di optional chaining, non deve avere spazi bianchi a sinistra. Per usarlo nell'operatore condizionale ternario (`?` `:`), deve avere spazi bianchi su entrambi i lati. Se uno degli argomenti di un operatore infisso è un letterale espressione regolare, allora l'operatore deve avere spazi bianchi su entrambi i lati. In certi costrutti, gli operatori che iniziano con `<` o `>` possono essere suddivisi in due o più token. La parte rimanente viene trattata allo stesso modo e può essere suddivisa di nuovo. Di conseguenza, non hai bisogno di aggiungere spazi bianchi per eliminare l'ambiguità tra i caratteri `>` di chiusura in costrutti come `Dictionary>`. In questo esempio, i caratteri `>` di chiusura non vengono trattati come un unico token che potrebbe poi essere erroneamente interpretato come operatore di scorrimento di bit `>>`. Per imparare a definire nuovi operatori personalizzati, vedi [Operatori personalizzati](/guida-al-linguaggio/operatori-avanzati.md#operatori-personalizzati) e [Dichiarazione di operatore](/riferimento-del-linguaggio/dichiarazioni.md#dichiarazione-di-operatore). Per imparare a eseguire l'overload di operatori esistenti, vedi [Metodi operatore](/guida-al-linguaggio/operatori-avanzati.md#metodi-operatore). {% hint style="info" %} **Grammatica degli operatori:** *operator* → *operator-head* *operator-characters?*\ *operator* → *dot-operator-head* *dot-operator-characters* *operator-head* → **`/`** | **`=`** | **`-`** | **`+`** | **`!`** | **`*`** | **`%`** | **`<`** | **`>`** | **`&`** | **`|`** | **`^`** | **`~`** | **`?`**\ *operator-head* → U+00A1–U+00A7\ *operator-head* → U+00A9 or U+00AB\ *operator-head* → U+00AC or U+00AE\ *operator-head* → U+00B0–U+00B1\ *operator-head* → U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7\ *operator-head* → U+2016–U+2017\ *operator-head* → U+2020–U+2027\ *operator-head* → U+2030–U+203E\ *operator-head* → U+2041–U+2053\ *operator-head* → U+2055–U+205E\ *operator-head* → U+2190–U+23FF\ *operator-head* → U+2500–U+2775\ *operator-head* → U+2794–U+2BFF\ *operator-head* → U+2E00–U+2E7F\ *operator-head* → U+3001–U+3003\ *operator-head* → U+3008–U+3020\ *operator-head* → U+3030 *operator-character* → *operator-head*\ *operator-character* → U+0300–U+036F\ *operator-character* → U+1DC0–U+1DFF\ *operator-character* → U+20D0–U+20FF\ *operator-character* → U+FE00–U+FE0F\ *operator-character* → U+FE20–U+FE2F\ *operator-character* → U+E0100–U+E01EF\ *operator-characters* → *operator-character* *operator-characters?* *dot-operator-head* → **`.`**\ *dot-operator-character* → **`.`** | *operator-character*\ *dot-operator-characters* → *dot-operator-character* *dot-operator-characters?* *infix-operator* → *operator*\ *prefix-operator* → *operator*\ *postfix-operator* → *operator* {% endhint %}