Il segno di b viene ignorato per quanto riguarda i valori negativi. questo significa che % b e % -b danno lo stesso risultato.


CALCOLO DEL RESTO NEI NUMERI A VIRGOLA MOBILE
A differenza degli operatori di resto in C e Objective-C, in Swift possono operare anche con i numero in virgola mobile:

8 % 2.5 // equals 0.5

In questo esempio, 8 diviso 2.5 uguale a 3, con un resto di 0.5 , infatti l’operatore resto restituisce un valore double di 0.5.

OPERATORI DI INCREMENTO E DECREMENTO

Come in C, Swift prevede un operatore di incremento (++) e uno di decremento (–) come “scorciatoia” per incrementare o decrementare il valore di una variabile di 1. Questi operatori si possono utilizzare con variabili contenenti numeri in virgola fissa oppure in virgola mobile.

var i = 0
++i // i now equals 1

Ogni volta che si utilizza ++i, il valore di i viene incrementato di 1. Essenzialmente utilizzare ++i è un modo più veloce di scrivere  i = i + 1. Allo stesso modo, –i viene utilizzato alternativamente a  i = i – 1.

I simboli ++ e — possono essere utilizzati come operatori di prefisso oppure di suffisso. ++i e i++ sono entrambi validi per incrementare un valore di 1. Similmente, –i e i– sono entrambi validi per decrementare un valore di 1.

Da notare che gli operatori, oltre a modificare il valore di i, restituiscono il nuovo valore assegnato ad i. Se vuoi solamente incrementare o decrementare il valore memorizzato in i, senza restituirlo come risultato, puoi semplicemente ignorare il valore restituito. Comunque, se vorrai utilizzare il valore restituito dall’operatore, quest’ultimo sarà diverso in base al modo in cui avrai utilizzato lo stesso:

Se l’operatore è posto prima della variabile, la variabile viene incrementata PRIMA di restituire il valore.
Se l’operatore è posto dopo la variabile, la stessa verrà incrementata subito dopo la restituzione del valore.
Ecco un esempio:

var a = 0
let b = ++a
// a and b are now both equal to 1
let c = a++
// a is now equal to 2, but c has been set to the pre-increment value of 1

In questo esempio, let b = ++a incrementa a PRIMA di restituire il valore.

Invece, let c = a++ incrementa a DOPO la restituzione del valore risultante. Questo comporta che c prende il vecchio valore 1, mentre a viene portata a 2.

E’ consigliabile di utilizzare sempre ‌‌++i o –1, così il valore restituito sarà già incrementato e la possibilità di errore è ridotta al minimo.

OPERATORIO UNARIO NEGATIVO
Il segno di un valore numerico può essere indicato come negativo anteponendo il segno -:

let three = 3
let minusThree = -three // minusThree equals -3
let plusThree = -minusThree // plusThree equals 3, or “minus minus three

Il segno (-) deve essere inserito subito prima del valore, senza spazio.


OPERATORE UNARIO POSITIVO
L’operatore unario positivo (+) restituisce semplicemente il valore, senza modifiche:

let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix equals -6
Although the unary plus operator doesn’t actually do anything, you can use it to provide symmetry in your code for positive numbers when also using the unary minus operator for negative numbers.


OPERATORI DI ASSEGNAZIONE
Come in C, Swift prevede la combinazione di (=) con altri operatori. Un esempio è l’operatore di addizione(+=):

var a = 1
a += 2
// a is now equal to 3

L’espressione a += 2 è un modo breve di scrivere a = a + 2. In poche parole, con un solo comando si esegue l’operazione di addizione e di assegnamento del valore.

Questi operatori di assegnamento non restituiscono alcune valore. Non puoi infatti scrivere, ad esempio,  let b = a += 2.

OPERATORI DI COMPARAZIONE
Swift supporta tutti gli operatori di comparazione presenti in C:

Equal to (a == b)
Not equal to (a != b)
Greater than (a > b)
Less than (a < b)
Greater than or equal to (a >= b)
Less than or equal to (a <= b)

Tutti gli operatori di comparazione restituiscono un valore booleano che può indicare solamente se la comparazione è fondata o meno:

1 == 1 // true, because 1 is equal to 1
2 != 1 // true, because 2 is not equal to 1
2 > 1 // true, because 2 is greater than 1
1 < 2 // true, because 1 is less than 2
1 >= 1 // true, because 1 is greater than or equal to 1
2 <= 1 // false, because 2 is not less than or equal to 1

Gli operatori di comparazione sono molto utilizzati, ad esempio, nei cicli IF:

let name = “world”
if name == “world” {
println(“hello, world”)
} else {
println(“I’m sorry \(name), but I don’t recognize you”)
}
// prints “hello, world”, because name is indeed equal to “world”

 

OPERATORI TERNARI CONDIZIONALI
Gli operatori ternari condizionali sono degli operatori composti da 3 parti, nella forma: domanda ? risposta1 : risposta2. E’ un modo veloce per sapere se una domanda restituirà true, quindi la prima risposta, oppure in caso di false la seconda.

Un esempio:

if question {
answer1
} else {
answer2
}

In quest’ultimo esempio, calcoliamo l’altezza di una tabella. L’altezza della riga della tabella deve essere 50 pixels più grande della larghezza, se la tabella ha un header, oppure 20 se non è presente un header:

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90

Questo è un modo breve di scrivere il seguente codice:

let contentHeight = 40
let hasHeader = true
var rowHeight = contentHeight
if hasHeader {
rowHeight = rowHeight + 50
} else {
rowHeight = rowHeight + 20
}
// rowHeight is equal to 90

Nel primo esempio viene utilizzato l’operatore ternario, utilizzando una singola riga di codice.

Una controindicazione nell’utilizzo degli operatori ternari è la complessità nella lettura del codice magari in un momento successivo al suo sviluppo, in quanto il tutto è scritto in modo più sentito e conciso.

OPERATORI DI RANGE
Swift include due operatori per il range: chiuso e semichiuso.


Operatore chiuso
L’operatore di range chiuso (a…b) definisce un range da a fino a b, includendo sia a che b.

Questo va chiaramente utilizzato quando in un range si vogliono includere anche i valori agli estremi:

for index in 1…5 {
println(“\(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


Operatore semichiuso
L’operatore semochiuso (a..b) include nel range il valore inziale (quindi in questo caso a) ma non il valore all’estremo finale, cioè b).

L’operatore semichiuso è utile quando si lavora con liste (array) e si devono contare le posizioni dei valori contenuti in questo array, partendo dal primo, che naturalmente sarà contrassegnato con 0 (zero):

let names = [“Anna”, “Alex”, “Brian”, “Jack”]
let count = names.count
for i in 0..count {
println(“Person \(i + 1) is called \(names[i])”)
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

Notare che l’array dell’esempio precedente contiene 4 valori, il primo contrassegnato con la posizione 0 e l’ultimo in posizione 3, si utilizza quindi l’operatore semichiuso.


Operatori logici
Gli operatori logici lavorano con i valori booleani true o false (vero o falso). Swift supporta gli operatori logici base presenti in C:

Logical NOT (!a)
Logical AND (a && b)
Logical OR (a || b)

Operatore NOT
L’operatore NOT (!a) Inverte i valori booleani, se l’entrata è TRUE l’uscita sarà FALSE e viceversa.

L’operatore NOT va anteposto al valore, senza spazi, è può essere letto come NON A (!a). Ecco un esempio:

let allowedEntry = false
if !allowedEntry {
println(“ACCESS DENIED”)
}
// prints “ACCESS DENIED”

La frase !allowedEntry Può essere letta come “Se l’accesso non è consentito.”


L’operatore logico AND

L’operatore AND (a && b) prevede che entrambe i valori (a,b) devono essere TRUE per restituire il valore boolean TRUE.

Se una delle due alternative è FALSE, il risultato sarà FALSE. Infatti, se la prima entrata è FALSE, la seconda non viene nemmeno controllata, in quanto l’algoritmo è già al corrente che l’uscita sarà FALSE.

Questo esempio prende in considerazione due valori booleani e consente l’accesso solamente se entrambi i valori sono TRUE:

let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
println(“Welcome!”)
} else {
println(“ACCESS DENIED”)
}
// prints “ACCESS DENIED”

Operatore logico OR
L’operatore logico OR (a || b) è un operatore INFIX (cioè non è posto ne prima ne dopo un valore ma nel mezzo di due entrate) e viene rappresentato da due linee verticali. In questo caso basta che una delle due entrate sia vera (TRUE) per far si che l’intera espressione risulti verificata.

Come l’operatore AND, L’operatore OR può utilizzare un metodo di verifica “breve”. Se l’entrata a sinisistra (quindi la prima entrata) è TRUE, la seconda entrata non viene verificata, in quanto sappiamo a priori che il risultato dell’espressione sarà TRUE.

In questo esempio, la prima entrata è FALSE, la seconda TRUE. Visto che un’entrata è TRUE, l’espressione restituirà TRUE e l’accesso verrà garantito:

let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
println(“Welcome!”)
} else {
println(“ACCESS DENIED”)
}
// prints “Welcome!


Combinazioni di operatori logici
Gli operatori logici possono essere compilati per creare espressioni più complesse:

if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
println(“Welcome!”)
} else {
println(“ACCESS DENIED”)
}
// prints “Welcome!”

In questo esempio vengono usati && e || per creare un’unica espressione, anche se gli operatori lavorano con 2 valori per volta. Può essere letto come:

Se abbiamo inserito il codice corretto e abbiamo passato lo scan della retina; oppure se abbiamo inserito un codice corretto; oppure se conosciamo la password per il reset del codice, l’accesso sarà garantito.


Parentesi esplicite
Può essere utile inserire nelle parentesi anche quando non sarebbero normalmente richieste,per rendere meglio leggibile un’espressione. Ad esempio possiamo riscrivere l’esempio precedente come:

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
println(“Welcome!”)
} else {
println(“ACCESS DENIED”)
}
// prints “Welcome!

 

Il risultato non cambia ma l’espressione è sicuramente più semplice da leggere ed interpretare.

Mancano poche pagine alla fine di questo capitolo!

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