Swift-Closures

a Swift 4-ben a bezárások hasonlóak a blokkként szervezett önálló funkciókhoz, és bárhol meghívhatók, mint például a C és az Objective C nyelvek. A függvényeken belül definiált konstansok és változó referenciák rögzítésre és tárolásra kerülnek. A funkciók a bezárások különleges eseteinek tekinthetők, és a következő három formát öltik−

globális függvények	beágyazott függvények	bezárási kifejezések
mondj egy nevet. Ne rögzítsen semmilyen értéket	van neve. Capture értékeket körülzáró függvény	névtelen lezárások capture értékeket a szomszédos blokkok

Bezárás kifejezések Swift 4 nyelven kövesse éles, optimalizálás, és könnyű szintaxis stílusok, amely magában foglalja.

• paraméter és visszatérési érték típusok következtetése a kontextusból.
• Implicit visszatér az egy kifejezésű lezárásokból.
• gyorsírási argumentumnevek és
• záró zárási szintaxis

szintaxis

a következő egy általános szintaxis a zárás meghatározásához, amely elfogadja a paramétereket és visszaad egy adattípust−

{ (parameters) −> return type in statements}

a következő egy egyszerű példa−

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

amikor a fenti programot játszótérrel futtatjuk, a következő eredményt kapjuk−

Welcome to Swift Closures

a következő lezárás két paramétert fogad el, és Bool értéket ad vissza−

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

a következő egy egyszerű példa−

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

amikor a fenti programot játszótérrel futtatjuk, megkapjuk a következő eredmény−

10

a beágyazott függvények kényelmes módot nyújtanak a kódblokkok elnevezésére és meghatározására. A teljes függvénydeklaráció helyett a név konstrukciókat használjuk a rövidebb függvények jelölésére. A függvény világos rövid nyilatkozatban történő ábrázolása fókuszált szintaxissal zárási kifejezésekkel érhető el.

növekvő sorrendű Program

a karakterlánc rendezése A Swift 4S kulcs által fenntartott “rendezett” funkcióval érhető el, amely már elérhető a standard könyvtárban. A függvény növekvő sorrendben rendezi az adott karakterláncokat, és visszaadja az elemeket egy új tömbben, ugyanolyan méretű és adattípusú, mint a régi tömbben. A régi tömb ugyanaz marad.

két argumentum jelenik meg a rendezett függvényen belül−

• az ismert típusú értékek tömbként vannak ábrázolva.

• Array contents (Int, Int) és Boolean értéket ad vissza (Bool), ha a tömb megfelelően van rendezve, akkor true értéket ad vissza, különben false értéket ad vissza.

a normál függvény input string van írva, majd át a rendezett függvény, hogy a húrok rendezve új tömb, amely az alább látható−

func ascend(s1: String, s2: String) -> Bool { return s1 > s2}let stringcmp = ascend(s1: "Swift 4", s2: "great")print (stringcmp)

amikor a playground segítségével futtatjuk a programot, a következő eredményt kapjuk−

true

a jégkrémhez rendezendő kezdeti tömb a “Swift 4” és a “great”. A tömb rendezésére szolgáló függvény string adattípusként van deklarálva,visszatérési típusa pedig logikai. Mindkét karakterláncot összehasonlítjuk és növekvő sorrendben rendezzük, majd egy új tömbben tároljuk. Ha a rendezés sikeres, a függvény valódi értéket ad vissza, máskülönben hamis értéket ad vissza.

záró kifejezés szintaxis használ−

• állandó paraméterek,
• változó paraméterek és
• inout paraméterek.

a bezárási kifejezés nem támogatja az alapértelmezett értékeket. A variadikus paraméterek és sorozatok paramétertípusként és visszatérési típusként is használhatók.

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

amikor a fenti programot a playground segítségével futtatjuk, a következő eredményt kapjuk−

30

a függvény utasításban említett paraméterek és visszatérési típus deklarációk az ‘in’ kulcsszóval ellátott inline closure expression függvényrel is ábrázolhatók. Miután deklaráló paraméter és visszatérési típusok ‘ in ‘ kulcsszó jelöli, hogy a test a lezárás.

egyetlen kifejezés Implicit értéke

itt a rendezett függvény második Argumentumának függvénytípusa egyértelművé teszi, hogy a bool értéket vissza kell adni a bezárásnak. Mivel a Bezárás törzse egyetlen kifejezést tartalmaz (s1 > s2), amely Bool értéket ad vissza, nincs kétértelműség, és a return kulcsszó elhagyható.

egyetlen kifejezésutasítás visszaadásához a kifejezés bezárásakor a ‘return’ kulcsszó elhagyásra kerül a deklaráció részében.

var count: = let descending = count.sorted(by: { n1, n2 in n1 > n2 })let ascending = count.sorted(by: { n1, n2 in n1 < n2 })print(descending)print(ascending)

amikor a fenti programot a playground segítségével futtatjuk, a következő eredményt kapjuk−

maga az állítás egyértelműen meghatározza, hogy ha a string1 nagyobb, mint a string 2 visszatér igaz egyébként hamis, ezért a return utasítás itt elhagyható.

ismert típusú lezárások

fontolja meg két szám hozzáadását. Tudjuk, hogy az összeadás visszaadja az egész adattípust. Ezért az ismert típusú lezárásokat a következőképpen deklarálják−

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

amikor a fenti programot játszótérrel futtatjuk, a következő eredményt kapjuk−

-10

a Gyorsírási argumentumok nevének lezárásként való deklarálása

a Swift 4 automatikusan megadja a gyorsírási argumentumok nevét az inline lezárásokhoz, amelyek felhasználhatók a lezárás argumentumainak értékeire a $0, $1, $2 stb.

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

itt a $0 és $1 A lezárás első és második karakterlánc argumentumaira utal.

amikor a fenti programot a playground segítségével futtatjuk, a következő eredményt kapjuk−

200

a Swift 4 megkönnyíti a felhasználó számára, hogy az Inline bezárásokat rövid argumentumnevekként ábrázolja $0, $1, $2 — $n.

lezárások argumentumlista kihagyásra kerül a definíció szakaszban, amikor rövid argumentumneveket ábrázolunk a bezárási kifejezésekben. A függvény típusa alapján a gyorsírási argumentumnevek származtatásra kerülnek. Mivel a gyorsírási argumentum a kifejezéstestben van definiálva ,az’ in ‘ kulcsszó kihagyásra kerül.

bezárások mint operátori funkciók

a Swift 4 egyszerű módot kínál a tagok elérésére azáltal, hogy csak operátori funkciókat biztosít bezárásként. Az előző példákban a ‘Bool’ kulcsszót használjuk a ‘true’ visszatérésére, ha a karakterláncok egyenlőek, különben a ‘false’értéket adja vissza.

a kifejezést még egyszerűbbé teszi operátor funkció Bezárás mint−

let numb = var sortedNumbers = numb.sorted ({ (left: Int, right: Int) -> Bool in return left < right})let asc = numb.sorted(<)print(asc)

amikor a fenti programot játszótérrel futtatjuk, a következő eredményt kapjuk−

lezárások mint pótkocsik

a függvény végső Argumentumának átadását egy záró kifejezésnek a ‘záró lezárások’segítségével deklaráljuk. A függvényen kívül van írva () val vel {}. Használata akkor szükséges, ha a függvény inline-t nem lehet egyetlen sorra írni.

reversed = sorted(names) {  > }

ahol {$0 > $1} külső záró lezárásként (nevekként) vannak ábrázolva.

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

amikor a fenti programot a playground segítségével futtatjuk, a következő eredményt kapjuk−

értékek és Referenciatípusok rögzítése

a Swift 4-ben az állandók és változók értékeinek rögzítése lezárások segítségével történik. Továbbá utal és módosítja a zárótesten belüli állandók és változók értékeit, annak ellenére, hogy a változók már nem léteznek.

az állandó és változó értékek rögzítése a beágyazott függvény használatával érhető el, ha a függvényt más függvény testébe írja.

egy beágyazott függvény rögzíti−

• külső függvény argumentumok.
• a külső függvényben definiált állandók és változók rögzítése.

a Swift 4-ben, amikor egy konstansot vagy változót deklarálnak egy függvényen belül, az adott változókra való hivatkozás is automatikusan létrejön a bezárással. Azt is lehetővé teszi, hogy több mint két változót azonos lezárásként hivatkozzon az alábbiak szerint−

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

itt a oneDecrement és a Decrement változók ugyanazt a memóriablokkot mutatják, mint a bezárási referencia.

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()

amikor a fenti programot a playground segítségével futtatjuk, a következő eredményt kapjuk−

826446

amikor minden egyes alkalommal a külső függvény calcDecrement nevezzük meghívja a decrementer () függvény és csökkenti az értéket 18 és visszaadja az eredményt segítségével külső függvény calcDecrement. Itt a meszesedés zárásként működik.

annak ellenére, hogy a decrementer() függvénynek nincs argumentuma, a closure alapértelmezés szerint az ‘overallDecrement’ és a ‘total’ változókra utal a meglévő értékeinek rögzítésével. A megadott változók értékeinek másolatát az új decrementer() függvény tárolja. A Swift 4 kezeli a memóriakezelési funkciókat a memóriaterületek kiosztásával és elosztásával, amikor a változók nincsenek használatban.