Control Flow & Collection Flashcards Preview

SWIFT > Control Flow & Collection > Flashcards

Flashcards in Control Flow & Collection Deck (36):

Conditional statements (istruzioni condizionali)

Una dichiarazione condizionale esegue in determinate condizioni una certa porzione di codice. Ad esempio, è possibile eseguire un codice particolare quando si verifica un errore o visualizzare un messaggio quando un valore supera una determinata linea di base. Per impostare le condizioni, utilizzare le istruzioni if o switch 


The if Statement

The most basic if statement contains a single if condition, and executes a set of statements only if that condition is true:

var temp = 25
if temp <= 30 {
print("It's cold.")

You can specify additional conditions by chaining together multiple if statements.

if cardValue == 11 {
} else if cardValue == 12 {
else {
print("Not found")

You can add as many else-if statements as needed.


The switch Statement

Use the switch statement as an alternative to the if statement for multiple potential states. The switch statement compares a value with several possible matching patterns, executing a block of code using the first matching pattern.

Each case begins with the keyword case:

switch distance {
case 0:
print("not a valid distance")
case 1,2,3,4,5:
print("too far")

A single case can contain multiple values, as in our example above. It can also contain ranges, using the range operators.

Every switch statement must be exhaustive, i.e. take every possible value into consideration. In cases in which it is not appropriate to provide a switch case for every possible value, you can define a default catch-all case to cover any values that are not explicitly addressed. Indicate the catch-all case by using the keyword default. This always appears last.
Swift doesn't require break statements, but will still accept one to match and ignore a particular case, or to break out of a matched case before that case has completed its execution.



The where clause checks for additional conditions.

let myPoint = (1, -1)
switch myPoint {
case let (x, y) where x == y:
print("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
print("(\(x), \(y)) is on the line x == -y")
case let (x, y):
print("(\(x), \(y)) is just some arbitrary point")

The three switch cases declare placeholder constants x and y, which temporarily take on the two values from myPoint, creating a dynamic filter as part of a where clause. The switch case matches the current value of point only if the where clause's condition evaluates to true for that value.
The final case matches all possible remaining values; a default case is not necessary to have an exhaustive switch statement.


The while Loop

while loop performs a set of statements until a condition becomes false. These kinds of loops are best used when the number of iterations is not known before the first iteration begins.
while evaluates its condition at the start of each pass through the loop.

while a < b {

The code will execute until the a++ statement renders a < b as false.



The repeat-while loop is the alternate while loop. It first makes a single pass through the loop block, then considers the loop's condition, and repeats the loop until the condition shows as false.

repeat {
} while x > 0

Swift's repeat-while loop is similar to a do-while loop in other languages.


The for-in Loop


Use the for-in loop to iterate over a sequence, such as ranges of numbers, items in an array, or characters in a string.
The following example prints the first few entries in the five-times-table:

for index in 1...5 {
print("\(index) times 5 is \(index * 5)")
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

The index variable is set at the first value in the range (1). The statements within the for loop are then executed in sequence, through the final item in the range (5).


The for Loop

The for loop cycles through a set of statements until a specific condition is met. A typical for loop runs a counter at the end of each loop, and consists of three parts: counter initializationcondition, and increment:

for var index = 0; index < 3; ++index {
print("index is \(index)")

// index is 0
// index is 1
// index is 2

Semicolons are inserted to define the loop’s three parts.

The loop is executed as follows:
1. Upon entering the loop, the initialization expression is evaluated once, establishing the loop's constants and/or variables.
2. If the condition expression is found to be true when evaluated, the statements in braces are executed to continue code execution.
3. The increment expression is evaluated once all statements have been executed, and code execution returns to Step 2.

Constants and variables in the initialization expression (such as var index = 0) are only valid within the for loop itself. To retrieve the final value of index after the loop ends, you must declare index before the loop begins.


Control Transfer

Control transfer statements alter the code execution by transferring control from one piece of code to another. Swift's four control transfer statements are continue, break, fallthrough, and return




The continue statement stops the loop, then restarts it at the beginning of its next cycle. It says “I am done with the current loop iteration” without leaving the loop altogether.
The example below shows how to use the continue statement to skip over even numbers.

for num in 1...10 {
if num%2 == 0 {

A for loop with a condition and an incrementer still evaluates the incrementer after the continue statement is initiated. The loop itself continues to work as usual; only the code within the loop's body is skipped.



Use the break statement to immediately end the execution of an entire control flow statement. Also, the break statement is used within a switch statement or a loop statement to terminate its execution sooner than would otherwise be the case.


Break in a Loop Statement

When a break statement is used within a loop statement, the loop's execution immediately stops. Control transfers to the first line of code following the loop's closing brace (}). The current iteration's remaining code is skipped, and no further iterations of the loop are initiated.
For example, you can have a loop that breaks out when the value of a becomes less than that of b:
var b = 7
var a = 10
while a > 0 {
if(a < b) {


Break in a Switch Statement

A break causes a switch statement to end its execution immediately, and transfers control to the first line of code that follows the switch statement's closing brace (}).

var a = 5
var letter = "X"
switch a {
case 1:
letter = "A"
case 2:
letter = "B"

This example breaks out of the switch statement as soon as the default case is matched.
Always use a break statement to ignore a switch case.



In Swift, switch statements do not fall through the bottom of each case into the next. Instead, the entire switch statement completes its execution when the first matching case is completed.
By contrast, C requires insertion of an explicit break statement at the end of every switch case to prevent fallthrough. By eliminating default fallthrough, Swift allows for more concise and predictable switch statements in comparison with C, and thus avoids inadvertently executing multiple switch cases.

In cases that require C-style fallthrough behavior, use the fallthrough keyword on a case-by-case basis. The example below uses fallthrough to create a number's textual description.

let myInt = 5
var desc = "The number \(myInt) is"
switch myInt {
case 2, 3, 5, 7, 11, 13, 17, 19:
desc += " a prime number, and also"
desc += " an integer."

This prints "The number 5 is a prime number, and also an integer."

If myInt's value is one of the prime numbers in the list, text noting that the number is prime is appended to the end of the description. The fallthrough keyword then causes it to "fall into" the default case.
The fallthrough keyword does not check case conditions in the switch case into which execution falls. As with C’s standard switch statement behavior, the fallthrough keyword moves code execution directly to the statements inside the next (or default) case block.



Una stringa è un insieme ordinato di caratteri, come "Ciao, mondo" o "SoloLearn". Stringhe Swift sono rappresentate dal tipo String, che a sua volta rappresenta un insieme di valori di tipo carattere.

I valori stringa predefiniti possono essere inclusi nel codice come stringhe letterali, o sequenze fisse di caratteri testuali all'interno di virgolette doppie (""). Utilizzare una stringa letterale come valore iniziale per una costante o variabile.

let someString = "Some string literal value"

Poiché è inizializzato con un valore letterale di stringa, Swift deduce un tipo di String per la costante someString.


Empty Strings

Un valore di stringa vuota può essere creato come punto di partenza per una stringa più lunga. Per effettuare questa operazione, assegnare una stringa vuota letterale a una variabile o inizializzare una nuova istanza String utilizzando sintassi di inizializzazione:

var emptyString = "" // empty string literal
var anotherEmptyString = String() // initializer syntax

Entrambe le stringhe sono vuote e equivalenti tra loro.Determinare se un valore stringa è vuota controllando la sua proprietà booleana isEmpty:

if emptyString.isEmpty {
print("String is empty")



valori stringa possono essere sommati (o concatenati) con l'operatore di addizione (+) per creare un nuovo valore di stringa:

let string1 = "Hello"
let string2 = " World"
var welcome = string1 + string2
// welcome now equals "Hello World"

L'operatore di assegnazione addizione (+ =) aggiunge un valore String di una variabile stringa esistente

var msg = "Hi"
msg += " David"
// msg is now "Hi David"


String Interpolation

String interpolazione comprende i valori di un mix di costanti, variabili, letterali, e le espressioni all'interno di una stringa letterale per formare un nuovo valore Stringa. Precedere ogni elemento con una barra rovesciata, posizionare l'elemento tra parentesi, e inserirlo nella stringa letterale.

let mult = 4
let message = "\(mult) times 1.5 is \(Double(mult) * 1.5)"
// message is "4 times 1.5 is 6"

Nell'esempio precedente, il valore del moltiplicatore viene inserito nella stringa letterale come \ (mult). Quando l'interpolazione stringa viene valutata prima di creare la stringa effettiva, questo segnaposto viene sostituito con il valore effettivo di mult.
Più avanti nella stringa, il valore di mult appare all'interno di un'espressione più ampia all'interno della stringa letterale: \ (double(Mult) * 1.5). L'espressione calcola il valore della Double(mult) * 1.5 e quindi inserisce il risultato (6) nella stringa.


Counting Characters

Per ottenere un conteggio dei valori carattere di una stringa, utilizzare la proprietà conteggio della proprietà caratteri della stringa:

let someString = "I am learning with SoloLearn"
print("someString has \(someString.characters.count) characters")
// prints "someString has 28 characters"



Comparing Strings

Swift offre tre opzioni per il confronto dei valori testuali: stringa e il carattere di uguaglianza,prefix equality , e suffix equality.

Utilizzare l'operatore "equal to" (==) e il "not equal to" (! =) per determinare uguaglianza di stringa e di carattere.

Utilizzare metodi hasPrefix e hasSuffix della stringa per determinare se una stringa ha un particolare prefisso o suffisso di stringa. Entrambi i metodi adottano un solo argomento di tipo String e restituiscono un valore booleano.

let s1 = "We are alike"
let s2 = "We are alike"
if s1 == s2 {
print("These two strings are equal")
// prints "These two strings are equal"

Utilizzare metodi hasPrefix e hasSuffix della stringa per determinare se una stringa ha un particolare prefisso o suffisso di stringa. Entrambi i metodi adottano un solo argomento di tipo String e restituiscono un valore booleano



Un array è un elenco ordinato di valori dello stesso tipo, in cui lo stesso valore può apparire più volte in posizioni diverse. In Swift, il tipo di array può essere scritto in forma completa come Array , in cui T rappresenta il tipo valore dell'array consentito da memorizzare. Il tipo di array può anche essere espresso in forma abbreviata, come [T].


Creating an Empty Array


Creare un array vuoto di un certo tipo utilizzando la sintassi di inizializzazione.

var someInts = [Int]()

Si noti che il tipo di variabile someInts viene dedotta per essere [Int], dal tipo di inizializzatore.


Array with a Default Value

Array di Swift fornisce anche un inizializzatore per la creazione di una array di una certa dimensione, con tutti i suoi valori impostati allo stesso valore predefinito. Si può passare a questa inizializzazione il numero di elementi da aggiungere al nuovo array (chiamato count) e un valore di default del tipo appropriato (chiamato repeatedValue)

var fourDoubles = [Double](count: 4, repeatedValue: 0.0)
fourDoubles is of type [Double], and equals [0.0, 0.0, 0.0, 0.0]



Array Literal

Utilizzare un array letterale è un altro modo per inizializzare un array. L'array letterale è un'abbreviazione per uno o più valori scritti come collezione di array, ed è scritto come un elenco di valori, separati da virgole, parentesi quadre all'inizio e alla fine. [value 1, value 2, value 3]
The example below creates an array called shoppingList, for storing String values:

var shoppingList: [String] = ["Bread", "Milk"]

Questo particolare array può memorizzare solo valori stringa, poichè ha String specificato come tipo di valore. A causa di inferenza di tipo di Swift, non c'è bisogno di scrivere il tipo di array. Assicurarsi di inizializzare un array letterale contenente valori della stessa tipologia. L'inizializzazione di ShoppingList sarebbe potuto essere scritto in una forma più breve:

var shoppingList = ["Bread", "Milk"]

Tutti i valori nella matrice letterale sono dello stesso tipo, consentendo a Swift di dedurre che [String] è il typo corretto per la variabile shoppingList

La combinazione di due array esistenti con tipi compatibili utilizzando l'operatore di addizione (+) consente di creare un nuovo array. Swift deduce il type della nuova matrice in base al type dei due array combinati.


Accessing and Modifying an Array


Accedi e modifica un array attraverso i suoi metodi e proprietà o utilizzando subscript syntax.

An array's read-only count property provides the number of items in an array.

print("The shopping list contains \(shoppingList.count) items.")
// prints "The shopping list contains 2 items."


Utilizzare la proprietà booleana isEmpty come scorciatoia quando si desidera sapere se la proprietà conteggio è uguale a 0.

if shoppingList.isEmpty {
print("The shopping list is empty.")
} else {
print("The shopping list is not empty.")
// prints "The shopping list is not empty."


Modifying an Array 1


il metodo append di un array consente di aggiungere un nuovo elemento alla fine dell'array.


In alternativa, aggiungere un array di uno o più elementi compatibili con l'operatore di assegnazione addizione (+ =):

shoppingList += ["Juice"]
shoppingList += ["Chocolate", "Cheese"]


Accessing an Array


Utilizzando subscript syntax, è possibile recuperare un valore dalla array, inserendo l'indice del valore che si desidera recuperare tra parentesi quadre subito dopo il nome della array:

var firstItem = shoppingList[0]

Gli array in Swift sono sempre zero-indicizzati, il che significa che l'indice del primo elemento è 0, invece di 1, come ci si potrebbe aspettare. Accedere o modificare un valore di un indice che è fuori dai limiti attuali di una array, attiva un errore di runtime. Controllare la validità di un indice prima di utilizzarlo attraverso il confronto con la proprietà conteggio della array.


Modifying an Array 2

Utilizzare la subscript syntax per modificare un valore esistente in un determinato indice.

shoppingList[0] = "Two apples"

Subscript syntax cambia anche un intervallo di valori tutti in una volta. Questo funziona anche con un set di sostituzione di valori con una lunghezza che è differente dall'intervallo originale. Nel seguente esempio, gli elementi con indice 4, 5, 6 sono sostituiti con due nuovi valori.

shoppingList[4...6] = ["Bananas", "Oranges"]

Non utilizzare la subscript syntax per aggiungere un nuovo elemento a un array.


Modifying an Array 3


Un metodo d'inserimento di un array (atIndex) inserisce un elemento nell'array in corrispondenza di un indice specificato.

shoppingList.insert("Syrup", atIndex: 0)

"Syrup" is now the first item in the list.

Allo stesso modo, il metodo removeAtIndex consente di rimuovere un elemento dalla array. Questo metodo rimuove l'elemento all'indice specificato e restituisce anche l'elemento rimosso. Si noti che il valore restituito può essere ignorato se non è necessario.

let syrup = shoppingList.removeAtIndex(0)

Quando un elemento viene rimosso da un array, Swift chiude le lacune che sono state create

Se si desidera rimuovere l'elemento finale da un array, utilizzare il metodo removeLast () piuttosto che il metodo removeAtIndex per evitare la necessità di richiamare la proprietà calcolo della array:

let apples = shoppingList.removeLast()
// the last item has just been removed


Iterating Over an Array


Il ciclo for-in consente di iterare l'intero set di valori in un array.

for item in shoppingList {

In alternativa, utilizzare il metodo enumerate () per iterare in una array quando è necessario l'indice intero per ogni elemento oltre al suo valore. Questo restituisce un tuple per ogni elemento dell'array che indica l'indice e il valore di quell'elemento. È possibile scomporre la tuple in costanti o variabili temporanee come parte di iterazione:

for (index, value) in shoppingList.enumerate() {
print("Item \(index + 1): \(value)")

Questo stampa l'indice e il valore degli elementi nell'array.



Un set memorizza valori distinti dello stesso tipo in un insieme senza ordine definito. Gli insiemi sono utilizzati come alternativa agli array quando l'ordine degli elementi non è una preoccupazione o quando è necessario assicurare che un elemento appaia solo una volta. Per un set di Swift, scrivere il type come un Set , dove T è il type che nel set è consentito di memorizzare. A differenza degli array, non c'è scorciatoia equivalente per i set.

È possibile creare un insieme vuoto di un certo tipo utilizzando la sintassi di inizializzazione. In base al tipo di inizializzazione, Swift deduce il typo delle lettere in modo che sia Set

var letters = Set()

Un array letterale funziona anche come abbreviazione quando si inizializza un set con uno o più valori come un set di raccolta.

var names: Set = ["David", "Susan", "Robert"]

Durante l'inizializzazione del tipo di set con un array letterale che contiene i valori dello stesso tipo, non è necessario scrivere il type del set. L'inizializzazione potrebbe essere scritta in una forma più breve:

var names: Set = ["David", "Susan", "Robert"]

Poiché tutti i valori nella array letterale sono dello stesso tipo, Swift ne deduce che Set è il tipo corretto da utilizzare per i nomi della variabile.


Accessing and Modifying a Set

Le proprietà count e isEmpty funzionano allo stesso modo con un set come fanno con un array. Richiamare il metodo di inserimento del set, aggiunge un nuovo elemento a un set.


È possibile rimuovere un elemento da un set richiamando il metodo di rimozione del set. L'elemento viene rimosso se è un elemento del set e il valore rimosso viene restituito. Esso restituisce nil se l'elemento non è contenuto nel set. In alternativa, utilizzare il metodo removeAll () del set per rimuovere tutti gli elementi in un set.



Il dizionario archivia associazioni tra le key dello stesso tipo ed i valori dello stesso tipo, in una collezione con nessun ordinamento definito. Ogni valore è associato ad una key univoca, che agisce come un identificatore per quel valore all'interno del dizionario. Un dizionario è utilizzato per cercare i valori in base ai loro identificatori, più o meno allo stesso modo in cui un dizionario del mondo reale viene utilizzato per cercare la definizione di una particolare parola.Scritto nella sua interezza, un tipo di dizionario Swift è Dictionary . Key indica quale tipo di valore può essere utilizzato come chiave del dizionario, e Value indica quale tipo di valori il dizionario archivia per quelle chiavi. La forma abbreviata per il type di un dizionario è [Key: Value].Come con gli array, un inizializzatore di sintassi viene usato per creare un dizionario vuoto di un tipo specificato:

var airports = [Int: String]()



The Dictionary Literal


Un dizionario letterale fornisce un modo per scrivere in forma abbreviata una o più coppie key-value come raccolta del dizionario.La chiave e il valore in ciascuna coppia di valori-chiave sono separati da due punti. Le coppie di valori-chiave sono scritti come una lista, separati da una virgola, circondate da una coppia di parentesi quadre.

L'esempio che segue crea un dizionario in cui le chiavi sono i codici di tre lettere, ed i valori sono nomi per l'aeroporto:

var airports: [String: String] = ["TOR": "Toronto", "NY": "New York"]​

Poiché tutte le chiavi e valori nel dizionario letterale condividono lo stesso type, Swift può dedurre che [String: String] è il type corretto da utilizzare per il dizionario aeroporti.

var airports = ["TOR": "Toronto", "NY": "New York"]



Accessing and Modifying a Dictionary


Le proprietà count e isEmpty si possono utilizzare anche per il dizionario.

airports["LHR"] = "London"

Subscript syntax può essere usato per cambiare il valore associato a una particolare key:

airports["LHR"] = "London Heathrow"
// the value for "LHR" has been changed

Utilizzare il metodo UpdateValue di un dizionario come alternativa all'indicizzazione di quando si imposta o aggiorna il valore di una chiave. Il metodo UpdateValue restituisce il vecchio valore dopo l'esecuzione di un aggiornamento:

let oldValue = airports.updateValue("New York", forKey: "NY")

Subscript syntax viene utilizzato anche per recuperare un valore per una particolare chiave dal dizionario. Se il valore per la chiave richiesta non esiste, Swift restituisce un valore nil (zero):

let airportName = airports["NY"]​

Utilizzare subscript syntax per assegnare un valore nil a una key per rimuovere una coppia key-value da un dizionario.

airports["APL"] = "Apple"
airports["APL"] = nil

In alternativa, il metodo removeValueForKey rimuove una coppia key-value da un dizionario, se la coppia esiste, e restituisce il valore rimosso. nil viene restituito se non esiste alcun valore.

if let removedValue = airports.removeValueForKey("NY") {
print("The removed airport's name is \(removedValue).")
} else {
print("The airports dictionary does not contain a value for NY.")





Iterating Over a Dictionary

Utilizzare un ciclo for-in per scorrere le coppie key-value in un dizionario. Ogni elemento nel dizionario viene restituito come una (key, value) tuple, che si può scomporre in costanti o variabili temporanee come parte di iterazione.

for (airportCode, airportName) in airports {
print("\(airportCode): \(airportName)")

Inoltre, l'accesso a proprietà delle chiavi e valori di un dizionario richiamerà una collezione iterabile di chiavi o valori del dizionario.

for airportCode in airports.keys {
print("Airport code: \(airportCode)")

for airportName in airports.values {
print("Airport name: \(airportName)")

Dal momento che il Dizionario di Swift non ha un ordinamento definito, utilizzare il metodo sort () sulle proprietà di key o values del dizionario per iterare le chiavi o valori in un ordine specifico.