Swift - Zamknięcia

Zamknięcia w Swift 4 są podobne do zamkniętych funkcji zorganizowanych w bloki i nazywanych wszędzie, jak języki C i Objective C. Stałe i odwołania do zmiennych zdefiniowane wewnątrz funkcji są przechwytywane i przechowywane w domknięciach. Funkcje są uważane za szczególne przypadki domknięć i przyjmują następujące trzy formy -

Funkcje globalne	Funkcje zagnieżdżone	Wyrażenia końcowe
Miej imię. Nie rejestruj żadnych wartości	Miej imię. Przechwyć wartości z otaczającej funkcji	Nienazwane Zamknięcia przechwytują wartości z sąsiednich bloków

Wyrażenia zamykające w języku Swift 4 są zgodne z wyraźnymi, optymalizacyjnymi i lekkimi stylami składni, które obejmują.

Wnioskowanie o typach parametrów i zwracanych wartościach z kontekstu.
Niejawne zwroty z zamknięć pojedynczych wyrażeń.
Skrócone nazwy argumentów i
Składnia zamknięcia końcowego

Składnia

Poniżej znajduje się ogólna składnia definiująca zamknięcie, które akceptuje parametry i zwraca typ danych -

{
   (parameters) −> return type in
   statements
}

Oto prosty przykład -

let studname = { print("Welcome to Swift Closures") }
studname()

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

Welcome to Swift Closures

Poniższe zamknięcie akceptuje dwa parametry i zwraca wartość logiczną -

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

Oto prosty przykład -

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

let result = divide(200, 20)
print (result)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

Wyrażenia w zamknięciach

Zagnieżdżone funkcje zapewniają wygodny sposób nazywania i definiowania bloków kodu. Zamiast reprezentować całą deklarację funkcji i konstrukcje nazw są używane do oznaczania krótszych funkcji. Przedstawienie funkcji w jasnej, krótkiej instrukcji ze skoncentrowaną składnią osiąga się za pomocą wyrażeń zamykających.

Program porządku rosnącego

Sortowanie ciągu odbywa się za pomocą zarezerwowanej funkcji klucza Swift 4s „sortowane”, która jest już dostępna w bibliotece standardowej. Funkcja posortuje podane ciągi w kolejności rosnącej i zwróci elementy w nowej tablicy o takim samym rozmiarze i typie danych, jak w starej tablicy. Stara tablica pozostaje taka sama.

W posortowanej funkcji reprezentowane są dwa argumenty -

Wartości typu Known reprezentowane jako tablice.
Zawartość tablicy (Int, Int) i zwraca wartość logiczną (Bool), jeśli tablica jest poprawnie posortowana, zwróci wartość true, w przeciwnym razie zwróci wartość false.

Normalna funkcja z ciągiem wejściowym jest zapisywana i przekazywana do posortowanej funkcji, aby uzyskać ciągi posortowane do nowej tablicy, która jest pokazana poniżej -

func ascend(s1: String, s2: String) -> Bool {
   return s1 > s2
}

let stringcmp = ascend(s1: "Swift 4", s2: "great")
print (stringcmp)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

true

Początkowa tablica, która ma być posortowana pod kątem lodów, jest podana jako „Swift 4” i „świetna”. Funkcja sortowania tablicy jest zadeklarowana jako łańcuchowy typ danych, a jej zwracany typ jest określany jako Boolean. Oba ciągi są porównywane i sortowane w kolejności rosnącej i zapisywane w nowej tablicy. Jeśli sortowanie zakończy się pomyślnie, funkcja zwróci wartość true, w przeciwnym razie zwróci wartość false.

Używa składni wyrażenia zamknięcia -

stałe parametry,
zmienne parametry i
parametry inout.

Wyrażenie zamknięcia nie obsługuje wartości domyślnych. Parametry zmienne i krotki mogą być również używane jako typy parametrów i typy zwracane.

let sum = {
   (no1: Int, no2: Int) -> Int in 
   return no1 + no2 
}

let digits = sum(10, 20)
print(digits)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

Parametry i deklaracje typu zwracanego wymienione w instrukcji funkcji mogą być również reprezentowane przez funkcję wyrażenia inline closure ze słowem kluczowym „in”. Po zadeklarowaniu parametru i zwracanych typów słowo kluczowe „in” jest używane do oznaczenia treści zamknięcia.

Niejawne zwroty pojedynczego wyrażenia

W tym przypadku typ funkcji drugiego argumentu posortowanej funkcji wyjaśnia, że wartość logiczna musi zostać zwrócona przez zamknięcie. Ponieważ treść zamknięcia zawiera pojedyncze wyrażenie (s1> s2), które zwraca wartość Bool, nie ma niejednoznaczności, a słowo kluczowe return można pominąć.

Aby zwrócić instrukcję Single expression w zamknięciu wyrażenia, słowo kluczowe „return” jest pomijane w części deklaracji.

var count:[Int] = [5, 10, -6, 75, 20]
let descending = count.sorted(by: { n1, n2 in n1 > n2 })
let ascending = count.sorted(by: { n1, n2 in n1 < n2 })

print(descending)
print(ascending)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

[75, 20, 10, 5, -6]
[-6, 5, 10, 20, 75]

Samo stwierdzenie jasno definiuje, że gdy string1 jest większe niż string 2, zwraca true, w przeciwnym razie false, stąd instrukcja return jest tutaj pominięta.

Zamknięcia znanych typów

Rozważ dodanie dwóch liczb. Wiemy, że dodanie zwróci całkowity typ danych. Stąd znane zamknięcia typu są deklarowane jako -

let sub = {
   (no1: Int, no2: Int) -> Int in 
   return no1 - no2 
}

let digits = sub(10, 20)
print(digits)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

-10

Deklarowanie skróconych nazw argumentów jako domknięć

Swift 4 automatycznie dostarcza skrócone nazwy argumentów do domknięć w wierszu, których można użyć do odwoływania się do wartości argumentów domknięcia przez nazwy $0, $1, 2 USD i tak dalej.

var shorthand: (String, String) -> String
shorthand = { $1 }
print(shorthand("100", "200"))

Tutaj, $0 and $1 odnoszą się do pierwszego i drugiego argumentu String zamknięcia.

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

Swift 4 ułatwia użytkownikowi reprezentowanie domknięć Inline jako skróconych nazw argumentów przez reprezentowanie $0, $1, $2 --- $n.

Lista argumentów zamknięć jest pomijana w sekcji definicji, gdy reprezentujemy skrócone nazwy argumentów w wyrażeniach zamknięcia. Na podstawie typu funkcji zostaną wyprowadzone skrócone nazwy argumentów. Ponieważ argument skrótu jest zdefiniowany w treści wyrażenia, słowo kluczowe „in” jest pomijane.

Zamknięcia jako funkcje operatora

Swift 4 zapewnia łatwy dostęp do elementów, zapewniając po prostu funkcje operatora jako zamknięcia. W poprzednich przykładach słowo kluczowe „Bool” jest używane do zwracania „prawda”, gdy łańcuchy są równe, w przeciwnym razie zwraca „fałsz”.

Wyrażenie jest jeszcze prostsze dzięki funkcji operatora w zamknięciu, ponieważ -

let numb = [98, -20, -30, 42, 18, 35]
var sortedNumbers = numb.sorted ({
   (left: Int, right: Int) -> Bool in
   return left < right
})

let asc = numb.sorted(<)
print(asc)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

[-30, -20, 18, 35, 42, 98]

Zamknięcia jako zwiastuny

Przekazanie końcowego argumentu funkcji do wyrażenia zamykającego deklarowane jest za pomocą „Końcowych zamknięć”. Jest napisany poza funkcją () z {}. Jego użycie jest potrzebne, gdy nie można zapisać funkcji w linii w jednym wierszu.

reversed = sorted(names) { $0 > $1}

gdzie {$0 > $1} są reprezentowane jako końcowe zamknięcia zadeklarowane na zewnątrz (nazwy).

import Foundation
var letters = ["North", "East", "West", "South"]

let twoletters = letters.map({ 
   (state: String) -> String in
   return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString
})

let stletters = letters.map() { 
   $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString 
}
print(stletters)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

[NO, EA, WE, SO]

Przechwytywanie wartości i typów odwołań

W Swift 4 przechwytywanie stałych i wartości zmiennych odbywa się za pomocą domknięć. Ponadto odwołuje się i modyfikuje wartości tych stałych i zmiennych wewnątrz ciała zamknięcia, nawet jeśli zmienne już nie istnieją.

Przechwytywanie wartości stałych i zmiennych uzyskuje się za pomocą funkcji zagnieżdżonej, zapisując funkcję w treści innej funkcji.

Zagnieżdżona funkcja przechwytuje -

Argumenty funkcji zewnętrznej.
Przechwytuj stałe i zmienne zdefiniowane w funkcji Outer.

W Swift 4, gdy stała lub zmienna jest zadeklarowana wewnątrz funkcji, odniesienie do tych zmiennych jest również tworzone automatycznie przez zamknięcie. Zapewnia również możliwość odniesienia więcej niż dwóch zmiennych jako tego samego zamknięcia w następujący sposób -

let decrem = calcDecrement(forDecrement: 18)
decrem()

Tutaj oneDecrement i zmienne Decrement będą wskazywać ten sam blok pamięci jako odniesienie zamknięcia.

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 100
   func decrementer() -> Int {
      overallDecrement -= total
      print(overallDecrement)
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 18)
decrem()
decrem()
decrem()

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

82
64
46

Za każdym razem, gdy wywoływana jest funkcja zewnętrzna calcDecrement, wywołuje ona funkcję dekrementer (), zmniejsza wartość o 18 i zwraca wynik za pomocą funkcji zewnętrznej calcDecrement. Tutaj calcDecrement działa jak zamknięcie.

Mimo że funkcja decrementer () nie ma domyślnie żadnych argumentów, zamknięcie odwołuje się do zmiennych „generalDecrement” i „total”, przechwytując ich istniejące wartości. Kopia wartości określonych zmiennych jest przechowywana za pomocą nowej funkcji dekrementacji (). Swift 4 obsługuje funkcje zarządzania pamięcią poprzez przydzielanie i zwalnianie przestrzeni pamięci, gdy zmienne nie są używane.