chiusura Swift

Chiusure (chiusure) è un blocco autonomo funzionale del codice, è possibile utilizzare o essere utilizzata come valore di parametro nel codice.

chiusure Swift in C e blocchi di codice Objective-C (blocchi) e di alcuni altri linguaggi di programmazione funzione anonima è abbastanza simile.

funzioni globali e le funzioni annidate è in realtà una chiusura speciale.

Chiusura del modulo:

chiusure Swift hanno un sacco di posti di ottimizzazione:

1. A seconda del tipo di parametro contesto infer e valore di ritorno
2. Da una sola linea di chiusura espressione rendimento implicito (cioè, il corpo di chiusura è solo una riga di codice, è possibile omettere ritorno)
3. Può essere utilizzato per semplificare il nome del parametro, ad esempio $ 0, $ 1 (da 0, indicando che l'argomento i-th ...)
4. Fornire la sintassi di chiusura finale (sintassi chiusura Trailing)

grammatica

Di seguito definisce un parametro di ricezione e restituisce il tipo specificato di sintassi di chiusura:

{(parameters) -> return type in
   statements
}

Esempi

import Cocoa

let studname = { print("Swift 闭包实例。") }
studname()

L'output sopra l'esecuzione del programma è il seguente:

Swift 闭包实例。

Il seguente modulo chiusure accetta due parametri e restituisce un valore booleano:

{(Int, Int) -> Bool in
   Statement1
   Statement 2
    ---
   Statement n
}

Esempi

import Cocoa

let divide = {(val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}
let result = divide(200, 20)
print (result)

L'output sopra l'esecuzione del programma è il seguente:

10

---

chiusure di espressione

espressione Chiusure è un modo per costruire l'uso di semplici chiusure sintassi in linea. sintassi delle espressioni Chiusure fornisce qualche ottimizzazione in modo che compongono la chiusura diventa semplice e chiara.

---

funzione di ordinamento

Swift libreria standard fornisce una funzione denominata sorta, sarà ordinata in base alla funzione di chiusura da Lei forniti verranno utilizzati per ordinare i valori di tipo noto nella matrice.

Dopo il completamento del genere, sort (_ :) metodo restituisce un array delle stesse dimensioni dell'originale, il nuovo array contiene lo stesso tipo di elemento e l'elemento è stato correttamente ordinato, la matrice originale non viene modificato sort (_ :) metodi.

sort (_ :) metodo accetta due argomenti:

• Un array di tipo noto
• funzione di chiusura, che chiusure di funzione deve passare un array di elementi con lo stesso tipo di due valori e restituisce un valore booleano per indicare che il primo parametro dopo la fine della fila di smistamento in entrata davanti o dietro il secondo parametro. Se i primi valori dei parametri visualizzati davanti ai secondi valori di parametro, ordinare la funzione di chiusura deve tornare true , contrariamente a tornare false .

Esempi

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {
    return s1 > s2
}
var reversed = names.sort(backwards)

print(reversed)

L'output sopra l'esecuzione del programma è il seguente:

["S", "D", "BE", "AT", "AE"]

Se la stringa primo carattere (S1) è maggiore della seconda stringa (S2), all'indietro funzione restituisce true, che indica che il nuovo array dovrebbe apparire prima S1 S2. Per i caratteri della stringa, il "superiore" significa "più avanti appaiono in ordine alfabetico." Ciò significa che la lettera "B" è maggiore della lettera "A", la stringa "S" è maggiore della stringa "D". Si invertirà sorta alfabetico, "AT" verranno ordinati prima di "AE".

---

Nome del parametro abbreviazione

Swift fornisce automaticamente una funzione inline nome del parametro abbreviazione, è possibile direttamente attraverso i $ 0 chiusure dei parametri di $ 1, $ 2 per chiamare ordine.

Esempi

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

var reversed = names.sort( { $0 > $1 } )
print(reversed)

$ 0 e $ 1 per la chiusura del primo e del secondo parametro di tipo String.

L'output sopra l'esecuzione del programma è il seguente:

["S", "D", "BE", "AT", "AE"]

Se si utilizza il nome del parametro sigla nell'espressione di chiusura, è possibile la chiusura lista dei parametri sua definizione viene omesso, e le tipologie Acronimo nome parametro corrispondente verrà dedotto dal tipo di funzione. in parole può anche essere omesso.

---

funzione di Operatore

In realtà c'è un modo più breve per scrivere quanto sopra espressione esempio chiusure.

di Swift String tipo definisce il segno di maggiore ( > implementazione stringa), come una funzione che prende due String parametro di tipo e restituisce un Bool tipo di valore. Ciò ha coinciso con l' sort(_:) tipo di funzione del secondo parametro del metodo deve conformarsi. Pertanto, si può semplicemente passare un segno di maggiore, Swift può dedurre automaticamente che si desidera utilizzare è maggiore del numero di funzioni stringa per ottenere:

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

var reversed = names.sort(>)
print(reversed)

L'output sopra l'esecuzione del programma è il seguente:

["S", "D", "BE", "AT", "AE"]

---

Trailing Chiusure

Trailing chiusura è una funzione scritta tra parentesi dopo la chiusura di espressioni, funzioni per sostenere la sua chiamata come ultimo parametro.

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函数体部分
}

// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure({
    // 闭包主体部分
})

// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
  // 闭包主体部分
}

Esempi

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

//尾随闭包
var reversed = names.sort() { $0 > $1 }
print(reversed)

sort () dopo {$ 0> $ 1} chiusura finale.

L'output sopra l'esecuzione del programma è il seguente:

["S", "D", "BE", "AT", "AE"]

Nota: Se la funzione di un solo parametro di espressione chiusure, quando si utilizza la chiusura finale, si può anche mettere () omesso.

reversed = names.sort { $0 > $1 }

---

valore catturato

Chiusure possono essere cattura costante o variabile nel contesto della sua definizione.

Anche la definizione di queste costanti e variabili del dominio originale non esiste, la chiusura può ancora funzionare in vivo chiusura riferimento e la modifica di questi valori.

Swift più semplice forma di chiusura è funzione nidificata, la funzione è definita nel corpo delle altre funzioni della funzione.

La funzione annidata in grado di catturare tutti i suoi parametri di funzionamento esterni e costanti definite e variabili.

Guarda questo esempio:

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

Una funzione makeIncrementor, ha un parametro di tipo Int amout, e ha un nome di parametro forIncremet esterno, significa che quando si chiama, è necessario utilizzare il nome esterno. Il valore di ritorno è un ()-> Int funzione.

Nella funzione titolo, dichiarare una variabile e un incrementatore funzione di RunningTotal.

funzione di incrementatore non ottiene alcun argomento, ma nel corpo della funzione per accedere alle variabili RunningTotal e importo. Questo è perché contiene il corpo della funzione catturando sua RunningTotal esistente e quantità variabile realizzato.

Poiché non vi è alcuna variabile quantità di modifica, incrementatore in realtà catturare e memorizzare una copia della variabile, che viene memorizzato insieme ad una copia come incrementatore.

Così, quando chiamiamo questa funzione si accumulano:

import Cocoa

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

let incrementByTen = makeIncrementor(forIncrement: 10)

// 返回的值为10
print(incrementByTen())

// 返回的值为20
print(incrementByTen())

// 返回的值为30
print(incrementByTen())

L'output sopra l'esecuzione del programma è il seguente:

10
20
30

---

Le chiusure sono tipi di riferimento

L'esempio precedente, incrementByTen è costante, ma il punto di chiusura di queste costanti può ancora aumentare il valore della sua cattura variabile.

Questo perché le funzioni e le chiusure sono tipi di riferimento.

Che tu sia una funzione / chiusura assegnata a una costante o variabile, in realtà si sta impostando il valore dei corrispondenti riferimenti funzione / chiusura costanti / variabili. L'esempio precedente, incrementByTen chiusure punto di riferimento è una costante, piuttosto che il contenuto della chiusura stessa.

Questo significa anche che se si assegna la chiusura delle due diverse costanti / variabili, entrambi i valori punterà alla stessa chiusura:

import Cocoa

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

let incrementByTen = makeIncrementor(forIncrement: 10)

// 返回的值为10
incrementByTen()

// 返回的值为20
incrementByTen()

// 返回的值为30
incrementByTen()

// 返回的值为40
incrementByTen()

let alsoIncrementByTen = incrementByTen

// 返回的值也为50
print(alsoIncrementByTen())

L'output sopra l'esecuzione del programma è il seguente:

50

Precedente: Funzione Swift
Successivo: enumerazione Swift