Concatenare stringhe e caratteri
Stringhe e caratteri possono essere concatenati tra di loro utilizzando l’operatore di addizione (+) andando a creare quindi una nuova stringa:

let string1 = “hello”
let string2 = ” there”
let character1: Character = “!”
let character2: Character = “?”

 

let stringPlusCharacter = string1 + character1 // equals “hello!”
let stringPlusString = string1 + string2 // equals “hello there”
let characterPlusString = character1 + string1 // equals “!hello”
let characterPlusCharacter = character1 + character2 // equals “!?”

Puoi anche aggiungere una stringa o un carattere ad una stringa già esistente, utilizzando l’operatore (+=):

var instruction = “look over”
instruction += string2
// instruction now equals “look over there”

var welcome = “good morning”
welcome += character1
// welcome now equals “good morning!

Interpolazione delle stringhe
L’interpolazione delle stringhe è un modo per costruire una nuova stringa da un insieme di espressioni, variabili, costanti includendo i loro valori all’interno di una stringa unica. Ogni valore che inserisci nella nuova stringa va incluso tra parentesi e fatto precedere da un backslash:

let multiplier = 3
let message = “\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)”
// message is “3 times 2.5 is 7.5

In questo esempio, il valore di multiplier è inserito nella stringa in questo modo: \(multiplier).

Il valore del moltiplicatore è anche parte di un’espressione seguente, sempre nella stessa stringa. Questa espressione calcola il valore di doppia (moltiplicatore) * 2.5 e inserisce il risultato (7.5) nella stringa. In questo caso, l’espressione viene scritta come \ (doppia (moltiplicatore) * 2.5) .

Comparazione di stringhe

Swift fornisce 3 metodi di comparazione per le stringhe: string equality, prefix equality, and suffix equality.


String Equality
Due stringhe vengono considerate uguali se contengono gli stessi valori, esattamente nello stesso ordine:

let quotation = “We’re a lot alike, you and I.”
let sameQuotation = “We’re a lot alike, you and I.”
if quotation == sameQuotation {
println(“These two strings are considered equal”)
}
// prints “These two strings are considered equal”

 


Prefix and Suffix Equality

Per verificare se una stringa ha un particolare prefisso o suffisso, si usano i metodi hasPrefix e hasSuffix, entrambi i quali prendono un singolo argomento di tipo String e restituiscono un valore booleano. Entrambi i metodi eseguono un confronto carattere per carattere tra la stringa di base e la stringa di prefisso o suffisso.

Gli esempi che seguono considerano un array di stringhe che rappresentano le scene dei primi due atti di Romeo e Giulietta di Shakespeare:

“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 nell’atto1:

var act1SceneCount = 0
for scene in romeoAndJuliet {
if scene.hasPrefix(“Act 1 “) {
++act1SceneCount
}
}
println(“There are \(act1SceneCount) scenes in Act 1”)
// prints “There are 5 scenes in Act 1

 

Similmente,puoi utilizzare il metodo hasSuffix per contare per contare il numero di scene che prendono parte nella dimora Capuleti e nella Friar Lawrence’s cell:

var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet {
if scene.hasSuffix(“Capulet’s mansion”) {
++mansionCount
} else if scene.hasSuffix(“Friar Lawrence’s cell”) {
++cellCount
}
}
println(“\(mansionCount) mansion scenes; \(cellCount) cell scenes”)
// prints “6 mansion scenes; 2 cell scenes


Uppercase and Lowercase (MAIUSCOLO e minuscolo)
Puoi richiamare una stringa in maiuscolo o minuscolo con le proprietà uppercaseString and lowercaseString :

 

let normal = “Could you help me, please?”
let shouty = normal.uppercaseString
// shouty is equal to “COULD YOU HELP ME, PLEASE?”
let whispered = normal.lowercaseString
// whispered is equal to “could you help me, please?”

Unicode
Unicode è un sistema internazionale e universale utilizzato per rappresentare i caratteri che compongono un qualsiasi testo. Permette di scrivere qualsiasi carattere di qualsiasi lingua in forma standardizzata, e di leggere e scrivere questi caratteri da fonti esterne, ad esempio una pagina web.

In Swift tutte le stringhe e i caratteri sono compatibili con Unicode. Swift supporta diverse codifiche Unicode, come vediamo qui si seguito.

 

Terminologia Unicode
Ogni carattere in Unicode può essere rappresentato da uno o più scalari (numeri). Uno scalare in Unicode è rappresentato da un numero a 21 bit e un nome, come ad esempio U+0061 for per la lettera minuscola (“a”), oppure U+1F425 per l’emoticon della paperella (“emoticon”).

Quando una stringa Unicode viene scritta in un file di testo o altrove, questi scalari sono codificati in uno tra i  diversi standard Unicode. Ogni formato codifica le stringhe in parti, chiamate code units. Queste includono il formato UTF-8  (che codifica le stringhe in unità da 8 bit) e il formato UTF-16  (che codifica le stringhe in unità da 16 bit).


Rappresentazione delle stringhe in unicode
Swift prevede strade diverse per accedere ai caratteri unicode presenti nelle stringhe.

You can iterate over the string with a for-in statement, to access its individual Character values as Unicode characters. This process is described in Working with Characters.

Alternatively, access a String value in one of three other Unicode-compliant representations:

A collection of UTF-8 code units (accessed with the string’s utf8 property)
A collection of UTF-16 code units (accessed with the string’s utf16 property)
A collection of 21-bit Unicode scalar values (accessed with the string’s unicodeScalars property)

UTF-8
Puoi accedere ad un carattere in UTF-8 presente in una stringa con la proprietà utf8 . Questa proprietà è del tipo UTF8View, che rappresenta un insieme di valori 8-bit (UInt8) senza segno, uno per byte:

for codeUnit in dogString.utf8 {
print(“\(codeUnit) “)
}
print(“\n”)
// 68 111 103 33 240 159 144 182

 

 

Nell’esempio precedente, i primi quattro valori decimali (68, 111, 103, 33) rappresentano i caratteri D, o, g, e!, La cui rappresentazione UTF-8 è la stessa della loro rappresentazione ASCII. Gli ultimi quattro valori (240, 159, 144, 182) sono quattro byte UTF-8 e rappresentano l’emoticon del cagnolino.
UTF-16
È possibile accedere a una rappresentazione UTF-16 di una stringa mediante iterazione sulla sua struttura utf16. Questa proprietà è di tipo UTF16View, che rappresenta un insieme di valori senza segno a 16 bit (UInt16), uno per ogni unità di codice a 16 bit in UTF-16, la rappresentazione della stringa:

for codeUnit in dogString.utf16 {
print(“\(codeUnit) “)
}
print(“\n”)
// 68 111 103 33 55357 56374

Ancora un volta, i primi valori (68, 111, 103, 33) rappresentano i caratteri D, o, g, and !.

VOLETE ESSERE AGGIORNATI TEMPESTIVAMENTE ALL’USCITA DI UN NUOVO CAPITOLO ? BASTA UN LIKE SULLA NOSTRA PAGINA FACEBOOK!