Swift: Datentypen

In diesem Abschnitt schauen wir uns die Datentypen in Swift an. Dabei sehen wir uns zunächst die eingebauten ("einfachen") Datentypen an und gehen dann zu Klassen, Strukturen und den Aufzählungstypen.

Im Anschluss können wir mit einfachen Datentypen umgehen und eigene komplexe Datentypen erstellen und verwenden. Wir wissen mit Methoden / Funktionen zu arbeiten und kennen Unterschiede und Gemeinsamkeiten zu anderen Programmiersprachen

Vorhandene Datentypen

Collections

Dictionary

Ein Dictionary ist eine Collection, welche aus Schlüssel-Wert-Paaren besteht. Der Typ unserer Schlüssel muss dabei lediglich einen eindeutigen numerischen Wert berechnen können – keine Sorge, wir müssen uns normalerweise nicht darum sorgen Hashable zu sein. Der Wert selbst ist beliebig. Damit wir auch wissen welche Typen wir meinen, können wir diese bei der Deklaration zwischen < und > angeben. Wir können also auf einfache Art ein Dictionary erstellen:

// Erstellen eines leeren Dictionary
var en2de : Dictionary<String,String> = [:]
// Erstellen eines Dictionary mit Werten
let stadtEinwohner : Dictionary<String,Int> = ["Berlin": 3419623, "Hamburg":1753380, "München":1388308, "Köln":1024373]
// Erstellen eines Dictionary mit Werten (Kurzschreibweise)
var weltmeister = [1974: "Deutsche Demokratische Republik", 1954: "Deutschland", 1990: "Deutschland"]

Ein Dictionary ist eine unsortierte Collection. Geben wir also unser Dictionary aus:

var weltmeister = [1974: "Deutsche Demokratische Republik", 1954: "Deutschland", 1990: "Deutschland"]
for jahr in weltmeister.keys {
  println("Jahr \(jahr) - \(weltmeister[jahr])")
}
// oder einfacher
for (jahr, land) in weltmeister {
  println("Jahr \(jahr) - \(land)")
}

Wir können die Werte in einem Dictionary auch ändern. Hierzu steht die updateValue Methode zur Verfügung. Diese gibt uns ggf. auch den bisher gespeicherten Wert zurück. Möchten wir auf einen Wert zugreifen, können wir auch den Schlüssel in [] angeben. Diese Schreibweise finden zum Löschen von einzelnen Werten oder auch des kompletten Dictionary Anwendung.

var weltmeister = [1974: "Deutsche Demokratische Republik", 1954: "Deutschland", 1990: "Deutschland"]

// Hinzufügen /  Ersetzen eines einzelnen Schlüssel-Wert-Paares
oldValue = weltmeister.updateValue("Deutschland", forKey: 2013)
weltmeister[2013] = "Deutsche Demokratische Republik" // Hinzufügen oder Ersetzen
var oldValue = weltmeister.updateValue("Deutschland", forKey: 1974) 
println("Bisher \(oldValue) aber jetzt \(weltmeister[1974])")
oldValue = weltmeister.updateValue("Deutschland", forKey: 2014)

// Löschen eines einzelnen Schlüssel-Wert-Paares
weltmeister[2013] = nil // Das Löschen wir jetzt

// Schauen wir mal den Inhalt an!
for (jahr, land) in weltmeister {
  println("Jahr \(jahr) - \(land)")
}

// Leeren des kompletten Dictionary
weltmeister = [:] // Alles löschen!

Aufzählungstyp / Enumeration

Enumerationen werden mit dem Schlüsselwort enum deklariert, die verschiedenen Fälle werden mit dem Schlüsselwort case.

enum Essen {
  case pizza
  case spaghetti
  case penne_rigate
}

Dann kann man sie als Typ für Variablen und Konstanten benutzen. Die Werte werden mit dem Namen der Enumeration, gefolgt von einem Punkt und dem Namen des Falls, dem Enum zugewiesen. Es gibt auch eine Kurzschreibweise, bei der nur ein Punkt und der Name des Falls steht. Hier muss dann aber das Enum explizit als Typ zugewiesen werden.

var lieblingsessen = Essen.pizza
var nudeln: [Essen] = [.spaghetti, .penne_rigate]

Man kann Enums auch erben lassen:

enum EssenMitZeichenkette: String {
  case pizza = "Pizza"
  case spaghetti = "Lange Nudeln"
  case penne_rigate = "Penne Rigate
}

Schnittstellen

Schnittstellen werden wir durch das Schlüsselwort protocol kenntlich machen, dem wir anschließend einen Namen geben. Schnittstellen in Swift geben nur die Konventionen für eine vorhandene Methode an, ohne eine Implementierung dieser bereitstellen zu können.

protocol Schnittstelle {
  func getTiefe () -> Int;
}

Unsere Schnittstelle darf andere Schnittstellen erweitern.

protocol Location {
  func getX () -> Int;
  func getY () -> Int;
  func getZ () -> Int;
  func getDate () -> Date;
}
protocol SubSchnittstelle : Schnittstelle, Location {
  func isRepairable () -> Bool;
}

Klassen

Klassen werden durch das Schlüsselwort class eingeleitet, gefolgt von einem Bezeichnet / Namen für unsere Klasse. Unser Klasseninhalt befindet sich in geschweiften Klammer.

class Klasse {
  // Klasseninhalt
}

Swift ermöglicht unserer Klasse von anderen Klassen zu erben, wobei nur Einfachvererbung unterstützt wird. Hierfür wird nach der Klasse getrennt durch einen Doppelpunkt die Superklasse angeführt. Auch wenn Mehrfachvererbung nicht unterstützt wird, haben wir die Möglichkeit beliebig viele Schnittstellen zu implementieren.

class Klasse : Superklasse, SuperProtokoll, WeiteresProtokoll {
  // Klasseninhalt
}

Klassenfunktionen

Funktionen auf Klassenebene werden durch das Schlüsselwort class gekennzeichnet. Wir müssen zum Ausführen dieser Funktionen kein Objekt unserer Klasse erzeugen.

class Klasse {
  class func maxSchueler () -> Int8 {
    return 17
  }
}

Konvertieren von Datentypen

Sofern wir eine Instance von einem anderen Typ benötigen können wir dies auf verschiedene Arten erhalten. Im Idealfall bietet entweder der Ausgangstyp oder der Zieltyp eine Methode an. So können wir die Int-Typen über den Konstruktor umwandeln.

let bigInt : Int64 = 591975
let constructorCast : Int32 = Int32(bigInt)

Hier bietet der Zieltyp einen passenden Konstruktor an. Alternativ stehen uns manchmal auch beim Quelltyp Methoden zur Umwandlung bereit.

Manchmal hilft jedoch nur das harte Casten in einen anderen Typen über das Schlüsselwort as.

var obj : NSObject = "Hallo"
var str : String = obj as String