munka Táblázat nézet vezérlők Swift

írta Reinder de Vries augusztus 3-án 2020-ban App Development, iOS

ebben a tutorial megmutatom lépésről-lépésre, hogyan táblázat nézet vezérlők működnek, és hogyan lehet használni őket. A UITableViewController teljes skálájába belemerülünk az objektum-orientált programozásba, a delegálásba és a táblázatnézetek kulisszák mögötti mechanizmusaiba.

a táblázatnézet-vezérlő strukturált, megismételhető információkat jelenít meg függőleges listában. Az iOS-alkalmazás UITableViewController osztályát használja táblázatnézet-vezérlő létrehozásához.

a táblázatnézet-vezérlővel való munka néhány fontos iOS fejlesztési koncepcióval is együtt jár, mint például az alosztályozás, a delegálási tervezési minta és a nézetek újrafelhasználása.

fontos a professzionális és gyakorlati iOS Fejlesztők (te!) a mester dolgozik Asztal nézet vezérlők. Miután megszokta, hogy egy ilyen sokoldalú felhasználói felület-összetevőn dolgozik, mint például a UITableViewController, az iOS fejlesztésének más összetettebb szempontjai is értelmet nyernek.

Kész? Merüljünk bele!

1. hogyan működik a Táblázat nézet vezérlő
2. egyszerű táblázat nézet vezérlő beállítása
3. a Táblázat nézet vezérlő adatforrásának kódolása
4. cellák biztosítása a Táblázat nézet vezérlő
5. válasz a felhasználói interakcióra
6. további olvasmányok

hogyan működik a Táblázat nézet vezérlő view controller works

ha korábban már használt iOS alkalmazást, akkor korábban is használt Table View vezérlőket. Olyan gyakran használják őket az iOS alkalmazásokban!

Íme egy példa egy táblázatnézet-vezérlőre:

a Táblázat nézet vezérlő általában a következő látható összetevők:

• táblázatnézet, amely a képernyőn megjelenő felhasználói felület-összetevő vagy nézet. A táblázatnézet a UITableView osztály egy példánya, amely a UIScrollViewalosztálya.
• Táblázatnézet cellák, amelyek a táblázatnézetben látható ismételhető sorok vagy nézetek. A táblázatnézet cella egy UITableViewCell osztály példánya, és ezt az osztályt gyakran alosztályozzák egyéni táblázatnézet cellák létrehozásához.

a táblázatnézet vezérlő ezen összetevők használatára is támaszkodik, a színfalak mögött:

• táblázatnézet-delegált, amely felelős a táblázatnézet elrendezésének kezeléséért és a felhasználói interakciós események megválaszolásáért. A táblázatnézet delegáltja a UITableViewDelegate osztály egy példánya.
• táblázatnézeti adatforrás, amely a táblázatnézeti adatok kezeléséért felelős, beleértve a táblázatnézeti cellákat és szakaszokat is. Az adatforrás a UITableViewDataSource osztály egy példánya.

a Táblázat nézet vezérlőkkel való munka legérdekesebb része maga a Táblázat nézet vezérlő! Hogyhogy?

ismeri a modell-nézet-vezérlő architektúrát? A Model-View-Controller architektúra szerint a table view és a table view cella nézetek, a table view controller pedig vezérlő.

a nézetek felelősek az információk látható megjelenítéséért a felhasználó számára, felhasználói felülettel (UI). Az adatkezelők felelősek a logika megvalósításáért, az adatok kezeléséért és a döntések meghozataláért. Másképp mondta: nem látja a vezérlőt, de ott van, kezeli, amit lát a nézeteken keresztül.

ha táblázatnézet-vezérlőt használ az alkalmazásban, akkor a UITableViewController osztályt alosztályozza. Maga a UITableViewController osztály az UIViewController alosztálya.

itt található egy példatábla nézet vezérlő osztályhierarchiája, amely megjeleníti a kapcsolattartási adatokat:

• egy példánya ContactsTableViewController
  • alosztályok UITableViewController
    • alosztályok UIViewController

az Object-Oriented Programming (OOP) alapelvei szerint, amikor a RaceCar osztály Vehicle alosztályokat örököl, akkor a szuperosztály tulajdonságait és funkcióit örökli, mint például a maxSpeed és a drive().

a Vehicleosztályt ezután a RaceCar szuperosztályának nevezzük. Ezt az elvet öröklésnek nevezik.

zavaró? Ez lehet! Gondolj rá, mint ez: annak érdekében, hogy a táblázatnézet-vezérlő rendben működjön, örökölnie kell egy csomó kódot, így nem kell magának megírnia az összes kódot. Az osztályhierarchia és az OOP azért van, hogy strukturálja ezt az örökséget.

táblázatnézetekkel asztalnézet vezérlő használata nélkül is dolgozhat. Egyszerűen adjon hozzá egy UITableView értéket egy nézetvezérlőhöz, adja meg neki a táblázatnézet delegáltjának és az adatforrás funkcióinak implementációit, és kész.

a UITableViewController osztály ezen táblázatnézeti delegált és táblázatnézeti adatforrás függvények alapértelmezett implementációit tartalmazza. Ez egy fontos szempont a munka egy asztal nézet vezérlő!

amint az oktatóanyag következő fejezeteiben látható, ezeket a funkciókat saját implementációinkkal felülbíráljuk. Testreszabhatjuk a Táblázat nézet vezérlőjét ezzel.

beállítása egy egyszerű tábla nézet vezérlő

rendben, tegyük mindezt a gyakorlatba. Ebben a részben egy egyszerű táblázatnézet-vezérlőt fogunk építeni. Végrehajtja a szükséges funkciókat, hogy működjön, és elmagyarázom, hogyan működnek, ahogy haladunk. Gyerünk, mozgás!

3 különböző megközelítést használhat az UI-kkel való munkavégzéshez az Xcode-ban:

1. nézetek létrehozása programozottan, azaz kézzel történő kódolás
2. UI-k beállítása az Interface Builder-ben és Swift-kóddal való összekapcsolása XIBs-en keresztül
3. UI-k és átmeneteik beállítása az Interface Builder-ben a Storyboards segítségével
4. (technikailag használhatja a SwiftUI-t is, de a táblázatnézet-vezérlők esetében ez túlmutat ezen oktatóprogramon.)

unalmas és nem produktív Az UI-k kézi kódolása. Ha nem vigyázol a forgatókönyvekkel, akkor végül elrejtik a bonyolultságot a fejlesztő elől. Forgatókönyvekkel fogunk dolgozni, miközben pontosan kitaláljuk, hogyan működnek a színfalak mögött.

Itt van, mit kell tenni:

Először hozzon létre egy új Xcode projekt segítségével a Fájl → Új → Projekt…. Győződjön meg róla, hogy válassza ki az alkalmazás sablont, és válasszon Storyboard for Interface és UIKit App Delegate for Life Cycle.

ezután tegye meg ezeket a lépéseket:

1. kattintson a jobb gombbal a projektre a Project Navigatorban, és válassza az új fájl lehetőséget…
2. válassza ki a Cocoa Touch osztály sablont (iOS)
3. válassza a UITableViewController lehetőséget a
4. osztály Alosztályának megnevezéséhez ContactsTableViewController
5. ne jelölje be az xib fájl létrehozását is
6. végül, kattintson a Tovább gombra, és mentse a fájlt a többi swift fájl mellett

végül tegye ezt:

1. LÉPJEN BE Main.storyboard és távolítsa el a meglévő Nézetvezérlő jelenetet
2. adjon hozzá egy új Táblázatnézet-vezérlőt a storyboardhoz a könyvtáron keresztül
3. a táblázatnézet-vezérlő kiválasztásával LÉPJEN az attribútumok felügyelőhöz, és jelölje be az Is kezdeti Nézetvezérlő jelölőnégyzetet
4. végül LÉPJEN az Identitásfelügyelőhöz, és állítsa az osztálytContactsTableViewController

ez az! Most már van egy táblázatnézet-vezérlő a projekt storyboardjában, és csatlakoztatta a ContactsTableViewController Swift osztályhoz.

ahogy kitaláltad, a ContactsTableViewControllerosztályod a UITableViewController alosztálya. Ezt láthatja a Swift fájlban, a tetején, az osztály deklarációjában.

class ContactsTableViewController: UITableViewController { ···

ez a szintaxis azt jelenti: a ContactsTableViewControllerosztály a UITableViewController alosztálya.

amikor jobb gombbal rákattint az “UITableViewController”-re, miközben lenyomva tartja az Option-billentyűt, az osztály deklarációjában láthatja, hogy a UITableViewController a UIViewController alosztálya, és megfelel a UITableViewDelegate és UITableViewDataSource protokolloknak.

ez a Táblázat nézet vezérlő ereje! Nem csak az egyes összetevőket adja meg nekünk a táblázatnézet elkészítéséhez, hanem a vezérlő alapértelmezett megvalósítást is biztosít. Ezért a UITableViewController alosztályba tartozunk, ahelyett, hogy üres nézetvezérlőt hoznánk létre táblázatos nézettel.

ezen a ponton futtathatja az alkalmazást a Command-R gombbal vagy a lejátszás gombbal, és láthatja, hogy az üres tábla nézet vezérlő megjelenik a képernyőn.

egyébként miért van ez? Még nem kódoltunk semmit! Ez azért van, mert a Táblázat nézet vezérlő egy alapértelmezett végrehajtása, hogy csak azt mutatja, üres cellák a képernyőn. Ügyes!

a Táblázat nézet vezérlő adatforrás kódolása

most, hogy a Táblázat nézet vezérlő beállítása megtörtént, hozzuk életre! Ebben a fejezetben azokra a különféle funkciókra összpontosítunk, amelyeket végre kell hajtania a táblázatnézet-vezérlő működéséhez.

amint azt korábban kifejtettük, ezek a függvények vagy a táblázatnézet vezérlő delegáltjához, vagy a táblázatnézet vezérlő adatforrásához tartoznak. Mindkét protokoll delegálást használ a Táblázat nézet testreszabásához.

a UITableViewDataSource legfontosabb funkciói a következők:

• numberOfSections(in:)
• tableView(_:numberOfRowsInSection:)
• tableView(_:cellForRowAt:)

a UITableViewDelegate további fontos funkciói a következők:

• tableView(_:didSelectRowAt:)
• tableView(_:willDisplay:for:)

további funkciókat az UITableViewDelegate és az UITableViewDataSource Apple fejlesztői dokumentációjában talál.

a névjegyek adatainak hozzáadása

először a táblázatnézet-vezérlő kapcsolattartási adatainak hozzáadásával kezdi. Adja hozzá a következő tulajdonságot a ContactsTableViewController osztályhoz:

let contacts:] = , , , , , , , , , , , , , , , , ]

ez egy névsor, amit mindannyian szeretnénk, igaz? Itt van, hogyan működik:

• a let contactskonstansot deklarál contacts névvel. Hozzáadta tulajdonságként az osztályhoz, így minden osztálypéldány hozzáférhet ehhez az állandóhoz az osztály kódjában.
• a contacts típusa ], amely karakterláncok tömbje. Lényegében egy tömböt hoz létre, amelynek elemei húrok tömbjei. (A változó neve és típusa kettősponttal van elválasztva :)
• a = kód egy tömb literált rendel a contacts – hez, kitöltve néhány milliárdos nevével és telefonszámával.

egy későbbi ponton használhatjuk a tömbben lévő elemek számát contacts.count – vel. És megkaphatjuk az egyes neveket és telefonszámokat a contacts és a contacts betűkkel, az index szintaxis használatával.

Táblázatnézet Cellaosztály regisztrálása

mielőtt cellákat használna egy táblázatnézet-vezérlőben, regisztrálnia kell őket a táblázatnézetben. Ezt két módon teheti meg:

1. táblázatnézet cellaosztály és azonosító megadásával
2. táblázatnézet xib cellaazonosító megadásával

ha egyéni táblázatnézet cellát használ, akkor valószínűleg regisztrálni szeretne egy XIB-t ehhez. Ha az alapértelmezett táblázatnézet cellákat vagy más programozott cellákat használja, regisztrálja az osztályt. Használjuk az osztályt, egyelőre!

adja hozzá a következő kódot a viewDidLoad() funkcióhoz:

tableView.register(UITableViewCell.self, forCellReuseIdentifier: "cellIdentifier")

feltétlenül adja hozzá a super.viewDidLoad() sor alá. Mint bizonyára tudják, a viewDidLoad() funkció a nézetvezérlő életciklusának része, és a UIViewController osztályba tartozik.

felülírja a viewDidLoad() funkciót, hogy reagáljon erre az eseményre egy nézetvezérlő életciklusában, így beállíthatja a nézetet a betöltése után. Esetünkben a függvényt használjuk a táblázatnézet cellájának regisztrálására.

amikor regisztrál egy táblázatnézet cellát, meg kell adnia egy azonosítót is. Ez egyszerűen a cella osztályát társítja egy később használható névvel, amikor a cellát tableView(_:cellForRowAt:) – ban leválasztja.

még mindig velem vagy? Menjünk tovább!

a “numberOfSections(in:)”végrehajtása

az első delegált funkció, amelyet megvalósítunk, a numberOfSections(in:).

a táblázatnézetnek több szakasza vagy csoportja is lehet. Minden csoportnak van egy fejléc, amely a függőleges cellasor tetején lebeg. A névjegyek alkalmazásban ábécé sorrendben csoportosíthatja a névjegyeket. Ez valójában az iPhone névjegyek alkalmazásában történik, ahol a Névjegyek A-Z csoportosítva vannak.

az általunk épített alkalmazásnak csak egy része van. Adja hozzá a következő függvényt az osztályhoz:

override func numberOfSections(in tableView: UITableView) -> Int{ return 1}

egyszerű, igaz? A függvény híváskor 1 értéket ad vissza.

végrehajtási “tableView(_:numberOfRowsInSection:)”

hasonló funkció tableView(_:numberOfRowsInSection:). A szakaszok számának megadása helyett a szakaszok sorainak számát adja meg. Mivel a táblázatnézet egy függőleges lista celláit mutatja, minden cella egy sornak felel meg a táblázatnézetben.

az általunk épített alkalmazásnak csak egy szakasza van, és az egyik szakaszban az elemek száma megegyezik a contacts tömbben található elemek számával. Tehát ez contacts.count!

adja hozzá a következő funkciót az osztályhoz:

override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int{ return contacts.count}

látod, hogy működik? Egyszerűen visszatérünk contacts.count. Ha egy másik nevet és telefonszámot adnál hozzá a contacts – hez, akkor ez szépen megjelenik a táblázat nézetben is.

a sorok és szakaszok megértése

a kapcsolatok alkalmazásunk egydimenziós, csak egy listát mutat a nevekről és a telefonszámokról, és nem használ csoportokat. De mi van, ha van egy csoportosított táblázat nézet?

a legtöbb esetben az adatforrás, mint például a contacts tömb, többdimenziós is lenne. A csoportokat az első szinten, az egyes elemeket pedig a második szinten, a csoportok “alatt” rendezné.

- Countries - A - Afghanistan - Albania - ... - B - Bahamas - Bahrain - ... - C - Cambodia - Cameroon - ...

a csoportok száma countries.count, az egyetlen csoportba tartozó országok száma pedig countries.count, ahol x a szakaszindex. Ez a szakaszindex paraméterként van megadva tableView(_:numberOfRowsInSection:).

cellák biztosítása a Táblázat nézet vezérlőhöz

odaérünk! Térjünk át a táblázatnézet-vezérlő legfontosabb funkciójára: tableView(_:cellForRowAt:).

végrehajtjuk a funkciót, mielőtt belemerülnénk a részletekbe, de van néhány dolog, amit meg kell értenie róla:

• amikor
• mi az index elérési útja
• hogyan használja újra a cellákat

először adja hozzá a következő függvényt a ContactsTableViewController osztályhoz:

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell{}

itt van, hogyan működik:

• a függvény felülbírálja a superclass implementációját UITableViewController – tól. Most már tudod, hogy működik, igaz? Felülírjuk az alapértelmezett megvalósítást, és helyettesítjük a sajátunkat. Ez azért van, mert a UITableViewController már megvalósította a táblázatnézet delegáltját és adatforrását számunkra.
• mint korábban, a függvénynek is van egy tableView paramétere, amellyel azonosíthatjuk a függvény meghívásának táblázatnézetét.
• egy másik paraméter a indexPath, argumentumcímkével cellForRowAt. Az index elérési útja azonosítja a cella row és section indexeit. Erről bővebben később.
• a függvény visszatérési típusa UITableViewCell. Hé, ez érdekes. Ezt a funkciót a Táblázat nézet vezérlő hívja meg, minden alkalommal, amikor meg kell adnunk egy táblázat nézet cellát!

amikor végiggörgeti a névjegyeket ebben az alkalmazásban, minden alkalommal, amikor egy cellát meg kell jeleníteni a képernyőn, a tableView(_:cellForRowAt:) funkciót hívják. Minden alkalommal! Mindjárt bebizonyítom.

ezután írjuk meg a függvény törzsét. Adja hozzá a következő kódot a funkcióba:

let cell = tableView.dequeueReusableCell(withIdentifier: "cellIdentifier", for: indexPath)print("\(#function) --- section = \(indexPath.section), row = \(indexPath.row)")cell.textLabel?.text = contactsreturn cell

itt van, mi történik:

• először egy azonosítóval rendelkező cellát leválasztunk. Pontosan ugyanaz az azonosító, amit korábban használtunk, amikor regisztráltuk a cellát. Így a Táblázat nézet tudja, hogy milyen típusú cellát akarunk. A dequeued cella a cell állandóhoz van hozzárendelve. Most van egy táblázat nézet cella dolgozni. További információ a dequeuing később.
• ezután kinyomtatunk néhány információt a konzolra. Ez azért van, hogy lássuk, mikor hívják ezt a funkciót, amikor az alkalmazás fut.
• ezután hozzárendeljük a névjegy nevét a táblázatnézet cellájának szövegcímkéjéhez. A contacts tartalmazza a kapcsolattartó nevének értékét, amelyet a indexPath.rowhasználatával érünk el. A UITableViewCell minden példányának van egy textLabel tulajdonsága a UILabel – ból, és minden ilyen típusú címkének van egy texttulajdonsága. Ezzel állíthatja be a szöveget a címkén.

ne aggódjon, ezeket a dolgokat részletesebben áttekintjük. Először nézze meg, hogy futtathatja-e az alkalmazást. Látja a kapcsolattartók nevét? Látja a hibakeresési kimenetet a konzolban? Próbálja meg görgetni az alkalmazást!

mikor hívják a “tableView(_:cellForRowAt:)” – t?

ha futtatta a névjegyek alkalmazást, és fel-le görgetéssel játszott, nem hagyhatja figyelmen kívül, hogy minden görgetéskor megjelenik a hibakeresés kimenete a konzolon.

minden alkalommal, amikor megjelenik egy olyan cella, amely korábban nem volt a képernyőn, a tableView(_:cellForRowAt:) függvény meghívásra kerül, és egy új sor jelenik meg a konzolban.

tehát mikor hívják tableView(_:cellForRowAt:)? Minden alkalommal, amikor egy táblázat nézet cellát meg kell jeleníteni a képernyőn!

a táblázatnézet-vezérlő megállapította, hogy cellára van szükség, ezért hívja a tableView(_:cellForRowAt:) számot. Ennek a függvénynek a megvalósítása leválasztja a cellát, megváltoztatja, és visszaadja a Táblázat nézet vezérlőnek. A table view controller és az UIKit framework ezután grafikusan jeleníti meg a képernyőn.

mi az Index elérési útja?

minden alkalommal, amikor a táblázatnézet-vezérlőnek szüksége van egy cellára a tableView(_:cellForRowAt:) – ból, egy index elérési utat biztosít a függvény argumentumaként. A függvénytesten belül a indexPath paraméter segítségével pontosan megtudhatja, hogy melyik cellára van szüksége a táblázatnézet vezérlőnek.

az index elérési útja olyan, mint egy cím vagy egy koordináta a rácsban. Egy tipikus gráfnak van egy X tengelye és egy Y tengelye, így a gráfban egy koordináta kifejezhető x, y – ként, mint például 0, 1és 42, 3. Hasonlóképpen, a táblázat sorokat és oszlopokat tartalmaz indexekkel.

a táblázatnézet szakaszokat és sorokat használ. Amint azt korábban tárgyaltuk, szakaszokkal csoportosíthatja a cellákat. Alkalmazásunknak csak egy szakasza van, és contacts.count sorai vannak. A táblázatnézet sorai fentről lefelé futnak.

másként mondta: a táblázatnézet szakaszai és sorai azt jelentik, hogy az oszlopok és sorok egy táblázathoz tartoznak. Az index elérési útja meghatároz egy helyet a táblázat nézetben egy sor és egy szakasz használatával.

a sorokat és szakaszokat számok, úgynevezett indexek képviselik. Ezek az indexek nulláról indulnak, így az első sor és szakasz indexszáma 0 lesz.

ha visszatekintünk az előző képernyőképre, sokkal értelmesebb. Az első cella index elérési útja 0, 0, a második cella 0, 1, az utolsó látható celláig folytatva index elérési út 0, 11.

a Táblázat nézet újrafelhasználási mechanizmusa

a táblázat nézetben a leginkább figyelemre méltó a cellák újrafelhasználásának mechanizmusa. Valójában elég egyszerű.

• minden alkalommal, amikor egy táblázatnézet-vezérlőnek meg kell mutatnia egy cellát a képernyőn, a tableView(_:cellForRowAt:) funkciót hívják meg, amint azt korábban tárgyaltuk.
• ahelyett, hogy minden alkalommal új táblázatnézet cellát hozna létre, amikor ezt a függvényt meghívják, kiválaszt egy korábban létrehozott cellát a várólistáról.
• a cella üres állapotba áll vissza, törli a megjelenését, és a cella ismét testreszabásra kerül tableView(_:cellForRowAt:) – ban.
• amikor egy cellát a képernyőn kívül görgetnek, az nem pusztul el. Ez hozzáadódik a várólistához, arra vár, hogy újra felhasználják.

elég okos, igaz? A cellák létrehozása és törlése helyett egyszerűen újra felhasználhatja őket. De … miért?

sokkal kevésbé memóriaigényes a sejtek újrafelhasználása. A táblázatnézet-vezérlő folyamatosan ír a memóriába cellák létrehozásakor és törlésekor. A memória kezelése szintén intenzívebb lenne. Amikor a cellákat újra felhasználják, a memóriát hatékonyabban használják fel, és kevesebb memóriaműveletre van szükség.

ezenkívül az itt valamivel kevésbé CPU-igényes a cellák újrafelhasználására ahelyett, hogy létrehozná vagy törölné őket, mert egyszerűen kevesebb művelet vesz részt az újrafelhasználásban, mint a cellák létrehozása és törlése.

amikor gyorsan végiggörget egy táblázatnézetet, nem új cellákat lát – ugyanazokat a cellákat látja újra és újra, új információkkal.

a cella újrafelhasználásával kapcsolatos kód ez:

let cell = tableView.dequeueReusableCell(withIdentifier: "cellIdentifier", for: indexPath)

a dequeueReusableCell(withIdentifier:) függvény megkísérli egy cella leválasztását. Ha nincsenek cellák a sorban, akkor létrehoz egy cellát számunkra. Az azonosító arra szolgál, hogy minden típusú cellát a saját sorában tartson, és hogy megbizonyosodjon arról, hogy a megfelelő osztályt használják új cellák létrehozásához.

válasz a felhasználói interakció

egy dolog hiányzik a Táblázat nézet vezérlő: a képesség, hogy hívja az embereket a névjegyzékben! De mielőtt ezt megtesszük, győződjünk meg arról, hogy a partner telefonszámát is láthatja a Táblázat nézet vezérlőjében.

az alapértelmezett UITableViewCell osztálynak 4 különböző típusa van, a UITableViewCellStyle felsorolásban kifejezve. Választhat a következők közül:

• .default – egyszerű nézet egy sor fekete szöveggel
• .value1 – egyszerű nézet, bal oldalon egy sor fekete szöveggel, jobb oldalon pedig egy kis kék címkével (a Beállítások alkalmazásban használható)
• .value2 – egyszerű nézet, jobb oldalon egy sor fekete szöveggel, bal oldalon pedig egy kis kék címkével (amelyet a névjegyek alkalmazásban használnak)
• .subtitle – egyszerű nézet egy sor fekete szöveggel, alatta pedig egy kisebb szürke szövegsor

a legtöbb fejlesztő manapság egyéni táblázatnézet cellákat használ, így ezeket a cellatípusokat nem fogja gyakran látni. De ott vannak!

kissé módosítanunk kell a kódot tableView(_:cellForRowAt:) – ban. Cserélje ki a függvény első sorát a következő kódra:

var cell = tableView.dequeueReusableCell(withIdentifier: "cellIdentifier")if cell == nil{ cell = UITableViewCell(style: .subtitle, reuseIdentifier: "cellIdentifier")}

ha közelebbről megnézed, látni fogod, hogy eltávolítottuk a for: indexPath hívás dequeueReusableCell(...) részét. Ehelyett ez a függvény most egy opcionális értéket ad vissza. Ha nem tud leválasztani egy cellát, a függvény nilértéket ad vissza.

ezután beugrunk magunkba, hogy létrehozzuk a cellát, ha nil. Ezt látja a kódex második részében. Feltételes if utasítás használatával ellenőrizheti, hogy a cell egyenlő-e nil – vel, és ha ez igaz, akkor a cellát a UITableViewCell(style:reuseIdentifier:) inicializálóval hozza létre.

az inicializáló két argumentumot kap, a .subtitle cellastílust és a korábban használt azonosítót.

ezen a ponton van egy probléma, mert cell egy opcionális most! A típusa UITableViewCell?, de a függvény visszatérési típusa megköveteli, hogy egy nem opcionális UITableViewCelltípusú példányt adjunk vissza.

szerencsére ez egyike azoknak az eseteknek, amikor biztonságosan használhatjuk az erőszakos kibontást az opcionális érték kibontásához. A kód írásának módja miatt lehetetlen, hogy cell nil legyen a feltételen túl. Garantálhatja, hogy a cell nem nil a if utasítás után.

győződjön meg róla, hogy frissíti a funkciót, hogy a force unrapping funkciót használja a cell esetén. Ezenkívül adja hozzá a következő kódsort cell!.textLabel ... a cella feliratának beállításához mutassa meg a partner telefonszámát.

cell!.detailTextLabel?.text = contacts

a teljes funkció most így néz ki:

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell{ var cell = tableView.dequeueReusableCell(withIdentifier: "cellIdentifier") if cell == nil { cell = UITableViewCell(style: .subtitle, reuseIdentifier: "cellIdentifier") } print("\(#function) --- section = \(indexPath.section), row = \(indexPath.row)") cell!.textLabel?.text = contacts cell!.detailTextLabel?.text = contacts return cell!}

végül távolítsa el a következő sort a viewDidLoad() – ből. Megakadályozza, hogy a táblázatnézet rossz típusú cellákat inicializáljon.

tableView.register(UITableViewCell.self, forCellReuseIdentifier: "cellIdentifier")

hatalmas finom! Futtassa az alkalmazást a Command + R vagy a Play gombbal, és ellenőrizze, hogy működik-e. Lát neveket és telefonszámokat? Jó!

ezután adjuk hozzá a PI-decision-decision függvényt A Pi-decision-decision-hez. Most, hogy megtanulta a táblázatnézet-vezérlő bonyodalmait, azt hiszem, már tudja, hogyan működik ez a következő funkció.

override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath){ if let url = URL(string: "tel://" + contacts) { UIApplication.shared.open(url) }}

ismét felülbíráljuk a tableView(_:didSelectRowAt:) függvény alapértelmezett megvalósítását. Ezt a függvényt akkor hívják meg, amikor a felhasználó megérinti a táblázatnézet celláját, és a UITableViewDelegate protokollhoz tartozik. A többi funkcióhoz hasonlóan ez is biztosítja a megérintett cella index elérési útját.

a függvénytörzsben egyszerűen létrehozunk egy tel:// URL-t a telefonszámból. Ezután azt mondjuk az alkalmazásnak, hogy nyissa meg ezt az URL-t, amely gyakorlatilag azt mondja az iOS-nek, hogy kezdeményezzen hívást erre a számra. Ez a kód csak illusztrációs célokat szolgál. Ne feledje, hogy ez nem működik az iPhone szimulátoron, és hogy az alkalmazásunkban szereplő számok hamisak. (Mégis, akkor használja ezt a kódot, ha így egy igazi Kapcsolatok app!)

a következő kódot adhatja hozzá a funkcióhoz, ha ellenőrizni szeretné, hogy jól működik-e.

print("\(#function) --- Calling: \(contacts)")

ez egy hibakeresési üzenetet nyomtat ki, amikor megérinti a Táblázat nézet celláját.

további olvasmányok

és ennyi az egész! Elég nagy utazás volt, de most már tudja, hogyan működik az asztalnézet-vezérlő.