In het vorige artikel hebt u geleerd over variabelen, constanten en enkele veelvoorkomende gegevenstypen, zoals gehele getallen, drijvers en reeksen. In dit artikel zoomen we in op collecties. De standaardbibliotheek van Swift definieert drie soorten verzamelingen: sets, arrays en woordenboeken. Laten we beginnen met arrays.
1. Arrays
Als u bekend bent met Objective-C, JavaScript of PHP, is het niet moeilijk om arrays te begrijpen. Een array is een geordende, nul geïndexeerde verzameling waarden. Maar er zijn een paar belangrijke verschillen tussen arrays voor Swift en andere programmeertalen.
Type
Het eerste belangrijke verschil met arrays in Objective-C is dat de waarden die in een array zijn opgeslagen altijd van hetzelfde type zijn. In eerste instantie lijkt dit een belangrijke beperking, maar dat is het in feite niet. In feite heeft deze beperking een belangrijk voordeel. We weten precies welk type we terug krijgen als we de array vragen naar een van zijn waarden.
Een ander belangrijk verschil is het type waarden dat een array kan opslaan. In Objective-C kan een array alleen waarden van een klassetype opslaan. Snel heeft deze beperking niet. Een array in Swift kan tekenreeksen, gehele getallen, drijvers en klasseninstanties opslaan. Hoe dit werkt en waarom dit mogelijk is in Swift, zal later in deze serie duidelijk worden wanneer we klassen en structuren behandelen.
Verklaring
Hoewel er verschillende manieren zijn om een array te maken, moet u er rekening mee houden dat Swift moet weten welk type waarden u in de array wilt opslaan. Maak een nieuwe speeltuin in Xcode, zoals we in het vorige artikel hebben gedaan, en voeg de volgende regels toe aan je speeltuin.
var array1: Array var array2: [String] var array3 = ["Apple", "Pear", "Orange"]
De eerste en tweede regel betekenen hetzelfde. De tweede regel is gewoon steno. De vierkante haakjes wikkelen de Draad keyword vertel Swift dat we een array declareren die alleen kan bevatten Draad voorwerpen.
Je zou de eerste regel code kunnen lezen als: "We declareren een variabele met de naam array1van type reeks dat kan alleen bevatten Draad objecten. "De dubbele punt betekent van type.
De derde regel laat zien hoe een array met behulp van een array letterlijk moet worden geïnitialiseerd. Array-lettertypen lijken veel op array-letterwoorden in Objective-C. Het grootste verschil is de afwezigheid van de @ symbool voorafgaand aan de vierkante haken en de letterlijke tekenreeks.
Er is ook een mooie manier om een array te initialiseren met een vooraf gedefinieerd aantal standaardwaarden. De syntaxis kan in het begin verwarrend zijn, maar neem even de tijd om deze te laten zinken.
var a = [String] (herhalen: "Test", tel: 5)
De resulterende array bevat vijf reeksen, waarbij elke reeks gelijk is aan "Test". Om de bovenstaande initialisatie beter te begrijpen, bekijk je de volgende twee coderegels waarin we een lege array van strings initialiseren.
var b = Array() var c = [String] ()
Maak je geen zorgen als je nog steeds in de war bent. We zullen de syntaxis gedetailleerder verkennen zodra we beginnen met het behandelen van klassen en functies. In dit artikel richten we ons alleen op collecties.
veranderlijkheid
Een aspect van Swift dat je snel gaat waarderen, is hoe je veranderlijke verzamelingen declareert. Het bovenstaande codefragment verklaart bijvoorbeeld drie veranderbare arrays. Een veranderlijke array wordt gedefinieerd met behulp van de var trefwoord. Het is zo simpel.
Als u niet wilt dat een array kan worden gewijzigd, gebruikt u de laat sleutelwoord in plaats daarvan. Swift wil intuïtief en gebruiksvriendelijk zijn en de implementatie van veranderbaarheid is een perfect voorbeeld van dat doel.
Waarden verkrijgen en instellen
Voor toegang tot de waarden die in een array zijn opgeslagen, gebruiken we dezelfde subscriptsyntaxis als in Objective-C. In het volgende voorbeeld vragen we array3 voor zijn tweede element, de string "Peer".
array3 [1]
De waarde vervangen die is opgeslagen bij index 1 is net zo eenvoudig als het toewijzen van een nieuwe waarde met dezelfde subscriptsyntaxis. In het volgende voorbeeld vervangen we "Peer" op index 1 met "Perzik".
array3 [1] = "Perzik"
Dit is alleen mogelijk omdat de array veranderbaar is, dat wil zeggen dat we de array hebben gebruikt var sleutelwoord om de array te declareren. Het muteren van een constante array is niet mogelijk. Er zijn meer geavanceerde technieken voor het manipuleren van de inhoud van een array, maar het onderliggende concept is hetzelfde.
Het samenvoegen van twee arrays is net zo eenvoudig als het bij elkaar optellen. In het volgende voorbeeld verklaren en voegen we twee onveranderlijke arrays samen. Merk op dat de resulterende array, c, hoeft niet te worden gewijzigd om dit te laten werken.
laat a = [1, 2, 3] laat b = [4, 5, 6] laat c = a + b
Het is echter belangrijk dat de waarden worden opgeslagen in een en b zijn van hetzelfde type. De reden zou nu duidelijk moeten zijn. Zoals ik eerder al zei, moeten de waarden die in een array zijn opgeslagen van hetzelfde type zijn. Het volgende voorbeeld resulteert in een fout.
laat a = [1, 2, 3] laat b = [1.5, 5.2, 6.3] laat c = a + b
Om een array aan een veranderlijke array toe te voegen, gebruiken we de += operator. Merk op dat de operand aan de rechterkant een array is. Deze bewerking zou niet werken als we de vierkante haakjes eromheen verwijderen 4.
var a = [1, 2, 3] a + = [4]
Activiteiten
Arrays zijn objecten waarop u een breed scala aan bewerkingen kunt uitvoeren. Arrays stellen een aantal functies of methoden bloot. Om een methode op een object op te roepen, gebruikt u de puntnotatie. Voeg de volgende regel toe aan je speeltuin om een item aan toe te voegen array3.
array3.append ( "Cherry")
Laten we eens kijken hoeveel items array3 bevat door de waarde ervan te inspecteren tellen eigendom. Dit levert op 4 naar het resultatenvenster.
array3.count
Het is ook mogelijk om een item in een specifieke index in te voegen door de array's in te roepen invoegen (_: bij :) methode zoals hieronder getoond. De invoegen (_: bij :) methode accepteert meer dan één parameter en de syntaxis kan in eerste instantie een beetje vreemd lijken.
array3.insert ("Prune", op: 2)
Net als Objective-C ondersteunt Swift parameters met de naam om de leesbaarheid te verbeteren. Het resultaat is dat code gemakkelijker te lezen en te begrijpen is en dat functies of methoden niet veel uitleg behoeven in termen van wat ze doen. Het is bijvoorbeeld duidelijk dat de invoegen (_: bij :) methode voegt een element in bij index 2.
Hoewel Swift beknopter en minder uitgebreid is dan Objective-C, ondersteunt het benoemde parameters. Als je afkomstig bent van PHP, Ruby of JavaScript, dan is dit zeker iets dat even wennen is.
Gemaksmethoden
Wat ik erg leuk vind aan Swift zijn de Ruby-achtige gemakseigenschappen en methoden van de standaardbibliotheek van Swift. Een array heeft bijvoorbeeld een is leeg eigenschap die u vertelt of de array elementen bevat. Dit is niets meer dan steno voor het controleren van de array's tellen eigendom. Het resultaat is echter een code die beknopter is en gemakkelijker te lezen.
array3.isEmpty
2. Woordenboeken
Woordenboeken werken op dezelfde manier als woordenboeken in Objective-C. Een woordenboek bewaart een ongeordende verzameling waarden. Elke waarde in het woordenboek is gekoppeld aan een sleutel. Met andere woorden, een woordenboek slaat een aantal sleutel- / waardeparen op.
Type
Net als bij arrays moeten de sleutels en waarden die in een woordenboek zijn opgeslagen van hetzelfde type zijn. Dit betekent dat als u een woordenboek om de waarde van een bepaalde sleutel vraagt, u weet welk type het woordenboek zal retourneren.
Verklaring
Het declareren van een woordenboek lijkt op het declareren van een array. Het verschil is dat u het type voor zowel sleutels als waarden moet opgeven. In het volgende voorbeeld ziet u drie manieren om een woordenboek te declareren.
var dictionary1: Dictionary var dictionary2: [String: Int] var dictionary3 = ["Apple": 3, "Pear": 8, "Orange": 11]
De tweede regel is een afkorting voor de eerste regel. De sleutels van deze woordenboeken moeten van het type zijn Draad terwijl de waarden naar verwachting van het type zijn Int. De var trefwoord geeft aan dat de woordenboeken muteerbaar zijn.
Je zou de eerste regel code kunnen lezen als: "We declareren een variabele met de naam dictionary1van typeWoordenboek die alleen sleutels van het type kan bevatten Draad en waarden van het type Int."
De derde regel illustreert hoe we een woordenboek kunnen initialiseren met behulp van een letterlijke woordenlijst. Dit is vergelijkbaar met de syntaxis die we gebruiken in Objective-C, maar houd er rekening mee dat de accolades worden vervangen door vierkante haakjes en de letterlijke tekst is niet voorafgegaan door een @ symbool.
Waarden verkrijgen en instellen
Het benaderen van waarden lijkt op het benaderen van waarden van een array. Het enige verschil is dat u de sleutel gebruikt in plaats van de index van de waarde die u moet gebruiken. Het volgende voorbeeld illustreert dit.
let value = dictionary3 ["Apple"] print (waarde)
U zult opmerken dat Xcode ons vertelt dat de waarde van waarde is niet 3, maar Optioneel (3). Wat betekent dit? Swift gebruikt optionals om waarden in te pakken die een van twee dingen kunnen zijn, een waarde of nul. Maak je op dit moment geen zorgen over optionals. We gaan focussen op optionals in het volgende artikel van deze serie. Laat me je vertellen dat optionals een ander sleutelbegrip zijn van de Swift-programmeertaal.
Het is interessant om erop te wijzen dat de syntaxis om toegang te krijgen tot een waarde van een woordenboek identiek is aan die van arrays als de sleutels van het woordenboek van het type zijn Int. Bekijk het volgende voorbeeld om te zien wat ik bedoel.
var dictionary4 = [0: "Apple", 1: "Pear", 2: "Orange"] let fruit = dictionary4 [0]
Activiteiten
Net als bij arrays definieert de Swift-standaardbibliotheek een breed scala aan bewerkingen die u in woordenboeken kunt uitvoeren. U kunt een woordenboek om zijn aantal sleutel / waardeparen vragen via zijn tellen eigendom. Het verwijderen van een sleutel / waarde-paar is gemakkelijk en intuïtief, zoals het volgende voorbeeld illustreert. Dit is natuurlijk alleen mogelijk als het woordenboek muteerbaar is.
dictionary4.removeValue (forKey: 0)
Wanneer je Swift begint te leren, kom je misschien codefragmenten tegen die er vreemd of verwarrend uitzien. Bekijk de volgende regel, waarin we eerst een woordenboek declareren en vervolgens de sleutel / waarde-paren verwijderen.
Je moet toegeven dat de laatste regel een beetje vreemd lijkt. Omdat Swift de soorten sleutels en waarden kent die kunnen worden opgeslagen woordenboek, het legen van het woordenboek is net zo eenvoudig als het toewijzen van een leeg woordenboek eraan.
Het is niet nodig om de typen voor de sleutels en waarden in dit geval op te geven, omdat we dit al deden toen we het woordenboek op de eerste regel verklaarden. Dit wijst op een ander belangrijk detail, dat wil zeggen, het soort waarden dat u in arrays kunt opslaan en woordenboeken die niet kunnen worden gewijzigd zodra de verzameling is gedeclareerd.
3 sets
Sets lijken sterk op arrays omdat ze een verzameling waarden van hetzelfde type opslaan. Maar er zijn verschillende belangrijke verschillen. De elementen die in een set zijn opgeslagen, zijn ongeordend en elk item kan maar één keer in een set worden weergegeven.
Verklaring
Het werken met sets is een beetje anders dan het werken met arrays. Bekijk de volgende voorbeelden waarin we drie sets declareren. De set1 variabele is van het type set, een set die alleen waarden van het type kan bevatten Draad.
var set1: Set var set2 = Instellen() var set3: Set = ["Apple", "Peer", "Oranje"]
De set2 variabele is een lege set en we gebruiken een array letterlijk in het derde voorbeeld om een muteerbare set te maken en te vullen die drie waarden bevat. Dankzij de gevolgtrekking van Swift kunnen we het type set weglaten.
var set3: Set = ["Apple", "Pear", "Orange"]
Sets manipuleren
Werken met sets is vergelijkbaar met het werken met arrays. We kunnen het aantal elementen dat in een set is opgeslagen vragen door de sets te inspecteren tellen eigendom.
set3.count
Een element invoegen is eenvoudig. Omdat de elementen van een set niet zijn geordend, hoeven we de locatie van het nieuwe element niet op te geven.
set3.insert ( "Prune")
En hetzelfde geldt voor het verwijderen van een element uit een set.
set3.remove ( "Orange")
U kunt ook een set vragen als deze een bepaald element bevat.
set3.contains ( "Apple")
Reeksen of reeksen
Ik verwijs vaak naar sets als lichtgewicht versies van arrays. Als de volgorde van de elementen niet belangrijk is of als je zeker wilt weten dat elk element maar één keer in een verzameling kan voorkomen, zijn sets de juiste keuze.
4. Tupels
Je zult dol zijn op tuples. Tuples zijn geen collecties, maar net als collecties groeperen ze ook meerdere waarden. Net als bij arrays en woordenboeken, kunnen tuples waarden van elk type bevatten. Het belangrijkste verschil is echter dat de waarden die zijn opgeslagen in een tuple niet van hetzelfde type hoeven te zijn. Laten we een voorbeeld bekijken om dit in meer detail uit te leggen.
import Foundation var currency = ("EUR", 0.81) var time = (Datum (), "Dit is mijn bericht.") var email = ("Bart Jacobs", "[email protected]")
In het eerste voorbeeld wordt een tuple genoemd valuta dat is van het type (String, Int). Het tweede tuple, tijd, bevat een Datum exemplaar en een letterlijke tekenreeks. De waarden die zijn opgeslagen in e-mail zijn beide van het type Draad, wat betekent e-mail is van het type (String, String).
Toegang tot waarden
Indexes
Om toegang te krijgen tot een waarde opgeslagen in een tuple, gebruikt u de index die overeenkomt met de waarde waarin u geïnteresseerd bent.
var rate = currency.1 var message = time.1 var name = email.0
Xcode toont ons de indexen van elke waarde opgeslagen in een tupel in het resultatenvenster van de speelplaats aan de rechterkant.
namen
Om de leesbaarheid te verbeteren, kunt u de waarden noemen die zijn opgeslagen in een tuple. Het resultaat is dat u via hun namen toegang kunt krijgen tot de waarden van het tuple in plaats van hun indexen. Het declareren van een tuple is in dat geval iets anders.
var currency = (name: "EUR", rate: 0.81) let currencyName = currency.name laat currencyRate = currency.rate
Ontleding
Er is een tweede, elegantere manier om met de waarden te werken die in een tuple zijn opgeslagen. Bekijk het volgende voorbeeld waarin we de inhoud van ontleden valuta.
let (currencyName, currencyRate) = valuta
De waarde van valuta op index 0 is opgeslagen in currencyName, en de waarde bij index 1 is opgeslagen in wisselkoers. Het is niet nodig om het type op te geven currencyName en wisselkoers omdat Swift het type afleidt van de waarden die zijn opgeslagen in valuta. Met andere woorden, currencyName is van het type Draad, en wisselkoers is van het type Vlotter.
Als u alleen geïnteresseerd bent in specifieke waarden van een tuple, kunt u een onderstrepingsteken gebruiken om Swift te laten weten in welke waarden u niet bent geïnteresseerd.
let (currencyName, _) = valuta
Conclusie
Arrays en woordenboeken zijn fundamentele componenten van bijna elke programmeertaal en Swift is niet anders. Terwijl collecties zich in Swift een beetje anders gedragen, duurt het niet lang om bekend te raken met Swift's verzamelingstypen als je hebt gewerkt met arrays en woordenboeken in andere programmeertalen. In de volgende tutorial verkennen we optioneel en sturen we de flow aan.
Leer Swift
We hebben een complete gids samengesteld om je te helpen snel te leren, of je nu net begint met de basis of als je meer geavanceerde onderwerpen wilt verkennen.
Als je snel met de Swift-taal aan de slag wilt, bekijk dan onze cursus over het maken van iOS-apps met Swift.
Of bekijk enkele van onze andere tutorials en cursussen over Swift- en iOS-ontwikkeling!
Share
Accentsconagua
