Listings Sillmann/Swift


Listing 1: Fehler durch falsche Typzuweisung
let firstValue = 19.99
let secondValue = 99 

func addition(firstValue: Double, secondValue: Double) -> Double {
    firstValue + secondValue
}

addition(firstValue: firstValue, secondValue: secondValue)
// Fehler: secondValue ist vom Typ 'Int', nicht 'Double'.

-------

Listing 2: Typsicherheit von Arrays
var numbers = [19, 99, 118] // Integer-Array
var names = ["Thomas", "Michaela", "Mark"] // String-Array

var mixedValues = [19, "Thomas", true]
// Fehler: Elemente eines Arrays müssen demselben Typ entsprechen

-------

Listing 3: Eine Enumeration implementieren
enum Direction: String {
    case north = "Norden"
    case east = "Osten"
    case south = "Süden"
    case west = "Westen"
    
    func printInfo() {
      print("Gehe nach \(self.rawValue).")
    }
}

let myDirection = Direction.north
myDirection.printInfo()
// Gehe nach Norden.

-------

Listing 4: Enumeration mit Associated Values
enum PaymentMethod {
    case creditCard(String)
    case invoice(String, String, String)
}
let myPaymentMethod = PaymentMethod.invoice("Max Mustermann", "Musterstraße 19", "12345 Musterstadt")

-------

Listing 5: Associated Values einer Enumeration abfragen
switch myPaymentMethod {
case .creditCard(let creditCardNumber):
    print("Kreditkartenummer: \(creditCardNumber)")
case .invoice(let name, let street, let city):
    print("\(name), \(street), \(city)")
}
// Max Mustermann, Musterstraße 19, 12345 Musterstadt

-------

Listing 6: Unterscheidung zwischen Value und Reference Types
// Value Types
struct SomeStruct {
    var value = 0
}
var firstStruct = SomeStruct()
var secondStruct = firstStruct
firstStruct.value = 19
print("firstStruct.value = \(firstStruct.value)")
print("secondStruct.value = \(secondStruct.value)")
// firstStruct.value = 19
// secondStruct.value = 0

// Reference Types
class SomeClass {
    var value = 0
}
var firstClass = SomeClass()
var secondClass = firstClass
firstClass.value = 99
print("firstClass.value = \(firstClass.value)")
print("secondClass.value = \(secondClass.value)")
// firstClass.value = 99
// secondClass.value = 99

-------

Listing 7: Deklaration von Optionals
class Person {
    var name: String
    var address: String?

    init(name: String, address: String? = nil) {
      self.name = name
      self.address = address
    }
}

-------

Listing 8: Prüfen von Optionals gegen nil
let somePerson = Person(name: "Max Mustermann", address: "Musterstraße 19")
if somePerson.address != nil {
    print("Adresse: \(somePerson.address!)")
}
// Adresse: Musterstraße 19

-------

Listing 9: Prüfen von Optionals mit der Syntax if let
let somePerson = Person(name: "Max Mustermann", address: "Musterstraße 19")
if let address = somePerson.address {
    print("Adresse: \(address)")
}
// Adresse: Musterstraße 19

-------

Listing 10: Generische Funktionen mit statischen Typangaben
func swapTwoInts(_ firstInt: inout Int, _ secondInt: inout Int) {
    let temporaryFirstInt = firstInt
    firstInt = secondInt
    secondInt = temporaryFirstInt
}

func swapTwoStrings(_ firstString: inout String, _ secondString: inout String) {
    let temporaryFirstString = firstString
    firstString = secondString
    secondString = temporaryFirstString
}

-------

Listing 11: Tauschfunktion als Generic umsetzen
func swapTwoValues<T>(_ firstValue: inout T, _ secondValue: inout T) {
    let temporaryFirstValue = firstValue
    firstValue = secondValue
    secondValue = temporaryFirstValue
}

var firstInt = 19
var secondInt = 99
swapTwoValues(&firstInt, &secondInt)

var firstString = "First"
var secondString = "Second"
swapTwoValues(&firstString, &secondString)

-------

Listing 12: Einen Generic Type anlegen
struct Container<Item> {
    var items: [Item]
    mutating func add(item: Item) {
      items.append(item)
    }
}

var intContainer = Container<Int>(items: [19, 99])
var stringContainer = Container(items: ["First", "Second"])


 
