írta Reinder de Vries július 12-én 2020-ban az alkalmazásfejlesztésben, Swift

A Swift

a Swift egy csomó funkcióval rendelkezik, amelyek hasznosak a gyűjtemények és szekvenciák átalakításához. Ebben az oktatóanyagban a map(_:), flatMap(_:) és compactMap(_:)témákról lesz szó.

itt van, amit fogunk összpontosítani:

  1. hogyan map(_:) átalakít egy gyűjteményt vagy szekvenciát egy lezárás alkalmazásával
  2. hogyan flatMap(_:) simíthatja a bemeneti tömböt, miután meghívta map(_:)
  3. hogyan compactMap(_:) eltávolítja nil a bemeneti tömbből

egy korábbi oktatóanyagban megvitattuk, hogyan használhatja filter(_:) és reduce(_:). Ezek a magasabb rendű funkciók rendkívül hasznosak a gyűjtemények átalakításához, tömör és éleslátó módon.

Kész? Menjünk.

  1. A Swift Térkép funkciójának használata
  2. A FlatMap funkció használata
  3. A CompactMap funkció használata
  4. miért használja a Flatmap és a CompactMap funkciót?
  5. További információ

még nem ismeri a bezárásokat vagy a magasabb rendű funkciókat? Győződjön meg róla, hogy olvassa fel azokat az első:

  • A végső útmutató a lezárások Swift
  • térkép, csökkentése és szűrése Swift

a Swift

Térkép funkciójának gyors frissítéseként a Swift magasabb rendű funkcióiról kiindulópontunk a map(_:) funkció. Ez a függvény transzformációt alkalmaz egy sorozat minden elemére, például egy tömbre vagy szótárra.

Íme egy példa:

hagyja számok =
hagyja eredmény = számok.térkép({ $0 * $0 })
nyomtatás (eredmény)
figyelmeztetések elrejtése

bontsuk le ezt:

először egy tömböt hozunk létre numbers néhány egész értékkel. Ezután a map(_:) függvény meghívásra kerül numbers és az eredménye resultlesz.

a map(_:)függvénynek egy paramétere van, egy lezárás, amely eredményét adja vissza. A a lezárás első paraméterének felel meg, azaz a numbers számnak, amelyet átalakítanak.

minden szám négyzetét kiszámítjuk numbers. Lényegében a műveletet minden numbers számra meghívjuk, és a kapott tömb result – hez van rendelve. Átalakítja – vagy” leképezi ” – az egyik tömböt a másikba.

egy tömb átalakítása map(_:) – vel hasonló a for hurok használatához, de sokkal tömörebb. Mint ez:

let numbers = var result = ()for number in numbers { result += }print(result)

itt van egy másik módja annak, hogy megnézzük. Val vel map(_:), a számok bemeneti tömbje átalakul egy másik számtömbbé. Mint ez:

2 => 2 * 2 => 43 => 3 * 3 => 94 => 4 * 4 => 165 => 5 * 5 => 25

az olyan függvényeket, mint a map(_:), magasabb rendű függvényeknek nevezzük, mert egy függvényt vesznek bemenetként, szemben a szokásos értékekkel. A magasabb rendű függvények függvényeket is kiadhatnak, ami hasznos az úgynevezett programozási paradigmához funkcionális programozás.

technikailag magasabb rendű függvényeket hívhat meg, mint a map(_:) bármilyen sorrendben. Ez magában foglalja a gyűjtemények, mint tömbök, szótárak és készletek, tartományok, mint a 1...100 és az úgynevezett iterátorok. Bármi, ami úgy néz ki, mint egy “lista” értékek, alapvetően.

az oktatóanyag végén megvitatjuk, miért hasznosak a magasabb rendű függvények. Először a flatMap(_:) és a compactMap(_:) – ről olvashatunk.

jelentkezz iOS fejlesztőként

Tanuld meg, hogyan építhetsz iOS 14 alkalmazásokat a Swift 5 segítségével

regisztrálj az iOS fejlesztői tanfolyamomra, és tanuld meg, hogyan kezdheted el karriered professzionális iOS fejlesztőként.

a

FlatMap függvény használata a flatMap(_:) függvény hasonló a map(_:) függvényhez, azzal a különbséggel, hogy “ellapítja” a kapott tömböt. Íme egy példa:

hagyja számok =,,]
hagyja eredmény = számok.flatMap ({$0 })
nyomtatás (eredmény)
figyelmeztetések elrejtése

a fenti kód egész számok beágyazott tömbjével kezdődik. A numbers tömb 3 tömbből áll, amelyek mindegyike 3 számot tartalmaz.

a lezárás { } egyszerűen visszaadja a lezárás első Argumentumát, azaz az egyes beágyazott tömböket. Nem történik átalakítás vagy művelet. Amikor a flatMap(_:) – et hívja a numbers tömbön, bár a map(_:) helyett az egyes számok lapított tömbjét kapja. A numbers bemeneti tömbtől eltérően az eredmény tömb nem tartalmaz beágyazott tömböket!

nézzünk egy másik példát. Képzelje el, hogy 4 zsiráfcsoporttal dolgozik, és egyetlen zsiráfcsoportot szeretne létrehozni, amely magasabb, mint egy bizonyos magasság. Itt van, hogyan kell csinálni, hogy:

let giraffes =,,]
let legmagasabb = zsiráfok.flatMap ({ $0.szűrő({ $0 > 10 }) })
nyomtatás (legmagasabb)
figyelmeztetések elrejtése

nézze meg, hogy a giraffes hogyan tartalmaz tömböket? A fenti kódban a filter(_:) függvény minden beágyazott tömbben meghívásra kerül giraffes. Csak egész számokat akarunk (zsiráfok!), amelyek nagyobbak, mint 10. A kapott tömböket egy “lapos” tömbre lapítjuk, és tallest – hez rendeljük.

fontolja meg, mi történne, ha a map(_:) – t használtuk volna a flatMap(_:) helyett. A kapott tömb nem lesz lapítva. Helyette, ez lenne:

, , ]

fontos megjegyezni, hogy a flatMap(_:) függvény először a tömb elemeire hívja a map(_:) – et, majd ellapítja. Ezért nem működik az alábbiak:

let numbers = , , ]let result = numbers.flatMap({  * 2 })

a fenti kódban a a számok belsejében lévő tömbökre utal. Lehetetlen szorozni egy tömböt kettővel, ezért nem működik ez a kód.

ez okos gondolni flatmapping, mint látva egy tömb eggyel kevesebb dimenzióban. Egy kétdimenziós tömbbel kezdjük, és a flatMap(_:)után egydimenziós tömbbel fejezzük be.

mi a helyzet a flatMap(_:) opciókkal? Nézzük meg ezt a következőt.

a “kompakt térkép” elnevezés azon az elképzelésen alapul, hogy a nil elemek eltávolítása egy tömbből kompaktabbá teszi a tömböt. Hasonlóképpen, a “lapos térkép” név a tömb simításából származik. A “leképezés” pedig a matematika fogalma, ahol az értékeket egy készletben társítja egy másik készlethez.

a CompactMap függvény használata

a compactMap(_:) függvény eltávolítja a nil értékeket a bemeneti tömbből. Szuper hasznos, ha opcionálisokkal dolgozik.

A Swift 4 Előtt.1, a flatMap(_:) függvény (fent) szintén használható a nil értékek kiszűrésére a lapított tömbökből. A Swift 4.1+ óta az explicit compactMap(_:) – et használja erre a célra.

Íme egy példa:

hagyja számok =
hagyja eredmény = számok.compactMap ({Int ($0) })
nyomtatás (eredmény)
figyelmeztetések elrejtése

nézze meg, mi történik? A kód legfontosabb része Int(). Ez egy numbers karakterláncot vesz fel – vel, és megpróbálja konvertálni egész számra, a Int() inicializálóval.

ez a Int() inicializáló sikertelen: visszatérhet nil – opcionális-tehát visszatérési típusa Int?. Ennek eredményeként a leképezési transzformáció visszatérési típusa – opcionális egész számok tömbje.

a compactMap(_:) funkció automatikusan eltávolítja a nil elemeket a visszaadott tömbből, miután meghívta a map(_:) – et. Mint ilyen, a visszatérési típus nem opcionális.

a fenti kódban a resulttípusa . Ha a map(_:) értéket használta volna, a visszatérési típus lett volna. És szükség lett volna egy további lépésre, hogy kicsomagolja az értékeket a tömbből, hogy dolgozzon velük.

miért érdemes használni a Flatmap és a CompactMap alkalmazást?

mielőtt megvitatnánk a flatmap és a compactmap valós felhasználási eseteit, röviden összefoglaljuk ezeket a magasabb rendű függvényeket és céljaikat.

  1. a map(_:) függvény zárást alkalmaz egy bemeneti gyűjteményre, és visszaadja az átalakított gyűjteményt
  2. A flatMap(_:) függvény ugyanezt teszi, és az eredményül kapott gyűjteményt is ellapítja
  3. a compactMap(_:) függvény ugyanazt teszi, mint map(_:), és eltávolítja a nil – et az eredményül kapott gyűjteményből

map(_:),flatMap(_:)éscompactMap(_:)absztraktokkal való munka néha megnehezíti a gyakorlati felhasználási esetek elképzelését. Beszéljük meg, miért szeretné használni őket.

az olyan funkciók használata, mint a map(_:) a transzformációk szekvenciákra történő alkalmazásához, néhány előnnyel jár:

  • tömörebb, mint egy for ciklus használata, mert nincs szükség ideiglenes változókra és többsoros for in { } blokkra.
  • általában egy sorban írhat hívást map(_:) – re, ami (általában) olvashatóbbá teszi a kódot.
  • az olyan funkciók, mint a map(_:), láncolhatók, így több transzformációt is alkalmazhat egy sorozatra egyenként.

általában a magasabb rendű függvények hasznosak, mert lehetővé teszik egy függvény alkalmazását egy értéksorozatra. A transzformáció eljárási kódolása helyett egyszerűen alkalmazhatja a függvényt, és visszaadhatja az eredményt.

a flatMap(_:) legpraktikusabb Használati esete a csoportosított vagy beágyazott bemeneti értékekkel való munka, de a kívánt kimeneti értéknek egydimenziósnak kell lennie.

például egy zenei alkalmazásban 3 tömb lehet: dalok, előadók és lejátszási listák. Kombinálja őket egy tömbben, hívja a flatMap(_:) – et, válassza ki azokat a dalokat, előadókat és lejátszási listákat, amelyekhez a isFavorite true, és végül egy lapos listát kap a kedvenc elemekről.

a compactMap(_:)gyakorlati felhasználási esete olyan átalakítással dolgozik, amely nil értéket adhat vissza. Néhány triviális lépést megtakaríthat, ha hagyja, hogy a compactMap(_:) azonnal kiszűrje a nil értékeket. További előny a compactMap(_:) nem opcionális visszatérési típusa; a filter(_:)függvény összehasonlításképpen opcionális értéket adott volna vissza, ha kiszűrte a nil értéket.

kombinálhatja a flatMap(_:) és a compactMap(_:), sőt a filter(_:)vagy a reduce(_:_:) kombinációt is. Képzelje el, hogy közösségi média alkalmazást épít. Meg akarja építeni a bejegyzések idővonalát egy felhasználó számára. 3 lekérdezéssel választhatja ki a felhasználó bejegyzésazonosítóit, például a követő bejegyzésekből, hirdetésekből és felkapott témákból.

  • használhatja map(_:) bővíteni ezeket az azonosítókat a tényleges Post tárgyak
  • használhatja flatMap(_:) lelapul a 3 csoportok egy gyűjtemény
  • használhatja compactMap(_:) dobni üzenete, hogy nem lehet bővíteni

tisztán!

jelentkezz iOS fejlesztőként

Tanuld meg, hogyan építhetsz iOS 14 alkalmazásokat a Swift 5 segítségével

regisztrálj az iOS fejlesztői tanfolyamomra, és tanuld meg, hogyan kezdheted el karriered professzionális iOS fejlesztőként.

további olvasmányok

érdemes megismerni a map(_:), flatMap(_:) és compactMap(_:) szavakat, mert ezek tömörebbé és olvashatóbbá teszik a kódot. További funkcionális programozást adhat az alkalmazás kódjához. Ha egyszer megszokod őket, nem tudod elhinni, hogy nélkülük is el tudod végezni a munkádat.

különösen a map(_:), flatMap(_:) és compactMap(_:) közötti különbségeket érdemes kiemelni. Az első átalakítást alkalmaz egy szekvenciára, a második ellapítja a kapott tömböt, a harmadik pedig eltávolítja a nil értékeket, mielőtt visszaadja az eredményt. Király!

Vélemény, hozzászólás?

Az e-mail-címet nem tesszük közzé.