Arrays

Das Problem: Viele Werte, viele Variablen

Du willst die Namen deiner Freunde speichern. Mit Variablen sähe das so aus:

let friend1 = "Anna"
let friend2 = "Ben"
let friend3 = "Clara"

Was passiert, wenn ein vierter Freund dazukommt? Eine neue Variable. Und wenn du alle begrüßen willst? Drei einzelne print-Befehle. Wenn die Anzahl vorher nicht feststeht, etwa weil der Nutzer selbst Freunde hinzufügt, funktioniert dieser Ansatz überhaupt nicht mehr.

Du brauchst eine Schachtel, in die beliebig viele Werte passen, in einer festen Reihenfolge. Das ist ein Array.

Ein Array anlegen

Ein Array schreibst du mit eckigen Klammern, die Werte trennst du mit Kommas:

let friends = ["Anna", "Ben", "Clara"]
print(friends)   // ["Anna", "Ben", "Clara"]

Die eckigen Klammern [ und ] tippst du auf der deutschen Mac-Tastatur mit ⌥ 5 und ⌥ 6.

Die Motivations-App aus Lektion 0.4 hatte übrigens genau so ein Array: die Liste der Sprüche.

Der Typ eines Arrays

Alle Elemente eines Arrays haben denselben Typ. Swift leitet ihn wieder selbst ab:

let friends = ["Anna", "Ben", "Clara"]   // [String]
let scores = [12, 7, 23]                 // [Int]
let prices = [1.99, 4.5, 0.99]           // [Double]

[String] liest du als „Array von Strings“. Gemischte Arrays wie ["Anna", 34, true] lässt Swift nicht zu.

Ein leeres Array

Bei einem leeren Array kann Swift den Typ nicht erraten. Du musst ihn angeben:

var shoppingList: [String] = []

Auf Elemente zugreifen

Jedes Element hat eine Position, den Index. Und hier kommt eine Besonderheit: Gezählt wird ab 0.

let friends = ["Anna", "Ben", "Clara"]
//               0       1       2

print(friends[0])   // Anna
print(friends[2])   // Clara

Das erste Element hat den Index 0, das letzte den Index Anzahl − 1. Am Anfang ist das ungewohnt, aber fast alle Programmiersprachen zählen so. Du gewöhnst dich schnell daran.

Für den Anfang und das Ende gibt es bequeme Abkürzungen:

print(friends.first)   // Optional("Anna")
print(friends.last)    // Optional("Clara")

Was das Optional(...) bedeutet, lernst du in Lektion 1.8. Kurz gesagt: Bei einem leeren Array gäbe es kein erstes Element, und Swift macht dich darauf aufmerksam.

Wie viele Elemente?

print(friends.count)     // 3
print(friends.isEmpty)   // false

Ein Array verändern

Ein Array mit let ist unveränderlich. Willst du Elemente hinzufügen oder entfernen, brauchst du var:

var friends = ["Anna", "Ben"]

// Hinzufügen
friends.append("Clara")              // ["Anna", "Ben", "Clara"]
friends.insert("Zoe", at: 0)         // ["Zoe", "Anna", "Ben", "Clara"]
friends += ["David", "Eva"]          // hängt mehrere an

// Ändern
friends[1] = "Annika"                // ersetzt "Anna"

// Entfernen
friends.remove(at: 0)                // entfernt "Zoe"
friends.removeLast()                 // entfernt "Eva"
friends.removeAll()                  // leert das Array

Arrays durchlaufen

Jetzt kommen die Schleifen aus Lektion 1.5 ins Spiel:

let friends = ["Anna", "Ben", "Clara"]

for friend in friends {
    print("Hallo, \(friend)!")
}
// Hallo, Anna!
// Hallo, Ben!
// Hallo, Clara!

Ein vierter Freund? Einfach ins Array, die Schleife bleibt gleich. Genau das ist die Stärke von Arrays.

Mit Index durchlaufen

Brauchst du zusätzlich die Position, hilft enumerated():

for (index, friend) in friends.enumerated() {
    print("\(index + 1). \(friend)")
}
// 1. Anna
// 2. Ben
// 3. Clara

(index, friend) holt zwei Werte gleichzeitig aus jedem Durchlauf. So ein Paar von Werten heißt Tupel. Mehr brauchst du darüber im Moment nicht zu wissen.

Nützliche Fähigkeiten

Arrays bringen eine Menge fertiger Funktionen mit:

let scores = [12, 7, 23, 7, 15]

scores.contains(23)        // true
scores.firstIndex(of: 7)   // Optional(1)
scores.min()               // Optional(7)
scores.max()               // Optional(23)
scores.sorted()            // [7, 7, 12, 15, 23]
scores.reversed()          // in umgekehrter Reihenfolge
scores.shuffled()          // zufällig gemischt
scores.randomElement()     // zufälliges Element

randomElement() kennst du aus der Motivations-App. Und die Summe aller Elemente kannst du mit einer Schleife berechnen:

var total = 0
for score in scores {
    total += score
}
print(total)   // 64

sort() oder sorted()?

Achte auf den kleinen Unterschied:

var names = ["Clara", "Anna", "Ben"]

let sortedNames = names.sorted()   // gibt ein NEUES sortiertes Array zurück
print(names)                       // ["Clara", "Anna", "Ben"], unverändert

names.sort()                       // sortiert das Array SELBST
print(names)                       // ["Anna", "Ben", "Clara"]

Diese Namensregel gilt in Swift überall: Endet der Name auf -ed oder -ing (sorted, reversed, shuffled), bekommst du ein neues Ergebnis zurück, und das Original bleibt gleich. Ohne Endung (sort, reverse, shuffle) wird das Original verändert, und dafür braucht es var.

Typische Fehler

Index außerhalb des Arrays

let friends = ["Anna", "Ben", "Clara"]
print(friends[3])

Der höchste Index ist 2, nicht 3. Das ist der häufigste Absturzgrund bei Arrays. Prüf vorher mit friends.count, oder nutze first, last und Schleifen, die nie über das Ende hinauslaufen.

Array mit let verändern

Mach aus let ein var.

Falscher Typ

var scores = [12, 7, 23]
scores.append("zehn")

In ein [Int] passen nur ganze Zahlen.

Leeres Array ohne Typ

var items = []

Lösung: var items: [String] = [].

FAQ

Übungen

var movies = ["Inception", "Up", "Amélie"]
movies.append("Interstellar")
movies[1] = "Coco"

for (index, movie) in movies.enumerated() {
    print("\(index + 1). \(movie)")
}

let temperatures = [12.5, 14.0, 9.5, 11.0, 15.5, 17.0, 13.5]

var sum = 0.0
var warmDays = 0

for temperature in temperatures {
    sum += temperature
    if temperature > 13 {
        warmDays += 1
    }
}

let average = sum / Double(temperatures.count)
print("Durchschnitt: \(average) Grad")   // 13.285…
print("Warme Tage: \(warmDays)")          // 4

let numbers = [3, 1, 3, 2, 1, 4]
var unique: [Int] = []

for number in numbers {
    if !unique.contains(number) {
        unique.append(number)
    }
}

print(unique)   // [3, 1, 2, 4]

Zusammenfassung

• Ein Array speichert viele Werte desselben Typs in einer festen Reihenfolge.
• Der Index beginnt bei 0. Ein Zugriff außerhalb führt zum Absturz.
• append, insert, remove verändern das Array, dafür braucht es var.
• for item in array durchläuft alle Elemente, enumerated() liefert zusätzlich den Index.
• -ed-Funktionen (sorted) liefern ein neues Array, die anderen (sort) ändern das Original.

Spickzettel

var list = ["A", "B"]          // [String]
var empty: [Int] = []          // leeres Array
list[0]                        // "A"
list.count   list.isEmpty
list.append("C")
list.insert("Z", at: 0)
list.remove(at: 0)
list.contains("B")
for item in list { ... }
for (i, item) in list.enumerated() { ... }