Share
Op WWDC 2014 introduceerde Apple een van de grootste updates voor iOS sinds 2008 vanuit het oogpunt van een ontwikkelaar. Ze introduceerden HomeKit, HealthKit, CloudKit en Extensions om er maar een paar te noemen. Maar de grootste verrassing van WWDC 2014 was de introductie van een geheel nieuwe programmeertaal, Swift.
Swift is een prachtige programmeertaal die van de grond af is opgebouwd om efficiënt en veilig te zijn. Het gebruikt dezelfde API's als Objective-C. Of, wat u kunt doen in Objective-C, kunt u doen in Swift. Het introduceert ook een aantal nieuwe concepten die programmeurs voor de lange termijn zullen waarderen en waarvan ik sommige in deze introductieserie over Swift zal behandelen.
In deze serie ga ik ervan uit dat je al bekend bent met Objective-C. In het eerste artikel van deze serie, praat ik over Swift's filosofie, bestandsstructuur en syntaxis. In het tweede artikel zoom ik in op meer geavanceerde aspecten van Swift's syntaxis, zoals optionals en geheugenbeheer. Wacht even op je hoedjes, mensen, het wordt een doozy.
Om Swift beter te begrijpen, heeft Apple ons geconditioneerd met structurele verbeteringen in Objective-C in de afgelopen paar jaar. Objective-C-verbeteringen, zoals codeblokken, letterlijke array- en woordenboekdefinities, en ARC (Automatic Reference Counting) zijn maar een paar dingen die Apple heeft toegevoegd aan Objective-C die de overgang naar Swift vergemakkelijken.
Een belangrijke pijler van Swift's filosofie is code-initialisatie. Alle objecten en variabelen die in Swift zijn gedefinieerd, moeten in code worden geïnitialiseerd. Een niet-geïnitialiseerd object of variabele resulteert in een compile time error in Swift. Dit zorgt ervoor dat een object of variabele altijd een waarde heeft. Er is één speciaal geval in Swift voor wanneer een beginwaarde niet kan worden gedefinieerd. In dit speciale geval wordt uw variabele een genoemd facultatief. We zullen optionals behandelen in het tweede deel van deze serie.
Een andere belangrijke pijler is de volledigheid van branches. Alle voorwaardelijke takken, of het nu is als of switch / case, moet alle voorwaarden dekken. Op deze manier kan er geen code doorkomen zonder dat deze wordt afgedekt. Het missen van een voorwaarde in uw takinstructie zal worden betrapt en een compilatietijdfout genereren.
Een laatste element van de filosofie van Swift is zijn voorkeur voor constanten boven variabelen. Swift definieert variabelen en constanten op de volgende manier:
let someConstant: String = "Dit is een constante" var someVariable: String = "Dit is een variabele"
In het bovenstaande voorbeeld, de laat trefwoord wordt gebruikt om een constante te definiëren terwijl de var trefwoord definieert een variabele. Door de definitie van constanten zo eenvoudig te maken, moedigt Apple het gebruik van constanten aan waar mogelijk. Dit leidt tot veiligere code in een multithread-omgeving en betere code-optimalisatie omdat de compiler weet dat de waarde van een constante niet zal veranderen.
Nu is Swift veel meer dan een paar syntaxis- en opmaakverbeteringen. Swift is vanaf de grond opgebouwd om veel voorkomende C / C ++ en inherent objectieve C-bronnen van crashes op te lossen. Zaken als:
Als iemand die programmeert voor zowel iOS als Android, weet ik uit de eerste hand hoe leuker het coderen voor het iOS-platform is, met Cocoa en UIKit. Deze serie laat je zien hoeveel leuker codering kan zijn door Swift aan de mix toe te voegen.
In Objective-C hebben we hoofd bestanden (.h) en implementatie bestanden (.m). Dit is iets Objective-C geërfd van de C-taal.
In Swift wordt een klasse gedefinieerd in een enkel implementatiebestand (.snel) die alle definities en implementaties van de klasse bevat. Dit doet denken aan andere talen zoals Java en C #.
Voorbij is de noodzaak om header-bestanden te jongleren en het vervelende toe te voegen #IFNDEF bovenaan koptekstbestanden.
Het eerste dat je opvalt aan Swift is het verdwijnen van de puntkomma aan het einde van elke uitspraak. In Swift wordt elke regel als een statement beschouwd en wij niet moet voeg aan het einde van elke regel een puntkomma toe.
Ik benadruk moet, omdat niets u ervan weerhoudt om aan het einde van uw verklaringen puntkomma's toe te voegen. Ik zal doorgaan met het toevoegen van puntkomma's aan het einde van elke instructie, omdat ik denk dat dit de leesbaarheid verhoogt. Het is ook heel moeilijk om af te zien van de gewoonte om puntkomma's toe te voegen, zoals Cocoa-ontwikkelaars al jaren doen.
Een andere belangrijke verandering in Swift is dat accolades verplicht zijn als statements. Dat betekent geen Heartbleed-bugs meer.
Syntaxis kan een complex onderwerp zijn om over te schrijven. Swift heeft veel subtiliteiten die heel lang kunnen duren om over te gaan, maar dat is niet het doel van dit artikel. Om het kort te houden, zal ik me concentreren op de veranderingen die een ontwikkelaar van Objective-C zou opmerken.
Ik begin met het tonen van drie codefragmenten die enkele overeenkomsten met Objective-C illustreren. Het zal je helpen bij het begrijpen van de Swift-taal.
Accentsconagua
// Objective-C voor (int index = 0; index < 5; i++) NSLog(@"%d",index); // Swift for index in 1… <5 plrintln("\(index)"); // Objective-C-schakelaar (index) case 0: break; geval 1: pauze; standaard: pauze; // Swift-schakelaar (index) case 0: case 1: default: // geen break-instructie
// Objective-C if (index == 0) // Swift if index == 0 // haakjes zijn optioneel // accolades zijn verplicht
Objectief-C-programmeurs zullen ontdekken dat Swift dezelfde branch- en iteratieverklaringen kent die u al kent, zoals if / else, voor loops, voor in loops en schakelaar statements.
Swift omvat twee bereikoperatoren, ... < en ... , om een bereik van waarden op te geven. In bovenstaande voor loop, we gebruiken de operator met half gesloten bereik, ... <, om een bereik van waarden op te geven die 1, 2, 3 en 4 bevatten, maar dit is exclusief 5. De andere bereikoperator is de operator met gesloten bereik, ... . Het specificeert een bereik van waarden die de waarde aan beide zijden van de operator met gesloten bereik omvat. Bijvoorbeeld, 1 ... 5. geeft een bereik van waarden op van 1 tot 5, inclusief 5.
Laten we het voorbeeld opnieuw bekijken dat ik u eerder heb laten zien.
let someConstant: String = "Dit is een constante"; var someVariable: String = "Dit is een variabele";
In Swift definiëren we constanten met behulp van de laat trefwoord en variabelen met behulp van de var trefwoord. De dubbele punt, : ,is een markering om typen te definiëren. In het bovenstaande voorbeeld maken we een constante en een variabele van het type Draad.
We initialiseren ook de constante en de variabele met een tekenreeks. In Swift worden tekenreeksen net als C-strings gedefinieerd in Objective-C, ze worden niet voorafgegaan door een @ symbool.
Object-C is een sterk getypte taal, wat betekent dat het type variabele of parameter altijd moet worden opgegeven. Swift is ook een sterk getypte taal, maar Swift is een beetje slimmer omdat de compiler het type van een variabele zal afleiden. De compiler zorgt er ook voor dat er geen onjuiste casting van variabelen plaatsvindt zonder uw expliciete kennis en interventie.
Als we het bovenstaande voorbeeld van het releasetype van verwijzingen herschrijven, ziet het codefragment er als volgt uit:
let someConstant = "Dit is een constante"; var someVariable = "Dit is een variabele"; laat someInt = 1; laat someFloat = 1.0;
Dit is veel beter en de code is veel schoner. De compiler is slim genoeg om dat te begrijpen someInt is een Int en someFloat is een Dubbele.
Een manier om een idee te krijgen van de kracht van een taal is door te onderzoeken hoe het omgaat met stringmanipulatie. Objective-C heeft veel functies en functies die ons in staat stellen om strings aan te kunnen, beter dan de meeste talen, maar ze zijn vaak verwarrend en verwarrend van tijd tot tijd.
Laten we beginnen met een Objective-C-voorbeeld. Om twee strings aaneen te schakelen in Objective-C doen we het volgende:
NSString * string = @ "Hallo"; NSString * greeting = [string stringByAppendingString: @ "World!"];
Om in Swift een string aan een andere string toe te voegen, gebruiken we de + operator. Het is zo simpel.
laat string = "Hallo" laat groet = string + "Wereld!"
Strings in Swift zijn Unicode, wat betekent dat we kunnen schrijven:
laat string = "你好 世界"
We kunnen de karakters van een string herhalen met een voor in verklaring zoals getoond in het volgende voorbeeld. We kunnen een gebruiken voor in lus om ook Unicode-reeksen te herhalen. Het is echt zo gaaf.
laat str = "Hallo"; voor char in str println (char); // uitgangen // H // e // l // l // o
Een laatste ding dat ik graag wil bespreken over tekenreeksen voordat ik verder ga, is tekenreeksinterpolatie. In Objective-C, als we een string met variabelen willen uitvoeren, roepen we aan [NSString stringWithFormat:]. In Swift kunnen variabelen worden ingesloten. Bekijk het volgende voorbeeld.
laat x = 4; laat y = 5; println ("\ (x) x \ (y) = \ (x * y)") // uitgangen // 4 x 5 = 20Als u tekenreeksinterpolatie wilt gebruiken, wikkelt u de variabele- of functieaanroep tussen haakjes en plaatst u er een backslash voor, \( uitdrukking).
reeks & Woordenboek Als een Objective-C-programmeur bent u al vertrouwd met arrays en woordenboeken. Swift heeft ook collectieklassen en voegt een paar extra functies toe.
Hoe gebruik je collecties in Swift? In Swift worden ze gebeld reeks en Woordenboek. Het declareren van een array in Swift is vergelijkbaar met het declareren van een array letterlijk in Objective-C, met behulp van een aantal vierkante haakjes, [], maar zonder een @ symbool dat hen voorafgaat.
let someArray: [String] = ["one", "two", "three"]; var someOtherArray: [String] = ["alpha", "beta", "gamma"];
Hetzelfde geldt voor woordenboeken. In plaats van accolades te gebruiken, gebruikt u echter vierkante haakjes.
let someDictionary: [String: Int] = ["one": 1, "two": 2, "three": 3]; var someOtherDictionary: [String: Int] = ["cats": 1, "dogs": 4, "mice": 3];
Als een reeks object is gelijk aan een NSArray object en een Woordenboek object is gelijk aan een NSDictionary object, hoe creëren we mutable arrays en woordenboeken in Swift?
Het antwoord is heel eenvoudig, verklaar het object als een variabele. Met andere woorden, in het vorige voorbeeld someArray is het equivalent van een NSArray instantie en someOtherArray die van een NSMutableArray aanleg. Dit geldt ook voor woordenboeken. In het vorige voorbeeld, someDictionary is het equivalent van een NSDictionary instantie en someOtherDictionary die van een NSMutableDictionary aanleg. Dat is netjes, goed?
Hoewel Objective-C-arrays en -woordenboeken alleen objecten kunnen bevatten, kunnen in Swift collecties zowel objecten als primitieve gegevenstypen bevatten, zoals gehele getallen en drijvers. Een ander belangrijk verschil met Objective-C is dat collecties in Swift getypt worden, expliciet of door middel van type-gevolgtrekking tijdens het compileren. Door het type objecten in een verzameling op te geven, voegt Swift extra veiligheid toe aan deze collecties.
Hoewel we het type van een variabele kunnen weglaten bij het declareren, verandert dit niets aan het feit dat de compiler soorten toewijst aan de objecten in een verzameling. Het gebruik van type-inferentie helpt om de code leesbaar en licht te houden.
We kunnen het opnieuw instellen reeks en Woordenboek objecten die we eerder als volgt hebben verklaard:
laat someArray = ["een", "twee", "drie"]; var someOtherArray = ["alpha", "beta", "gamma"]; laat someDictionary = ["one": 1, "two": 2, "three": 3]; var someOtherDictionary = ["cats": 1, "dogs": 4, "mice": 3];
De compiler inspecteert de collecties tijdens hun initialisatie en leidt het juiste type af. Met andere woorden, het begrijpt dat someArray en someOtherArray zijn een verzameling van Draad objecten en someDictionary en someOtherDictionary zijn woordenboeken met toetsen van het type Draad en waarden van het type Int.
Het toevoegen van een object of een andere array aan een array lijkt sterk op string concatenation omdat we ook het + operator.
var array = ["one", "two", "three"]; // mutable array array + = "four"; // element toevoegen aan array array + = ["vijf", "zes"]; // array aan array toevoegen
Het bewerken van woordenboeken is net zo eenvoudig.
var dictionary = ["cat": 2, "dog": 4, "snake": 8]; // veranderlijk woordenboekwoordenboek ["leeuw"] = 7; // element toevoegen aan woordenboek woordenboek + = ["beer": 1, "muis": 6]; // voeg woordenboek toe aan woordenboek
Eerder vermeldde ik dat collecties in Swift getypt zijn, maar wat betekent dat? Als we een verzameling definiëren die bevat Draad objecten, je kunt alleen toevoegen Draad objecten aan die verzameling. Als u dit niet doet, krijgt u een foutmelding.
Laten we een voorbeeld bekijken om dit te verduidelijken. We definiëren een verzameling van Auto voorwerpen. In het volgende codefragment wordt het Auto klassendefinitie en een veranderlijke array auto's, met drie Auto instanties.
// Car class class Car var speed = 0.0 func accelerate (door: Double = 1.0) -> Bool speed + = by; geef waar terug; var cars = [Car (), Car (), Car ()];
Achter de schermen zal de compiler het type array afleiden. Als we een nieuw willen toevoegen Auto bijvoorbeeld aan de verzameling, kunnen we gewoon de + operator zoals hieronder getoond.
auto's + = Auto ();
Het toevoegen van een object van een ander type zal echter resulteren in een fout.
cars + = "Some String"; // dit veroorzaakt een compileerfout
Dit heeft het extra voordeel van typeveiligheid voor het ophalen van objecten uit verzamelingen. Het elimineert ook de noodzaak om verzamelobjecten te casten voordat ze worden gebruikt.
In ons voorbeeld, a Auto object heeft een versnellen methode. Omdat een verzameling is getypt, kunnen we een item uit de array pakken en onmiddellijk een methode op het object inroepen, in één regel code. We hoeven ons geen zorgen te maken over het type element, aangezien de verzameling alleen bevat Auto voorwerpen.
auto's [0] .accelerate (door: 2.0);
Om hetzelfde te bereiken in Objective-C met hetzelfde niveau van veiligheid, zouden we het volgende moeten schrijven:
id-aanwijzer = auto's [0]; if ([pointer isKindOfClass: [Car class]]) Car * car = (Car *) pointer; [autoversnelling: 2.0];
Ten slotte gebruiken we een array om een array te herhalen voor in lus:
voor auto in auto's car.accelerate (door: 2.0);
Om een woordenboek te herhalen, gebruiken we ook een voor in lus:
for (key, value) in someDictionary println ("Key \ (key) heeft value \ (value)"Zoals u kunt zien, zijn ingetypte collecties een krachtig kenmerk van de Swift-taal.
We hebben al aardig wat geleerd over de Swift-taal en je moet de tijd nemen om het te laten zinken. Ik raad aan om Xcode 6 zo snel mogelijk te downloaden en wat je hebt geleerd in dit artikel toe te passen in Xcode's nieuwe Speelplaats voorzien zijn van. Met speeltuinen kun je in realtime met Swift spelen.
Dat is het voor dit artikel. In de volgende aflevering van deze serie kijken we naar tuples, functies, sluitingen, klassen en last but not least, optionals. Je leert ook hoe geheugenbeheer werkt in Swift. Blijf kijken.
