È possibile mantenere un indice in un ciclo, sia utilizzando “..” per specificare un range di valori, oppure scrivendo un’inizializzazione esplicita, una condizione e un incremento. Ad esempio, questi due cicli producono il medesimo risultato:

var Ciclo = 0
for i in 0..3 {
    Ciclo += i
}
Ciclo

var AltroCiclo = 0
for var i = 0; i < 3; ++i {
    AltroCiclo += 1
}
AltroCiclo

 

Utilizzare “.. “per specificare un intervallo che non comprende il suo valore massimo (ad esempio 1..5 va da 1 a 4) , e con “…” un intervallo che include anche l’ultimo valore specificato.

FUNZIONI

Utilizzare func per dichiarare una funzione. Si può chiamare una funzione facendo seguire al suo nome una lista di argomenti racchiusi in parentesi. Usa > per separare i nomi dei parametri dal tipo di dato.

func saluti(nome: String, data: String) -> String {
    return “Ciao \(nome), oggi è \(data).”
}
saluti(“luca”, “Domenica”)

 

Utilizzare una tupla per ottenere diversi valori a partire da una funzione :

func PrezzoBenzina() -> (Double, Double, Double) {
    return (1.80, 1.76, 1.89)
}
getPrezzoBenzina()

 

Le funzioni possono anche prendere un numero variabile di argomenti, raccogliendoli in un array:

func somma(numero: Int…) -> Int {
var sum = 0
for numero in numeri {
    sum += numero
}
    return somma
}
sumOf()
sumOf(41, 456, 22)

 

Le funzioni possono essere nidificate. Funzioni nidificate hanno accesso a variabili che sono state dichiarate nella funzione esterna. È possibile utilizzare le funzioni nidificate per organizzare il codice quando la funzione è molto lunga o complessa:

func return quindici() -> Int {
var y = 9
func addiziona() {
    y += 6
}
add()
    return y
}
returnQuindici()

 

Le funzioni sono un tipo di prima classe. Ciò significa che possono restituire un’altra funzione come valore:

func incrementa() -> (Int -> Int) {
func AggiungiUno(number: Int) -> Int {
    return 1 + numero
}
    return AggiungiUno
}
var incrmeento = incrementa()
incremento(11)

 

Inoltre una funzione può avere un’altra funzione come suo valore:

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
for item in list {
if condition(item) {
    return true
    }
}
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, lessThanTen)

 

Potete utilizzare una funzione senza assegnargli un nome, includendo il codice tra parentesi graffe ({}):

numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})

Sono disponibili diverse opzioni per la scrittura delle funzioni nel modo più coinciso possibile. Quando il tipo di chiusura è già noto, come il callback di un delegato, è possibile omettere il tipo dei suoi parametri, il tipo restituito, o entrambi.

numeri.map({ numero in 3 * numero })

È possibile far riferimento ai parametri per numero anziché per nome, questo approccio è particolarmente utile in funzioni relativamente brevi:

sort([1, 5, 3, 12, 2]) { $0 > $1 }

 

OGGETTI E CLASSI

Per creare una classe, utilizzare class seguito dal nome che si vuole assegnare. Una dichiarazione di proprietà in una classe viene scritta nello stesso modo di una dichiarazione di costanti o variabili. Allo stesso modo funziona per le dichiarazioni di metodo e di funzione:

class Figura {
    var numeridiAngoli = 0
    func DescrizioneSemplice() -> String {
    return “Una figura con \(NumeroDiLati) lati.”
    }
}

Per creare un’istanza di una classe basta metterla tra parentesi dopo il nome della classe stessa. Utilizzare la sintassi del punto per accedere alle proprietà e ai metodi di istanza.

var figura = figura()
shape.numberOfSides = 9
var shapeDescription = shape.simpleDescription()

In questa versione della classe Shape manca qualcosa di importante: un inizializzatore per richiamare la classe quando viene creata un’istanza. Utilizzare init per creare uno :

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

    init(name: String) {
        self.name = name
    }

func simpleDescription() -> String {
    return “A shape with \(numberOfSides) sides.”
    }
}

Notate come self viene utilizzato per distinguere la proprietà name dal nome dell’inizializzatore. Gli argomenti di inizializzazione vengono passati come una chiamata di funzione quando si crea un’istanza della classe. Ogni proprietà ha bisogno di un valore assegnato, sia nella sua dichiarazione (come con NumberOfSides) o nell’inizializzatore (come nome).

Usa deinit per creare un “deinizializzatore” nel caso in cui ci sia bisogno di “pulire” la memoria prima che un qualsiasi oggetto venga deallocato.

Le sottoclassi, dopo il loro nome,  includono quello delle loro classi superiori, separati da due punti.

I metodi nelle sottoclassi che ignorano le classi superiori sono contrassegnati come override: ignorare un metodo per sbaglio, senza override, è visto come un errore dal compilatore. Il compilatore inoltre riconosce i metodi che implementano l’override senza ignorare nessun metodo nella classe superiore.

class Square: NamedShape {
    var sideLength: Double

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }

    func area() -> Double {
    return sideLength * sideLength
}

override func simpleDescription() -> String {
    return “A square with sides of length \(sideLength).”
    }
}
let test = Square(sideLength: 5.2, name: “my test square”)
test.area()
test.simpleDescription()

Oltre alle proprietà semplici che vengono memorizzate, queste possono avere un getter e setter.

class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
}

var perimeter: Double {
get {
    return 3.0 * sideLength
}
set {
    sideLength = newValue / 3.0
}

}

override func simpleDescription() -> String {
    return “An equilateral triagle with sides of length \(sideLength).”
    }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: “a triangle”)
triangle.perimeter
triangle.perimeter = 9.9
triangle.sideLength

 

Continueremo nella parte 3 di 3 fino al prossimo capitolo, dove inizieremo il vero e proprio corso di swift, partendo dalle basi.

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