Am 2. Juni 2014 stellte Apple eine brandneue objektorientierte Programmiersprache vor: Swift, ein Ersatz für Objective-C, das bis zu diesem Zeitpunkt die Standardprogrammiersprache für die Entwicklung von OS X- und iOS-Anwendungen war.
Es war ein mutiger Schritt, die Hauptentwicklungssprache für eine so beliebte Plattform vollständig zu ändern; dennoch reagierte unser Team auf diese Nachricht mit großer Begeisterung und entschied sich schnell, darauf umzusteigen. Und wir sind nicht die Einzigen: Swift wurde für seine Einfachheit und Flexibilität hoch gelobt, und die Akzeptanzrate ist in die Höhe geschossen.
Nach der Entwicklung einiger iOS-Anwendungen mit Swift haben wir beschlossen, unsere Gedanken über einige der Dinge zu teilen, die das Programmieren mit Swift einfacher und angenehmer machen. Hier ist also unsere Top-Ten-Liste der größten und wichtigsten Unterschiede zwischen Swift und Objective-C!
(Fühlen Sie sich frei, einen Playground zu nutzen, um mit den Code-Snippets in diesem Artikel zu üben. Es ist immer eine gute Idee, neue Sprachen und Frameworks zu erkunden!)
Swift vs. Objective-C: 10 Unterschiede
1. Optionals
Optionals sind ein Konzept, das in C oder Objective-C nicht existiert. Sie ermöglichen es Funktionen, die möglicherweise nicht immer einen sinnvollen Wert zurückgeben können (z.B. im Falle einer ungültigen Eingabe), entweder einen in einem Optional gekapselten Wert oder nil zurückzugeben. In C und Objective-C können wir bereits nil von einer Funktion zurückgeben, die normalerweise ein Objekt zurückgeben würde, aber wir haben diese Option nicht für Funktionen, die einen Grundtyp wie int, float oder double zurückgeben sollen. Beachten Sie folgendes Beispiel:
|
1 2 3 4 5 |
let a = "512" let b = Int(a) print(b) // Optional(512) |
Die Int-Funktion gibt in diesem Fall erwartungsgemäß ein Optional mit dem int-Wert 512 zurück. Aber was passiert, wenn wir versuchen, etwas wie „Hello“ zu konvertieren? In diesem Fall wird die Funktion nil zurückgeben, wie oben erklärt:
|
1 2 3 4 5 |
let a = "Hello" let b = Int(a) print(b) // nil |
Wie Sie vielleicht schon wissen, passiert in Objective-C nichts, wenn Sie eine Methode auf einem nil-Pointer aufrufen. Keine Compilerfehler, keine Laufzeitfehler, nichts. Dies ist eine bekannte Quelle von Fehlern und unerwartetem Verhalten und führt zu allgemeiner Frustration: Der Mangel an Rückmeldungen zwingt Entwickler dazu, die Quelle dieser Fehler selbst zu finden.
Mit Swift müssen Sie sich darüber keine Sorgen machen:
|
1 2 3 4 |
var x = Int("555") print(x.successor()) // error |
Der Compiler selbst wird einen Fehler auslösen, da x derzeit ein Optional ist und potenziell nil sein könnte. Bevor Sie einen Optional-Wert verwenden, müssen Sie ihn entpacken:
|
1 2 3 4 5 6 |
var x = Int("555") if x != nil { print(x!.successor()) // 556 } |
Alternativ können wir optionale Bindung verwenden:
|
1 2 3 4 5 6 7 |
var x = Int("555") if var y = x { y += 445 print(y) // 1000 } |
2. Kontrollfluss
Jeder, der in C oder einer C-ähnlichen Sprache programmiert hat, kennt die Verwendung von geschweiften Klammern ({}) zur Abgrenzung von Codeblöcken. In Swift sind sie jedoch nicht nur eine gute Idee: Sie sind Pflicht!
|
1 2 3 4 5 |
if a < 5 { print("Something") } |
Dies wird in Swift einen Compilerfehler auslösen!
|
1 2 3 4 |
if a < 5 print(“Something") |
Im Gegensatz zu Objective-C behandelt Swift geschweifte Klammern als obligatorisch für if-, for-, while- und repeat-Anweisungen. Das mag auf den ersten Blick nicht wie eine Verbesserung gegenüber Objective-C erscheinen, aber bedenken Sie, dass selbst die Entwickler von Apple Probleme hatten, wenn keine geschweiften Klammern verwendet wurden, um den Code zu strukturieren:
|
1 2 3 4 5 |
if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0) goto fail; goto fail; |
Das ist richtig: Der berüchtigte iOS „goto fail“-Fehler hätte vermieden werden können, wenn Objective-C so streng wie Swift bei der Durchsetzung von geschweiften Klammern gewesen wäre!
3. Typinferenz
Swift führt Typensicherheit in die iOS-Entwicklung ein. Sobald eine Variable mit einem bestimmten Typ deklariert ist, bleibt dieser Typ statisch und kann nicht geändert werden. Der Compiler ist auch intelligent genug, um zu ermitteln (oder zu inferieren), welchen Typ Ihre Variablen basierend auf den ihnen zugewiesenen Werten haben sollten:
|
1 2 3 4 5 6 |
var str = "Some string" // OR var str2:String str2 = "Other string" |
Dies bedeutet auch, dass der Compiler einen Fehler auslösen wird, wenn Sie versuchen, einen numerischen Wert, wie 10, unserer str2-Variable zuzuweisen:
|
1 2 3 |
str2 = 10 // error: Cannot assign value of type 'Int' to type 'String' |
Vergleichen Sie dies mit Objective-C, wo Sie den Typ einer Variable immer explizit angeben müssen:
|
1 2 3 |
NSString str = @"There is no type inference in Objective-C :(" |
4. Tupel
Swift unterstützt Tupel, Werte, die Gruppen anderer Werte speichern. Im Gegensatz zu Arrays müssen die Werte in einem Tupel nicht alle vom gleichen Typ sein. Zum Beispiel kann ein Tupel Strings und Ints enthalten:
|
1 2 3 4 |
var t:(String, Int) = ("John", 33) print(t.0, t.1) |
|
1 2 3 4 |
var j:(name:String, Int) = ("Morgan", 52) print(j.name, j.1) |
Der offensichtlichste Anwendungsfall für Tupel ist die Rückgabe mehrerer Werte aus einer Funktion:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
var arr = [23, 5, 7, 33, 9] func findPosition(el:Int, arr:[Int]) -> (found:Bool, position:Int)? { if arr.isEmpty { return nil } for (i, value) in arr.enumerate() { if value == el { return (true, i) } } return (false, -1) } if let (isFound, elPosition) = findPosition(5, arr: arr) { print(isFound, elPosition) // true 1 } |
In Objective-C können wir Blöcke auf ähnliche Weise verwenden, aber es ist nicht so unkompliziert oder elegant.
5. Zeichenkettenmanipulation
Swift bietet enorme Verbesserungen gegenüber Objective-C in Bezug auf die Zeichenkettenmanipulation. Zunächst müssen Sie sich keine Gedanken mehr über veränderbare vs. unveränderbare Zeichenketten machen: Deklarieren Sie Ihre Zeichenkette einfach mit var, wenn Sie sie in Zukunft ändern möchten, oder mit let, wenn sie konstant bleiben soll.
Die Verkettung von Zeichenketten ist so einfach wie 1+1=2:
|
1 2 3 4 5 |
// Swift: var str = "My string" str += " and another string” |
Vergleichen Sie dies mit Objective-C, wo das Verketten von zwei unveränderbaren Zeichenketten erfordert, dass Sie ein völlig neues NSString-Objekt erstellen. Hier ist ein Beispiel mit der Methode „stringWithFormat“:
|
1 2 3 4 5 |
// Obj-C: NSString *myString = @"My string"; myString = [NSString stringWithFormat:@"%@ and another string", myString]; |
Wie Sie hier sehen können, beinhaltet die Zeichenkettenformatierung in Objective-C das Einfügen spezieller Platzhalter für jeden Datentyp, den wir in unsere Zeichenkette interpolieren möchten:
|
1 2 3 |
NSString *str = [NSString stringWithFormat:@"String: %@ | Signed 32-bit integer: %d | 64-bit floating-point number: %f", @"My String", myInt, myFloat]; |
In Swift können wir stattdessen Werte interpolieren, indem wir die Variablennamen direkt in unsere Zeichenkette einfügen:
|
1 2 3 |
var str = "String: (myString) | Signed 32-bit integer: (myInt) | 64-bit floating-point number: (myFloat)" |
6. Guard und Defer
Haben Sie schon einmal vom „Pyramid of Doom“ gehört? Wenn nicht, hier ist ein Ausschnitt von Objective-C-Code, der Ihr Gedächtnis auffrischen sollte:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
enum TriangleAreaCalcError: ErrorType { case AngleNotSpecified case InvalidAngle case SideANotSpecified case SideBNotSpecified } func calcTriangleArea(a: Double ? , b : Double ? , alpha : Double ? ) throws - > Double { if let a = a { if let b = b { if let alpha = alpha { if alpha < 180 && alpha >= 0 { if alpha == 180 { return 0 } return 0.5 * a * b * sin(alpha * M_PI / 180.0) } else { throw TriangleAreaCalcError.InvalidAngle } } else { throw TriangleAreaCalcError.AngleNotSpecified } } else { throw TriangleAreaCalcError.SideBNotSpecified } } else { throw TriangleAreaCalcError.SideANotSpecified } } |
Das ist eine Pyramide, die selbst Indiana Jones zum Blinzeln bringen würde! Glücklicherweise haben wir in Swift mit guard eine neue bedingte Anweisung, die diesen Code viel lesbarer macht. Guard stoppt den Programmfluss, wenn eine Bedingung nicht erfüllt ist:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
func calcTriangleArea(a: Double ? , b : Double ? , alpha : Double ? ) throws - > Double { guard let a = a else { throw TriangleAreaCalcError.SideANotSpecified } guard let b = b else { throw TriangleAreaCalcError.SideBNotSpecified } guard let alpha = alpha else { throw TriangleAreaCalcError.AngleNotSpecified } if alpha == 180 { return Double(0) } guard alpha < 180 && alpha >= 0 else { throw TriangleAreaCalcError.InvalidAngle } return 0.5 * a * b * sin(alpha * M_PI / 180.0) } |
Swift bietet uns auch das Schlüsselwort defer, das eine sichere und einfache Möglichkeit bietet, Code zu behandeln, den wir nur ausführen möchten, wenn das Programm den aktuellen Bereich verlässt:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
func someImageFunc() - > UIImage ? { let dataSize: Int = ... let destData = UnsafeMutablePointer < UInt8 > .alloc(dataSize) // ... guard error else { destData.dealloc(dataSize) // #1 return nil } guard error2 else { destData.dealloc(dataSize) // #2 return nil } guard error3 else { destData.dealloc(dataSize) // #3 return nil } destData.dealloc(dataSize) // #4 // ... } |
Wie Sie sehen, müssen wir vier separate Aufrufe an destData.dealloc(dataSize) schreiben, um sicherzustellen, dass unser Pointer deallokiert wird, selbst wenn guard die Funktion im Fehlerfall beendet. Mit defer haben wir eine mühelose Möglichkeit, sowohl unseren Pointer als auch unseren Code zu bereinigen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
func someImageFunc() - > UIImage ? { let dataSize: Int = ... let destData = UnsafeMutablePointer < UInt8 > .alloc(dataSize) // ... defer { destData.dealloc(dataSize) } guard error else { return nil } guard error2 else { return nil } guard error3 else { return nil } // ... } |
7. Funktionale Programmiermuster
Swift integriert eine Reihe funktionaler Programmierfunktionen wie map und filter, die auf jede Sammlung angewendet werden können, die das CollectionType-Protokoll implementiert:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
let a = [4, 8, 16] print(a.map{$0 / 2}) // [2, 4, 8] let a:[(name:String, area:String)] = [("John", "iOS"), ("Sam", "Android"), ("Paul", "Web")] let b = a.map({"Developer ($0.name) (($0.area))"}) // ["Developer John (iOS)", "Developer Sam (Android)", "Developer Paul (Web)”] let a = [23, 5, 7, 12, 10] let b = a.filter{$0 > 10} print(b) // [23, 12] let sum = (20...30) .filter { $0 % 2 != 0 } .map { $0 * 2 } .reduce(0) { $0 + $1 } print(sum) // 250 |
Objective-C hat keine eingebaute Unterstützung für funktionale Programmierung. Um diese Funktionen zu nutzen, müssten Sie eine Drittanbieter-Bibliothek verwenden.
8. Aufzählungen
In Swift sind Aufzählungen leistungsfähiger als je zuvor in Objective-C: Sie können jetzt Methoden enthalten und werden als Wert übergeben. Hier ist ein kleiner Codeausschnitt, der zeigt, wie Enums in Swift funktionieren:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
enum Location { case Address(city: String, street: String) case Coordinates(lat: Float, lon: Float) func printOut() { switch self { case let.Address(city, street): print("Address: " + street + ", " + city) case let.Coordinates(lat, lon): print("Coordiantes: ((lat), (lon))") } } } let loc1 = Location.Address(city: "Boston", street: "33 Court St") let loc2 = Location.Coordinates(lat: 42.3586, lon: -71.0590) loc1.printOut() // Address: 33 Court St, Boston loc2.printOut() // Coordiantes: (42.3586, -71.059) |
Enums können auch rekursiv sein, sodass wir eine verkettete Liste unter Verwendung der indirekten Anweisung erstellen können, die dem Compiler mitteilt, die erforderliche Indirektionsebene hinzuzufügen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
enum List { case Empty indirect case Cell(value: Int, next: List) } let list0 = List.Cell(value: 1, next: List.Empty) let list1 = List.Cell(value: 4, next: list0) let list2 = List.Cell(value: 2, next: list1) let list3 = List.Cell(value: 6, next: list2) let headL = List.Cell(value: 3, next: list3) func evaluateList(list: List) - > Int { switch list { case let.Cell(value, next): return value + evaluateList(next) case .Empty: return 0 } } print(evaluateList(headL)) // 16 |
9. Funktionen
Die Funktionssyntax von Swift ist flexibel genug, um alles von einer einfachen C-ähnlichen Funktion bis hin zu einer komplexen Objective-C-ähnlichen Methode mit lokalen und externen Parameternamen zu definieren.
Jede Funktion in Swift hat einen Typ, der aus den Parametertypen und dem Rückgabewert der Funktion besteht. Das bedeutet, dass Sie Funktionen Variablen zuweisen oder sie als Parameter an andere Funktionen übergeben können:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
func stringCharactersCount(s: String) - > Int { return s.characters.count } func stringToInt(s: String) - > Int { if let x = Int(s) { return x } return 0 } func executeSuccessor(f: String - > Int, s: String) - > Int { return f(s).successor() } let f1 = stringCharactersCount let f2 = stringToInt executeSuccessor(f1, s: "5555") // 5 executeSuccessor(f2, s: "5555") // 5556 |
Swift ermöglicht es Ihnen auch, Standardwerte für Funktionsparameter zu definieren:
|
1 2 3 4 5 6 7 |
func myFunction(someInt: Int = 5) { // If no arguments are passed, the value of someInt is 5 } myFunction(6) // someInt is 6 myFunction() // someInt is 5 |
10. Do-Anweisung
Die do-Anweisung in Swift ermöglicht es Ihnen, einen neuen Bereich einzuführen:
|
1 2 3 4 5 6 7 8 9 10 |
let a = "Yes" do { let a = "No" print(a) // No } print(a) // Yes |
Do-Anweisungen können auch eine oder mehrere catch-Klauseln enthalten:
|
1 2 3 4 5 6 7 8 9 10 |
do { try expression statements } catch pattern 1 { statements } catch pattern 2 where condition { statements } |
Weitere Informationen finden Sie in der offiziellen Swift-Dokumentation zur do-Anweisung.
Fazit
Wir sind fest davon überzeugt, dass Swift die Zukunft der iOS-Entwicklung ist. Mit seiner Open-Source-Natur und wachsenden Beliebtheit können wir erwarten, dass es in Zukunft auch auf anderen Plattformen eingesetzt wird.
Eines seiner vielversprechendsten Merkmale ist das, was Apple als Protokollorientierte Programmierung bezeichnet, ein Paradigma, das in Zukunft einen großen Einfluss auf die Softwareentwicklung haben könnte. In Swift können Protokolle (oder „Interfaces“ in Sprachen wie C#) nicht nur von Klassen, sondern auch von Enums und Strukturen implementiert werden; außerdem bieten sie eine elegante und verständliche Alternative zur Mehrfachvererbung, da ein einzelnes Objekt mehrere Protokolle implementieren kann.
Mit seiner leichten, flexiblen Syntax und zahlreichen Funktionen, die vor häufigen Programmierfehlern schützen, macht das Programmieren in Swift einfach Spaß. Probieren Sie es selbst aus – Sie werden fast sicher zustimmen. Ein guter Ausgangspunkt ist die offizielle (und sehr umfassende) Dokumentation von Apple zur Sprache.
**//
Über Redwerk
Redwerk wurde im Jahr 2005 gegründet und hat seitdem umfangreiche Erfahrung in der Entwicklung von iOS-Spielen, Anwendungen, E-Government- und lokalen Medienlösungen gesammelt.
Zu den herausforderndsten Projekten, die uns geholfen haben, unsere Erfahrung in der iOS-Entwicklung zu erlangen und zu testen, gehören die folgenden:
School Observation App. Eine perfekte Lösung für Schulaufsichtsbehörden. Die Entwicklung dieser App wurde von The Education Partners in Auftrag gegeben, da sie ihre Notizen zu Lehrern, Schülern und der Schule selbst schnell und einfach, sowohl online als auch offline, festhalten mussten. Dank unserer vorherigen Erfahrung konnte Redwerk in kürzester Zeit einen einfachen und benutzerfreundlichen Prototyp liefern und schnell zur Implementierung der App übergehen. Von Anfang an wurde die Leistung als zentrales Ziel gesetzt, da die App große Mengen an Medien verarbeiten sollte. Es dauerte nur drei Monate, um eine Schulbeobachtungs-App zu entwickeln und zu starten, die hoffentlich dazu beitragen wird, dass The Education Partners die Bildungsstandards auf höchstem Niveau halten.
Local Media Mobile Apps. Redwerk hat eine langanhaltende Wartung für die Mehrheit der lokalen Nachrichten-Apps von Worldnow auf iOS bereitgestellt. Unsere tägliche Routine bestand darin, eine Reihe von Problemen regelmäßig zu lösen, wie z.B. Ladeprobleme bei Nachrichtenfeeds, doppelte Inhalte und Fehlermeldungen bei Wetterberichten. Wir arbeiteten auch daran, neue App-Blöcke und Funktionen hinzuzufügen und die bestehenden entsprechend den aktuellen Bedürfnissen der Benutzer zu modifizieren.
YouTown. Unser Team wurde beauftragt, eine mobile Anwendung von Grund auf zu entwerfen und zu entwickeln, die US-Bürger mit ihren lokalen Behörden verbindet und jederzeit aktuelle Stadtinformationen bereitstellt. Redwerk ist stolz darauf, dass es uns nur drei Monate gedauert hat, die ersten voll funktionsfähigen Betas einer Webschnittstelle für Regierungsvertreter und einer mobilen App für Endbenutzer zu liefern. Letztendlich wurde die App in mehr als 20 Städten innerhalb und außerhalb der Vereinigten Staaten weit verbreitet und schließlich von einem Drittunternehmen übernommen.
Neben der ausgelagerten Anwendungsentwicklung tragen wir viel zu internen Projekten bei. Als wir die US-Präsidentschaftswahlen 2016 verfolgten, beschlossen wir, diese Gelegenheit zu nutzen und unsere Fähigkeiten in der Entwicklung von Multiplayer-Spielen mit Unity zu verbessern. Gesagt, getan, in nur etwa sechs Monaten lieferte ein Team von zwei Entwicklern Electoral.io, ein dynamisches plattformübergreifendes Spiel, das sowohl in Android, iOS als auch in Browser-Versionen verfügbar ist.
Wie jeder andere unserer Kunden können Sie sicher sein, dass ein Team aus hochqualifizierten Entwicklern und effektiven Managern ihr Bestes geben wird, um Ihr Projekt pünktlich und auf höchstem Niveau zu liefern. Zögern Sie nicht, die iOS-Entwicklung an die Redwerk Company auszulagern, denn wir haben genügend Erfahrung, um alle Ihre Anforderungen zu erfüllen.
Unsere Entwickler sind außerdem Experten in
C- und C++-Entwicklung
C#-Softwareentwicklung
Microsoft-Windows-Entwicklung
ASP.NET-Entwicklung
HTML5-Spielentwicklung
