> 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/guida-al-linguaggio/stringhe-e-caratteri.md).
# Stringhe e caratteri (Strings and Characters)
Memorizza e manipola il testo.
Una *stringa* è una serie di caratteri, come `"hello, world"` o `"albatross"`. Le stringhe Swift sono rappresentate dal tipo `String`. Al contenuto di una `String` si può accedere in vari modi, anche come collezione di valori `Character`.
I tipi `String` e `Character` di Swift forniscono un modo veloce e conforme a Unicode per lavorare con il testo nel tuo codice. La sintassi per la creazione e la manipolazione delle stringhe è leggera e leggibile, con una sintassi dei letterali stringa simile a quella del C. La concatenazione di stringhe è semplice quanto combinare due stringhe con l'operatore `+`, e la mutabilità delle stringhe si gestisce scegliendo tra una costante e una variabile, proprio come per qualsiasi altro valore in Swift. Puoi anche usare le stringhe per inserire costanti, variabili, letterali ed espressioni in stringhe più lunghe, in un processo noto come interpolazione di stringhe. Questo rende facile creare valori stringa personalizzati da mostrare, memorizzare e stampare.
Nonostante questa semplicità di sintassi, il tipo `String` di Swift è un'implementazione di stringhe veloce e moderna. Ogni stringa è composta da caratteri Unicode indipendenti dalla codifica, e fornisce supporto per accedere a quei caratteri in varie rappresentazioni Unicode.
{% hint style="info" %}
**Nota:** Il tipo `String` di Swift è collegato (bridged) alla classe `NSString` di Foundation. Foundation estende inoltre `String` per esporre i metodi definiti da `NSString`. Ciò significa che, se importi Foundation, puoi accedere a quei metodi di `NSString` su `String` senza conversioni.
Per maggiori informazioni sull'uso di `String` con Foundation e Cocoa, vedi [Bridging Between String and NSString](https://developer.apple.com/documentation/swift/string#Bridging-Between-String-and-NSString).
{% endhint %}
## Letterali stringa
Puoi includere valori `String` predefiniti nel tuo codice come *letterali stringa*. Un letterale stringa è una sequenza di caratteri racchiusa tra virgolette doppie (`"`).
Usa un letterale stringa come valore iniziale per una costante o una variabile:
```swift
let someString = "Some string literal value"
```
Nota che Swift inferisce un tipo `String` per la costante `someString` perché è inizializzata con un valore letterale stringa.
### Letterali stringa su più righe
Se hai bisogno di una stringa che si estenda su più righe, usa un letterale stringa su più righe — una sequenza di caratteri racchiusa tra tre virgolette doppie:
```swift
let quotation = """
The White Rabbit put on his spectacles. "Where shall I begin,
please your Majesty?" he asked.
"Begin at the beginning," the King said gravely, "and go on
till you come to the end; then stop."
"""
```
Un letterale stringa su più righe include tutte le righe comprese tra le sue virgolette di apertura e di chiusura. La stringa inizia sulla prima riga dopo le virgolette di apertura (`"""`) e termina sulla riga prima delle virgolette di chiusura, il che significa che nessuna delle stringhe seguenti inizia o termina con un'interruzione di riga:
```swift
let singleLineString = "These are the same."
let multilineString = """
These are the same.
"""
```
Quando il tuo codice sorgente include un'interruzione di riga all'interno di un letterale stringa su più righe, quell'interruzione di riga compare anche nel valore della stringa. Se vuoi usare le interruzioni di riga per rendere il tuo codice sorgente più facile da leggere, ma non vuoi che le interruzioni di riga facciano parte del valore della stringa, scrivi una barra rovesciata (`\`) alla fine di quelle righe:
```swift
let softWrappedQuotation = """
The White Rabbit put on his spectacles. "Where shall I begin, \
please your Majesty?" he asked.
"Begin at the beginning," the King said gravely, "and go on \
till you come to the end; then stop."
"""
```
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. Per esempio:
```swift
let lineBreaks = """
This string starts with a line break.
It also ends with a line break.
"""
```
Una stringa su più righe può essere indentata in modo da corrispondere al codice circostante. Lo spazio bianco prima delle virgolette di chiusura (`"""`) dice a Swift quale spazio bianco ignorare prima di tutte le altre righe. Tuttavia, se scrivi dello spazio bianco all'inizio di una riga in aggiunta a quello che precede le virgolette di chiusura, quello spazio bianco *viene* incluso.
Nell'esempio qui sopra, anche se l'intero letterale stringa su più righe è indentato, la prima e l'ultima riga della stringa non iniziano con alcuno spazio bianco. La riga centrale ha un'indentazione maggiore rispetto alle virgolette di chiusura, quindi inizia con quell'indentazione aggiuntiva di quattro spazi.
### Caratteri speciali nei letterali stringa
I letterali stringa possono includere i seguenti caratteri speciali:
* I caratteri speciali con escape `\0` (carattere null), `\\` (barra rovesciata), `\t` (tabulazione orizzontale), `\n` (avanzamento di riga), `\r` (ritorno a capo), `\"` (virgoletta doppia) e `\'` (virgoletta singola)
* Un valore scalare Unicode arbitrario, scritto come `\u{`*n*`}`, dove *n* è un numero esadecimale da 1 a 8 cifre (Unicode è discusso più avanti in [Unicode](/guida-al-linguaggio/stringhe-e-caratteri.md#unicode))
Il codice seguente mostra quattro esempi di questi caratteri speciali. La costante `wiseWords` contiene due virgolette doppie con escape. Le costanti `dollarSign`, `blackHeart` e `sparklingHeart` dimostrano il formato degli scalari Unicode:
```swift
let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
// "Imagination is more important than knowledge" - Einstein
let dollarSign = "\u{24}" // $, scalare Unicode U+0024
let blackHeart = "\u{2665}" // ♥, scalare Unicode U+2665
let sparklingHeart = "\u{1F496}" // 💖, scalare Unicode U+1F496
```
Poiché i letterali stringa su più righe usano tre virgolette doppie invece di una sola, puoi includere una virgoletta doppia (`"`) all'interno di un letterale stringa su più righe senza farne l'escape. Per includere il testo `"""` in una stringa su più righe, fai l'escape di almeno una delle virgolette. Per esempio:
```swift
let threeDoubleQuotationMarks = """
Escaping the first quotation mark \"""
Escaping all three quotation marks \"\"\"
"""
```
### Delimitatori di stringa estesi
Puoi collocare un letterale stringa all'interno di *delimitatori estesi* per includere caratteri speciali in una stringa senza attivarne l'effetto. Collochi la tua stringa tra virgolette (`"`) e la circondi con dei cancelletti (`#`). Per esempio, stampare il letterale stringa `#"Line 1\nLine 2"#` stampa la sequenza di escape dell'avanzamento di riga (`\n`) anziché stampare la stringa su due righe.
Se hai bisogno degli effetti speciali di un carattere in un letterale stringa, fai corrispondere il numero di cancelletti all'interno della stringa dopo il carattere di escape (`\`). Per esempio, se la tua stringa è `#"Line 1\nLine 2"#` e vuoi andare a capo, puoi usare invece `#"Line 1\#nLine 2"#`. Analogamente, anche `###"Line1\###nLine2"###` va a capo.
Anche i letterali stringa creati usando i delimitatori estesi possono essere letterali stringa su più righe. Puoi usare i delimitatori estesi per includere il testo `"""` in una stringa su più righe, sovrascrivendo il comportamento predefinito che termina il letterale. Per esempio:
```swift
let threeMoreDoubleQuotationMarks = #"""
Here are three more double quotes: """
"""#
```
## Inizializzare una stringa vuota
Per creare un valore `String` vuoto come punto di partenza per costruire una stringa più lunga, assegna un letterale stringa vuoto a una variabile oppure inizializza una nuova istanza di `String` con la sintassi di inizializzazione:
```swift
var emptyString = "" // letterale stringa vuoto
var anotherEmptyString = String() // sintassi di inizializzazione
// queste due stringhe sono entrambe vuote, e sono equivalenti tra loro
```
Scopri se un valore `String` è vuoto controllando la sua proprietà booleana `isEmpty`:
```swift
if emptyString.isEmpty {
print("Nothing to see here")
}
// Stampa "Nothing to see here".
```
## Mutabilità delle stringhe
Indichi se una particolare `String` può essere modificata (o *mutata*) assegnandola a una variabile (nel qual caso può essere modificata), o a una costante (nel qual caso non può essere modificata):
```swift
var variableString = "Horse"
variableString += " and carriage"
// variableString ora è "Horse and carriage"
let constantString = "Highlander"
constantString += " and another Highlander"
// questo segnala un errore in fase di compilazione - una stringa costante non può essere modificata
```
{% hint style="info" %}
**Nota:** Questo approccio è diverso dalla mutazione delle stringhe in Objective-C e Cocoa, dove scegli tra due classi (`NSString` e `NSMutableString`) per indicare se una stringa può essere mutata.
{% endhint %}
## Le stringhe sono tipi valore
Il tipo `String` di Swift è un *tipo valore*. Se crei un nuovo valore `String`, quel valore `String` viene *copiato* quando viene passato a una funzione o a un metodo, o quando viene assegnato a una costante o a una variabile. In ciascun caso, viene creata una nuova copia del valore `String` esistente, e viene passata o assegnata la nuova copia, non la versione originale. I tipi valore sono descritti in [Strutture ed enumerazioni sono tipi valore](/guida-al-linguaggio/strutture-e-classi.md#strutture-ed-enumerazioni-sono-tipi-valore).
Il comportamento di copia predefinita di `String` in Swift garantisce che, quando una funzione o un metodo ti passa un valore `String`, sia chiaro che quell'esatto valore `String` è tuo, indipendentemente dalla sua provenienza. Puoi essere sicuro che la stringa che ti viene passata non verrà modificata a meno che non sia tu a modificarla.
Dietro le quinte, il compilatore di Swift ottimizza l'uso delle stringhe in modo che la copia effettiva avvenga solo quando è assolutamente necessaria. Ciò significa che ottieni sempre ottime prestazioni quando lavori con le stringhe come tipi valore.
## Lavorare con i caratteri
Puoi accedere ai singoli valori `Character` di una `String` iterando sulla stringa con un ciclo `for`-`in`:
```swift
for character in "Dog!🐶" {
print(character)
}
// D
// o
// g
// !
// 🐶
```
Il ciclo `for`-`in` è descritto in [Cicli for-in](/guida-al-linguaggio/flusso-di-controllo.md#cicli-for-in).
In alternativa, puoi creare una costante o una variabile `Character` autonoma a partire da un letterale stringa di un solo carattere fornendo un'annotazione di tipo `Character`:
```swift
let exclamationMark: Character = "!"
```
I valori `String` possono essere costruiti passando un array di valori `Character` come argomento al suo inizializzatore:
```swift
let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
print(catString)
// Stampa "Cat!🐱".
```
## Concatenare stringhe e caratteri
I valori `String` possono essere sommati (o *concatenati*) con l'operatore di addizione (`+`) per creare un nuovo valore `String`:
```swift
let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2
// welcome ora è uguale a "hello there"
```
Puoi anche aggiungere un valore `String` a una variabile `String` esistente con l'operatore di assegnamento con addizione (`+=`):
```swift
var instruction = "look over"
instruction += string2
// instruction ora è uguale a "look over there"
```
Puoi aggiungere un valore `Character` a una variabile `String` con il metodo `append()` del tipo `String`:
```swift
let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome ora è uguale a "hello there!"
```
{% hint style="info" %}
**Nota:** Non puoi aggiungere una `String` o un `Character` a una variabile `Character` esistente, perché un valore `Character` deve contenere un solo carattere.
{% endhint %}
Se usi letterali stringa su più righe per costruire le righe di una stringa più lunga, vuoi che ogni riga della stringa termini con un'interruzione di riga, compresa l'ultima. Per esempio:
```swift
let badStart = """
one
two
"""
let end = """
three
"""
print(badStart + end)
// Stampa due righe:
// one
// twothree
let goodStart = """
one
two
"""
print(goodStart + end)
// Stampa tre righe:
// one
// two
// three
```
Nel codice qui sopra, concatenare `badStart` con `end` produce una stringa di due righe, che non è il risultato desiderato. Poiché l'ultima riga di `badStart` non termina con un'interruzione di riga, quella riga viene unita alla prima riga di `end`. Al contrario, entrambe le righe di `goodStart` terminano con un'interruzione di riga, quindi quando viene combinata con `end` il risultato ha tre righe, come previsto.
## Interpolazione di stringhe
L'*interpolazione di stringhe* è un modo per costruire un nuovo valore `String` a partire da un insieme di costanti, variabili, letterali ed espressioni includendone i valori all'interno di un letterale stringa. Puoi usare l'interpolazione di stringhe sia nei letterali stringa su una sola riga sia in quelli su più righe. Ogni elemento che inserisci nel letterale stringa è racchiuso in una coppia di parentesi, preceduta da una barra rovesciata (`\`):
```swift
let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message è "3 times 2.5 is 7.5"
```
Nell'esempio qui sopra, il valore di `multiplier` viene inserito in un letterale stringa come `\(multiplier)`. Questo segnaposto viene sostituito con il valore effettivo di `multiplier` quando l'interpolazione di stringhe viene valutata per creare una stringa effettiva.
Il valore di `multiplier` fa anche parte di un'espressione più ampia più avanti nella stringa. Questa espressione calcola il valore di `Double(multiplier) * 2.5` e inserisce il risultato (`7.5`) nella stringa. In questo caso, l'espressione si scrive `\(Double(multiplier) * 2.5)` quando viene inclusa all'interno del letterale stringa.
Puoi usare i delimitatori di stringa estesi per creare stringhe contenenti caratteri che altrimenti verrebbero trattati come un'interpolazione di stringhe. Per esempio:
```swift
print(#"Write an interpolated string in Swift using \(multiplier)."#)
// Stampa "Write an interpolated string in Swift using \(multiplier)."
```
Per usare l'interpolazione di stringhe all'interno di una stringa che usa delimitatori estesi, fai corrispondere il numero di cancelletti dopo la barra rovesciata al numero di cancelletti all'inizio e alla fine della stringa. Per esempio:
```swift
print(#"6 times 7 is \#(6 * 7)."#)
// Stampa "6 times 7 is 42."
```
{% hint style="info" %}
**Nota:** Le espressioni che scrivi tra parentesi all'interno di una stringa interpolata non possono contenere una barra rovesciata senza escape (`\`), un ritorno a capo o un avanzamento di riga. Tuttavia, possono contenere altri letterali stringa.
{% endhint %}
## Unicode
*Unicode* è uno standard internazionale per codificare, rappresentare ed elaborare il testo in diversi sistemi di scrittura. Ti permette di rappresentare quasi qualsiasi carattere di qualsiasi lingua in forma standardizzata, e di leggere e scrivere quei caratteri da e verso una fonte esterna come un file di testo o una pagina web. I tipi `String` e `Character` di Swift sono pienamente conformi a Unicode, come descritto in questa sezione.
### Valori scalari Unicode
Dietro le quinte, il tipo nativo `String` di Swift è costruito a partire da *valori scalari Unicode*. Un valore scalare Unicode è un numero univoco a 21 bit per un carattere o un modificatore, come `U+0061` per `LATIN SMALL LETTER A` (`"a"`), o `U+1F425` per `FRONT-FACING BABY CHICK` (`"🐥"`).
Nota che non tutti i valori scalari Unicode a 21 bit sono assegnati a un carattere — alcuni scalari sono riservati per assegnazioni future o per l'uso nella codifica UTF-16. I valori scalari assegnati a un carattere hanno tipicamente anche un nome, come `LATIN SMALL LETTER A` e `FRONT-FACING BABY CHICK` negli esempi qui sopra.
### Cluster di grafemi estesi
Ogni istanza del tipo `Character` di Swift rappresenta un singolo *cluster di grafemi esteso* (extended grapheme cluster). Un cluster di grafemi esteso è una sequenza di uno o più scalari Unicode che (una volta combinati) producono un unico carattere leggibile.
Ecco un esempio. La lettera `é` può essere rappresentata come il singolo scalare Unicode `é` (`LATIN SMALL LETTER E WITH ACUTE`, ovvero `U+00E9`). Tuttavia, la stessa lettera può anche essere rappresentata come una *coppia* di scalari — una lettera standard `e` (`LATIN SMALL LETTER E`, ovvero `U+0065`), seguita dallo scalare `COMBINING ACUTE ACCENT` (`U+0301`). Lo scalare `COMBINING ACUTE ACCENT` viene applicato graficamente allo scalare che lo precede, trasformando una `e` in una `é` quando viene visualizzato da un sistema di rendering del testo che supporta Unicode.
In entrambi i casi, la lettera `é` è rappresentata come un unico valore `Character` di Swift che rappresenta un cluster di grafemi esteso. Nel primo caso, il cluster contiene un solo scalare; nel secondo caso, è un cluster di due scalari:
```swift
let eAcute: Character = "\u{E9}" // é
let combinedEAcute: Character = "\u{65}\u{301}" // e seguita da ́
// eAcute è é, combinedEAcute è é
```
I cluster di grafemi estesi sono un modo flessibile di rappresentare molti caratteri di scritture complesse come un unico valore `Character`. Per esempio, le sillabe Hangul dell'alfabeto coreano possono essere rappresentate come sequenza precomposta oppure scomposta. Entrambe queste rappresentazioni valgono come un unico valore `Character` in Swift:
```swift
let precomposed: Character = "\u{D55C}" // 한
let decomposed: Character = "\u{1112}\u{1161}\u{11AB}" // ᄒ, ᅡ, ᆫ
// precomposed è 한, decomposed è 한
```
I cluster di grafemi estesi permettono agli scalari dei segni racchiudenti (come `COMBINING ENCLOSING CIRCLE`, ovvero `U+20DD`) di racchiudere altri scalari Unicode come parte di un unico valore `Character`:
```swift
let enclosedEAcute: Character = "\u{E9}\u{20DD}"
// enclosedEAcute è é⃝
```
Gli scalari Unicode per i simboli indicatori regionali possono essere combinati a coppie per formare un unico valore `Character`, come questa combinazione di `REGIONAL INDICATOR SYMBOL LETTER U` (`U+1F1FA`) e `REGIONAL INDICATOR SYMBOL LETTER S` (`U+1F1F8`):
```swift
let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
// regionalIndicatorForUS è 🇺🇸
```
## Contare i caratteri
Per ottenere il numero di valori `Character` di una stringa, usa la proprietà `count` della stringa:
```swift
let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
print("unusualMenagerie has \(unusualMenagerie.count) characters")
// Stampa "unusualMenagerie has 40 characters".
```
Nota che l'uso da parte di Swift dei cluster di grafemi estesi per i valori `Character` significa che la concatenazione e la modifica delle stringhe potrebbero non influire sempre sul numero di caratteri di una stringa.
Per esempio, se inizializzi una nuova stringa con la parola di quattro caratteri `cafe`, e poi aggiungi un `COMBINING ACUTE ACCENT` (`U+0301`) alla fine della stringa, la stringa risultante avrà ancora un numero di caratteri pari a `4`, con un quarto carattere `é`, non `e`:
```swift
var word = "cafe"
print("the number of characters in \(word) is \(word.count)")
// Stampa "the number of characters in cafe is 4".
word += "\u{301}" // COMBINING ACUTE ACCENT, U+0301
print("the number of characters in \(word) is \(word.count)")
// Stampa "the number of characters in café is 4".
```
{% hint style="info" %}
**Nota:** I cluster di grafemi estesi possono essere composti da più scalari Unicode. Ciò significa che caratteri diversi — e rappresentazioni diverse dello stesso carattere — possono richiedere quantità diverse di memoria per essere memorizzati. Per questo motivo, i caratteri in Swift non occupano ciascuno la stessa quantità di memoria all'interno della rappresentazione di una stringa. Di conseguenza, il numero di caratteri di una stringa non può essere calcolato senza iterare sulla stringa per determinare i confini dei suoi cluster di grafemi estesi. Se lavori con valori stringa particolarmente lunghi, tieni presente che la proprietà `count` deve iterare sugli scalari Unicode dell'intera stringa per determinare i caratteri di quella stringa.
Il numero di caratteri restituito dalla proprietà `count` non è sempre uguale alla proprietà `length` di una `NSString` che contiene gli stessi caratteri. La lunghezza di una `NSString` si basa sul numero di unità di codice a 16 bit nella rappresentazione UTF-16 della stringa e non sul numero di cluster di grafemi estesi Unicode nella stringa.
{% endhint %}
## Accedere a una stringa e modificarla
Accedi a una stringa e la modifichi tramite i suoi metodi e le sue proprietà, oppure usando la sintassi dei subscript.
### Indici delle stringhe
Ogni valore `String` ha un *tipo indice* associato, `String.Index`, che corrisponde alla posizione di ciascun `Character` nella stringa.
Come accennato sopra, caratteri diversi possono richiedere quantità diverse di memoria per essere memorizzati, quindi per determinare quale `Character` si trova in una particolare posizione, devi iterare su ciascuno scalare Unicode a partire dall'inizio o dalla fine di quella `String`. Per questo motivo, le stringhe Swift non possono essere indicizzate con valori interi.
Usa la proprietà `startIndex` per accedere alla posizione del primo `Character` di una `String`. La proprietà `endIndex` è la posizione successiva all'ultimo carattere di una `String`. Di conseguenza, la proprietà `endIndex` non è un argomento valido per il subscript di una stringa. Se una `String` è vuota, `startIndex` ed `endIndex` sono uguali.
Accedi agli indici precedente e successivo a un dato indice usando i metodi `index(before:)` e `index(after:)` di `String`. Per accedere a un indice più lontano dall'indice dato, puoi usare il metodo `index(_:offsetBy:)` invece di chiamare più volte uno di questi metodi.
Puoi usare la sintassi dei subscript per accedere al `Character` in corrispondenza di un particolare indice di una `String`.
```swift
let greeting = "Guten Tag!"
greeting[greeting.startIndex]
// G
greeting[greeting.index(before: greeting.endIndex)]
// !
greeting[greeting.index(after: greeting.startIndex)]
// u
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index]
// a
```
Tentare di accedere a un indice al di fuori dell'intervallo di una stringa o a un `Character` in corrispondenza di un indice al di fuori dell'intervallo di una stringa attiverà un errore in fase di esecuzione.
```swift
greeting[greeting.endIndex] // Errore
greeting.index(after: greeting.endIndex) // Errore
```
Usa la proprietà `indices` per accedere a tutti gli indici dei singoli caratteri di una stringa.
```swift
for index in greeting.indices {
print("\(greeting[index]) ", terminator: "")
}
// Stampa "G u t e n T a g ! ".
```
{% hint style="info" %}
**Nota:** Puoi usare le proprietà `startIndex` ed `endIndex` e i metodi `index(before:)`, `index(after:)` e `index(_:offsetBy:)` su qualsiasi tipo conforme al protocollo `Collection`. Questo include `String`, come mostrato qui, così come tipi collezione come `Array`, `Dictionary` e `Set`.
{% endhint %}
### Inserire e rimuovere
Per inserire un singolo carattere in una stringa in corrispondenza di un indice specificato, usa il metodo `insert(_:at:)`, e per inserire il contenuto di un'altra stringa in corrispondenza di un indice specificato, usa il metodo `insert(contentsOf:at:)`.
```swift
var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)
// welcome ora è uguale a "hello!"
welcome.insert(contentsOf: " there", at: welcome.index(before: welcome.endIndex))
// welcome ora è uguale a "hello there!"
```
Per rimuovere un singolo carattere da una stringa in corrispondenza di un indice specificato, usa il metodo `remove(at:)`, e per rimuovere una sottostringa in un intervallo specificato, usa il metodo `removeSubrange(_:)`:
```swift
welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome ora è uguale a "hello there"
let range = welcome.index(welcome.endIndex, offsetBy: -6)..
Quando ottieni una sottostringa da una stringa — per esempio, usando un subscript o un metodo come `prefix(_:)` — il risultato è un'istanza di [`Substring`](https://developer.apple.com/documentation/swift/substring), non un'altra stringa. In Swift le sottostringhe hanno la maggior parte degli stessi metodi delle stringhe, il che significa che puoi lavorare con le sottostringhe nello stesso modo in cui lavori con le stringhe. Tuttavia, a differenza delle stringhe, usi le sottostringhe solo per un breve periodo di tempo mentre esegui azioni su una stringa. Quando sei pronto a memorizzare il risultato per un tempo più lungo, converti la sottostringa in un'istanza di `String`. Per esempio:
```swift
let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..
Swift fornisce tre modi per confrontare valori testuali: l'uguaglianza di stringhe e caratteri, l'uguaglianza del prefisso e l'uguaglianza del suffisso.
### Uguaglianza di stringhe e caratteri
L'uguaglianza di stringhe e caratteri si verifica con l'operatore “uguale a” (`==`) e con l'operatore “diverso da” (`!=`), come descritto in [Operatori di confronto](/guida-al-linguaggio/operatori-di-base.md#operatori-di-confronto):
```swift
let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation {
print("These two strings are considered equal")
}
// Stampa "These two strings are considered equal".
```
Due valori `String` (o due valori `Character`) sono considerati uguali se i loro cluster di grafemi estesi sono *canonicamente equivalenti*. I cluster di grafemi estesi sono canonicamente equivalenti se hanno lo stesso significato linguistico e lo stesso aspetto, anche se dietro le quinte sono composti da scalari Unicode diversi.
Per esempio, `LATIN SMALL LETTER E WITH ACUTE` (`U+00E9`) è canonicamente equivalente a `LATIN SMALL LETTER E` (`U+0065`) seguita da `COMBINING ACUTE ACCENT` (`U+0301`). Entrambi questi cluster di grafemi estesi sono modi validi di rappresentare il carattere `é`, e quindi sono considerati canonicamente equivalenti:
```swift
// "Voulez-vous un café?" usando LATIN SMALL LETTER E WITH ACUTE
let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
// "Voulez-vous un café?" usando LATIN SMALL LETTER E e COMBINING ACUTE ACCENT
let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"
if eAcuteQuestion == combinedEAcuteQuestion {
print("These two strings are considered equal")
}
// Stampa "These two strings are considered equal".
```
Al contrario, `LATIN CAPITAL LETTER A` (`U+0041`, ovvero `"A"`), come si usa in inglese, *non* è equivalente a `CYRILLIC CAPITAL LETTER A` (`U+0410`, ovvero `"А"`), come si usa in russo. I caratteri sono visivamente simili, ma non hanno lo stesso significato linguistico:
```swift
let latinCapitalLetterA: Character = "\u{41}"
let cyrillicCapitalLetterA: Character = "\u{0410}"
if latinCapitalLetterA != cyrillicCapitalLetterA {
print("These two characters aren't equivalent.")
}
// Stampa "These two characters aren't equivalent."
```
{% hint style="info" %}
**Nota:** In Swift i confronti tra stringhe e caratteri non dipendono dalle impostazioni locali.
{% endhint %}
### Uguaglianza del prefisso e del suffisso
Per verificare se una stringa ha un particolare prefisso o suffisso, chiama i metodi `hasPrefix(_:)` e `hasSuffix(_:)` della stringa, che accettano entrambi un singolo argomento di tipo `String` e restituiscono un valore booleano.
Gli esempi seguenti considerano un array di stringhe che rappresentano i luoghi delle scene dei primi due atti di *Romeo e Giulietta* di Shakespeare:
```swift
let romeoAndJuliet = [
"Act 1 Scene 1: Verona, A public place",
"Act 1 Scene 2: Capulet's mansion",
"Act 1 Scene 3: A room in Capulet's mansion",
"Act 1 Scene 4: A street outside Capulet's mansion",
"Act 1 Scene 5: The Great Hall in Capulet's mansion",
"Act 2 Scene 1: Outside Capulet's mansion",
"Act 2 Scene 2: Capulet's orchard",
"Act 2 Scene 3: Outside Friar Lawrence's cell",
"Act 2 Scene 4: A street in Verona",
"Act 2 Scene 5: Capulet's mansion",
"Act 2 Scene 6: Friar Lawrence's cell"
]
```
Puoi usare il metodo `hasPrefix(_:)` con l'array `romeoAndJuliet` per contare il numero di scene dell'Atto 1 dell'opera:
```swift
var act1SceneCount = 0
for scene in romeoAndJuliet {
if scene.hasPrefix("Act 1 ") {
act1SceneCount += 1
}
}
print("There are \(act1SceneCount) scenes in Act 1")
// Stampa "There are 5 scenes in Act 1".
```
Analogamente, usa il metodo `hasSuffix(_:)` per contare il numero di scene che si svolgono all'interno o nei dintorni della dimora dei Capuleti e della cella di Frate Lorenzo:
```swift
var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet {
if scene.hasSuffix("Capulet's mansion") {
mansionCount += 1
} else if scene.hasSuffix("Friar Lawrence's cell") {
cellCount += 1
}
}
print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
// Stampa "6 mansion scenes; 2 cell scenes".
```
{% hint style="info" %}
**Nota:** I metodi `hasPrefix(_:)` e `hasSuffix(_:)` eseguono un confronto di equivalenza canonica carattere per carattere tra i cluster di grafemi estesi di ciascuna stringa, come descritto in [Uguaglianza di stringhe e caratteri](/guida-al-linguaggio/stringhe-e-caratteri.md#uguaglianza-di-stringhe-e-caratteri).
{% endhint %}
## Rappresentazioni Unicode delle stringhe
Quando una stringa Unicode viene scritta in un file di testo o in un altro supporto di memorizzazione, gli scalari Unicode di quella stringa vengono codificati in una delle diverse *forme di codifica* definite da Unicode. Ciascuna forma codifica la stringa in piccoli blocchi noti come *unità di codice*. Queste comprendono la forma di codifica UTF-8 (che codifica una stringa come unità di codice a 8 bit), la forma di codifica UTF-16 (che codifica una stringa come unità di codice a 16 bit), e la forma di codifica UTF-32 (che codifica una stringa come unità di codice a 32 bit).
Swift fornisce diversi modi per accedere alle rappresentazioni Unicode delle stringhe. Puoi iterare sulla stringa con un'istruzione `for`-`in`, per accedere ai suoi singoli valori `Character` come cluster di grafemi estesi Unicode. Questo processo è descritto in [Lavorare con i caratteri](/guida-al-linguaggio/stringhe-e-caratteri.md#lavorare-con-i-caratteri).
In alternativa, accedi a un valore `String` in una delle altre tre rappresentazioni conformi a Unicode:
* Una collezione di unità di codice UTF-8 (a cui si accede con la proprietà `utf8` della stringa)
* Una collezione di unità di codice UTF-16 (a cui si accede con la proprietà `utf16` della stringa)
* Una collezione di valori scalari Unicode a 21 bit, equivalente alla forma di codifica UTF-32 della stringa (a cui si accede con la proprietà `unicodeScalars` della stringa)
Ciascun esempio seguente mostra una diversa rappresentazione della stringa seguente, composta dai caratteri `D`, `o`, `g`, `‼` (`DOUBLE EXCLAMATION MARK`, ovvero lo scalare Unicode `U+203C`), e dal carattere 🐶 (`DOG FACE`, ovvero lo scalare Unicode `U+1F436`):
```swift
let dogString = "Dog‼🐶"
```
### Rappresentazione UTF-8
Puoi accedere a una rappresentazione UTF-8 di una `String` iterando sulla sua proprietà `utf8`. Questa proprietà è di tipo `String.UTF8View`, che è una collezione di valori a 8 bit senza segno (`UInt8`), uno per ciascun byte della rappresentazione UTF-8 della stringa:
```swift
for codeUnit in dogString.utf8 {
print("\(codeUnit) ", terminator: "")
}
print("")
// Stampa "68 111 103 226 128 188 240 159 144 182 ".
```
Nell'esempio qui sopra, i primi tre valori decimali di `codeUnit` (`68`, `111`, `103`) rappresentano i caratteri `D`, `o` e `g`, la cui rappresentazione UTF-8 è la stessa della loro rappresentazione ASCII. I tre valori decimali successivi di `codeUnit` (`226`, `128`, `188`) sono una rappresentazione UTF-8 a tre byte del carattere `DOUBLE EXCLAMATION MARK`. Gli ultimi quattro valori di `codeUnit` (`240`, `159`, `144`, `182`) sono una rappresentazione UTF-8 a quattro byte del carattere `DOG FACE`.
### Rappresentazione UTF-16
Puoi accedere a una rappresentazione UTF-16 di una `String` iterando sulla sua proprietà `utf16`. Questa proprietà è di tipo `String.UTF16View`, che è una collezione di valori a 16 bit senza segno (`UInt16`), uno per ciascuna unità di codice a 16 bit della rappresentazione UTF-16 della stringa:
```swift
for codeUnit in dogString.utf16 {
print("\(codeUnit) ", terminator: "")
}
print("")
// Stampa "68 111 103 8252 55357 56374 ".
```
Di nuovo, i primi tre valori di `codeUnit` (`68`, `111`, `103`) rappresentano i caratteri `D`, `o` e `g`, le cui unità di codice UTF-16 hanno gli stessi valori della rappresentazione UTF-8 della stringa (perché questi scalari Unicode rappresentano caratteri ASCII).
Il quarto valore di `codeUnit` (`8252`) è l'equivalente decimale del valore esadecimale `203C`, che rappresenta lo scalare Unicode `U+203C` del carattere `DOUBLE EXCLAMATION MARK`. Questo carattere può essere rappresentato come un'unica unità di codice in UTF-16.
Il quinto e il sesto valore di `codeUnit` (`55357` e `56374`) sono una rappresentazione tramite coppia surrogata UTF-16 del carattere `DOG FACE`. Questi valori sono un valore surrogato alto `U+D83D` (valore decimale `55357`) e un valore surrogato basso `U+DC36` (valore decimale `56374`).
### Rappresentazione come scalari Unicode
Puoi accedere a una rappresentazione come scalari Unicode di un valore `String` iterando sulla sua proprietà `unicodeScalars`. Questa proprietà è di tipo `UnicodeScalarView`, che è una collezione di valori di tipo `UnicodeScalar`.
Ogni `UnicodeScalar` ha una proprietà `value` che restituisce il valore a 21 bit dello scalare, rappresentato all'interno di un valore `UInt32`:
```swift
for scalar in dogString.unicodeScalars {
print("\(scalar.value) ", terminator: "")
}
print("")
// Stampa "68 111 103 8252 128054 ".
```
Le proprietà `value` dei primi tre valori `UnicodeScalar` (`68`, `111`, `103`) rappresentano ancora una volta i caratteri `D`, `o` e `g`.
Il quarto valore di `codeUnit` (`8252`) è di nuovo l'equivalente decimale del valore esadecimale `203C`, che rappresenta lo scalare Unicode `U+203C` del carattere `DOUBLE EXCLAMATION MARK`.
La proprietà `value` del quinto e ultimo `UnicodeScalar`, `128054`, è l'equivalente decimale del valore esadecimale `1F436`, che rappresenta lo scalare Unicode `U+1F436` del carattere `DOG FACE`.
In alternativa all'interrogazione delle loro proprietà `value`, ogni valore `UnicodeScalar` può anche essere usato per costruire un nuovo valore `String`, come con l'interpolazione di stringhe:
```swift
for scalar in dogString.unicodeScalars {
print("\(scalar) ")
}
// D
// o
// g
// ‼
// 🐶
```