Share
Met de release van Swift 2 heeft Apple een reeks nieuwe functies en mogelijkheden toegevoegd aan de Swift-programmeertaal. Een van de belangrijkste was echter een herziening van de protocollen. De verbeterde functionaliteit die beschikbaar is met Swift-protocollen maakt een nieuw type programmeren, protocolgeoriënteerd programmeren mogelijk. Dit staat in contrast met de meer algemene objectgeoriënteerde programmeerstijl die velen van ons gewend zijn.
In deze tutorial laat ik je de basis zien van protocolgeoriënteerd programmeren in Swift en hoe het verschilt van objectgeoriënteerd programmeren.
Deze tutorial vereist dat je Xcode 7 of hoger gebruikt, inclusief ondersteuning voor versie 2 van de Swift-programmeertaal.
Als u nog niet bekend bent met protocollen, zijn ze een manier om de functionaliteit van een bestaande klasse of structuur uit te breiden. Een protocol kan worden gezien als een blauwdruk of interface die een reeks eigenschappen en methoden definieert. Een klasse of structuur die voldoet aan een protocol is vereist om deze eigenschappen en methoden in te vullen met respectievelijk waarden en implementaties.
Er moet ook worden opgemerkt dat een van deze eigenschappen en methoden als optioneel kan worden aangemerkt, wat betekent dat er geen conforme typen nodig zijn om ze uit te voeren. Een protocoldefinitie en klasse-conformiteit in Swift kunnen er als volgt uitzien:
protocol Welkom var welcomeMessage: String get set optioneel func welcome () class Welcomer: Welcome var welcomeMessage = "Hello World!" func welcome () print (welcomeMessage)
Om te beginnen opent u Xcode en maakt u een nieuwe speeltuin voor iOS of OS X. Nadat Xcode de speeltuin heeft gemaakt, vervangt u de inhoud door het volgende:
protocol Drivable var topSpeed: Int get protocol Omkeerbaar var reverseSpeed: Int get protocol Transport var seatCount: Int get
We definiëren drie protocollen die elk een eigenschap bevatten. Vervolgens maken we een structuur die voldoet aan deze drie protocollen. Voeg de volgende code toe aan de speeltuin:
struct Auto: Drivable, Reversible, Transport var topSpeed = 150 var reverseSpeed = 20 var seatCount = 5
Je hebt misschien gemerkt dat we een structuur hebben gemaakt in plaats van een klasse te maken die voldoet aan deze protocollen. We doen dit om een van de typische problemen te voorkomen die inherent zijn aan objectgeoriënteerd programmeren, objectreferenties.
Stel u bijvoorbeeld voor dat u twee objecten hebt, A en B. A maakt enkele gegevens op zichzelf en houdt een verwijzing naar die gegevens bij. A deelt deze gegevens vervolgens met B als referentie, wat betekent dat beide objecten een verwijzing naar hetzelfde object hebben. Zonder een weten, verandert B de gegevens op de een of andere manier.
Hoewel dit misschien geen groot probleem lijkt, kan het zijn dat A niet verwachtte dat de gegevens zouden worden gewijzigd. Object A kan gegevens vinden waarvan het niet weet hoe het moet omgaan of waarmee het moet omgaan. Dit is een algemeen risico van objectreferenties.
In Swift worden structuren gepasseerd waarde in plaats van door referentie. Dit betekent dat in het bovenstaande voorbeeld, als de gegevens die door A zijn gemaakt, werd verpakt als een structuur in plaats van een object en gedeeld met B, de gegevens zouden worden gekopieerd in plaats van gedeeld door verwijzing. Dit zou er vervolgens toe leiden dat zowel A als B hun eigen unieke kopie van hetzelfde stuk gegevens hebben. Een wijziging door B zou geen invloed hebben op de kopie beheerd door A.
Het doorbreken van de verrijdbaar, omkeerbaar, en Vervoer componenten in individuele protocollen maakt ook meer maatwerk mogelijk dan traditionele klasse-overerving. Als je mijn eerste tutorial over het nieuwe GameplayKit-framework in iOS 9 hebt gelezen, lijkt dit protocolgeoriënteerde model sterk op de structuur Entities en Componenten die in het GameplayKit-framework wordt gebruikt.
Door deze aanpak toe te passen, kunnen aangepaste gegevenstypen functionaliteit van meerdere bronnen overnemen in plaats van een enkele superklasse. Met in het achterhoofd wat we tot nu toe hebben gemaakt, kunnen we de volgende klassen maken:
Accentsconagua
verrijdbaar en omkeerbaar protocollenverrijdbaar en vervoerbaar protocollenomkeerbaar en vervoerbaar protocollenMet objectgeoriënteerd programmeren, zou de meest logische manier om deze drie klassen te creëren, zijn om te erven van één superklasse die de componenten van alle drie de protocollen bevat. Deze benadering resulteert er echter in dat de superklasse ingewikkelder is dan het moet zijn en dat elk van de subklassen meer functionaliteit erven dan het nodig heeft.
Alles wat ik tot nu toe heb laten zien, is mogelijk sinds de release in 2014 in Swift. Deze protocolgeoriënteerde concepten konden zelfs zijn toegepast op Objective-C-protocollen. Vanwege de beperkingen die in protocollen bestonden, was echte protocolgeoriënteerde programmering echter niet mogelijk totdat een aantal belangrijke functies in versie 2 aan de Swift-taal werden toegevoegd. Een van de belangrijkste van deze functies is protocol uitbreidingen, inclusief voorwaardelijke uitbreidingen.
Allereerst, laten we het uitbreiden verrijdbaar protocol en voeg een functie toe om te bepalen of een bepaalde al dan niet een is verrijdbaar is sneller dan een andere. Voeg het volgende toe aan je speeltuin:
extension Drivable func isFasterThan (item: Drivable) -> Bool return self.topSpeed> item.topSpeed let sedan = Car () laat sportsCar = Auto (topSpeed: 250, reverseSpeed: 25, seatCount: 2) sedan.isFasterThan (sportwagen)
Je kunt zien dat wanneer de code van de speeltuin wordt uitgevoerd, deze een waarde van uitvoert valsals jouw sedan auto heeft een standaardwaarde top snelheid van 150, wat minder is dan de sportwagen.
Je hebt misschien gemerkt dat we een functie hebben geleverd definitie in plaats van een functie verklaring. Dit lijkt vreemd, omdat protocollen alleen verklaringen zouden moeten bevatten. Rechts? Dit is een andere zeer belangrijke functie van protocol-uitbreidingen in Swift 2, standaard gedrag. Door een protocol uit te breiden, kunt u een standaardimplementatie bieden voor functies en berekende eigenschappen, zodat klassen die aan het protocol voldoen niet hoeven te doen.
Vervolgens gaan we een andere definiëren verrijdbaar protocolextensie, maar deze keer definiëren we deze alleen voor waardetypen die ook voldoen aan de omkeerbaar protocol. Deze extensie bevat dan een functie die bepaalt welk object het beste snelheidsbereik heeft. We kunnen dit bereiken met de volgende code:
extension Drivable where Self: Reversible func hasLargerRangeThan (item: Self) -> Bool return (self.topSpeed + self.reverseSpeed)> (item.topSpeed + item.reverseSpeed) sportsCar.hasLargerRangeThan (sedan)
De Zelf sleutelwoord, gespeld met een hoofdletter "S", wordt gebruikt om de klasse of structuur weer te geven die overeenkomt met het protocol. In het bovenstaande voorbeeld, de Zelf sleutelwoord vertegenwoordigt het Auto structuur.
Na het uitvoeren van de code van de speelplaats, zal Xcode de resultaten weergeven in de zijbalk aan de rechterkant, zoals hieronder getoond. Let daar op sportwagen heeft een groter bereik dan sedan.
Hoewel het definiëren en uitbreiden van uw eigen protocollen zeer nuttig kan zijn, wordt de ware kracht van protocol-extensies weergegeven wanneer u met de Swift-standaardbibliotheek werkt. Hiermee kunt u eigenschappen of functies toevoegen aan bestaande protocollen, zoals CollectionType (gebruikt voor zaken als arrays en woordenboeken) en gelijk te stellen (kunnen bepalen wanneer twee objecten gelijk zijn of niet). Met voorwaardelijke protocoluitbreidingen kunt u ook zeer specifieke functionaliteit bieden voor een specifiek type object dat voldoet aan een protocol.
In onze speeltuin breiden we de CollectionType protocol en maak twee methoden, een om de gemiddelde topsnelheid van auto's in een te krijgen Auto array en een andere voor de gemiddelde snelheid achteruit. Voeg de volgende code toe aan je speeltuin:
