Skip to main content

Arrays

Definition​

Ein Array ist eine geordnete Collection von Werten des gleichen Typs. Arrays in Swift sind typsicher und können dynamisch wachsen oder schrumpfen.

Basic Syntax​

// Leeres Array
var numbers: [Int] = []
var names = [String]()

// Array mit Werten
var fruits = ["Apple", "Banana", "Orange"]
var scores = [95, 87, 92, 88]

// Mit Type Annotation
var cities: [String] = ["Berlin", "Munich", "Hamburg"]

Array erstellen​

// Mit Literalen
let numbers = [1, 2, 3, 4, 5]

// Leeres Array
var emptyInts = [Int]()
var emptyStrings: [String] = []

// Mit Standardwert
let threes = Array(repeating: 3, count: 5)
// [3, 3, 3, 3, 3]

// Mit Range
let oneToTen = Array(1...10)
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Zugriff auf Elemente​

let fruits = ["Apple", "Banana", "Orange", "Grape"]

// Index-Zugriff
let first = fruits[0]              // "Apple"
let second = fruits[1]             // "Banana"

// Erstes und letztes Element
let firstFruit = fruits.first      // Optional("Apple")
let lastFruit = fruits.last        // Optional("Grape")

// Safe Subscripting
if let fruit = fruits.first {
    print(fruit)                   // "Apple"
}

// Index prüfen
if fruits.indices.contains(2) {
    print(fruits[2])               // "Orange"
}

Elemente hinzufügen​

var numbers = [1, 2, 3]

// Einzelnes Element anhängen
numbers.append(4)                  // [1, 2, 3, 4]

// Mehrere Elemente anhängen
numbers.append(contentsOf: [5, 6, 7])
// [1, 2, 3, 4, 5, 6, 7]

// An bestimmter Position einfügen
numbers.insert(0, at: 0)           // [0, 1, 2, 3, 4, 5, 6, 7]
numbers.insert(10, at: 5)          // An Index 5 einfügen

// Operator +=
numbers += [8, 9]                  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Elemente entfernen​

var fruits = ["Apple", "Banana", "Orange", "Grape", "Mango"]

// Erstes Element entfernen
let removed = fruits.removeFirst()  // "Apple"
// fruits: ["Banana", "Orange", "Grape", "Mango"]

// Letztes Element entfernen
let last = fruits.removeLast()      // "Mango"
// fruits: ["Banana", "Orange", "Grape"]

// An Index entfernen
fruits.remove(at: 1)                // Entfernt "Orange"
// fruits: ["Banana", "Grape"]

// Alle Elemente entfernen
fruits.removeAll()                  // []

Elemente ändern​

var numbers = [1, 2, 3, 4, 5]

// Einzelnes Element
numbers[0] = 10                     // [10, 2, 3, 4, 5]

// Range ersetzen
numbers[1...3] = [20, 30, 40]      // [10, 20, 30, 40, 5]

// Austauschen
numbers.swapAt(0, 4)                // [5, 20, 30, 40, 10]

Array-Eigenschaften​

let numbers = [1, 2, 3, 4, 5]

// Anzahl der Elemente
let count = numbers.count           // 5

// Ist leer?
let isEmpty = numbers.isEmpty       // false

// Kapazität
let capacity = numbers.capacity     // >= 5

// Indices
let indices = numbers.indices       // 0..<5

// Min und Max
let min = numbers.min()             // Optional(1)
let max = numbers.max()             // Optional(5)

Iteration​

let fruits = ["Apple", "Banana", "Orange"]

// For-in Loop
for fruit in fruits {
    print(fruit)
}

// Mit Index
for (index, fruit) in fruits.enumerated() {
    print("\(index): \(fruit)")
}
// Output:
// 0: Apple
// 1: Banana
// 2: Orange

// ForEach (Functional)
fruits.forEach { fruit in
    print(fruit)
}

// Mit Index-Range
for index in fruits.indices {
    print("\(index): \(fruits[index])")
}

Array-Methoden​

map​

let numbers = [1, 2, 3, 4, 5]

// Verdoppeln
let doubled = numbers.map { $0 * 2 }
// [2, 4, 6, 8, 10]

// Zu Strings
let strings = numbers.map { "Number: \($0)" }
// ["Number: 1", "Number: 2", ...]

filter​

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// Gerade Zahlen
let evens = numbers.filter { $0 % 2 == 0 }
// [2, 4, 6, 8, 10]

// Größer als 5
let large = numbers.filter { $0 > 5 }
// [6, 7, 8, 9, 10]

reduce​

let numbers = [1, 2, 3, 4, 5]

// Summe
let sum = numbers.reduce(0, +)
// 15

let sum2 = numbers.reduce(0) { $0 + $1 }
// 15

// Produkt
let product = numbers.reduce(1, *)
// 120

// String concatenation
let words = ["Hello", "World"]
let sentence = words.reduce("") { $0 + " " + $1 }
// " Hello World"

sorted​

let numbers = [5, 2, 8, 1, 9]

// Aufsteigend
let ascending = numbers.sorted()
// [1, 2, 5, 8, 9]

// Absteigend
let descending = numbers.sorted { $0 > $1 }
// [9, 8, 5, 2, 1]

// Custom Sorting
struct Person {
    let name: String
    let age: Int
}

let people = [
    Person(name: "Anna", age: 25),
    Person(name: "Bob", age: 30),
    Person(name: "Charlie", age: 20)
]

let sortedByAge = people.sorted { $0.age < $1.age }

compactMap​

// Filtert nil-Werte
let strings = ["1", "2", "three", "4", "5"]
let numbers = strings.compactMap { Int($0) }
// [1, 2, 4, 5]

// Entfernt Optionals
let optionals: [Int?] = [1, nil, 3, nil, 5]
let unwrapped = optionals.compactMap { $0 }
// [1, 3, 5]

flatMap​

// Flacht verschachtelte Arrays ab
let nested = [[1, 2], [3, 4], [5, 6]]
let flat = nested.flatMap { $0 }
// [1, 2, 3, 4, 5, 6]

// Mit Transformation
let numbers = [1, 2, 3]
let repeated = numbers.flatMap { Array(repeating: $0, count: 3) }
// [1, 1, 1, 2, 2, 2, 3, 3, 3]

Suchen und Prüfen​

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// contains
let hasThree = numbers.contains(3)          // true
let hasEleven = numbers.contains(11)        // false

// contains(where:)
let hasEven = numbers.contains { $0 % 2 == 0 }  // true

// first(where:)
let firstEven = numbers.first { $0 % 2 == 0 }   // Optional(2)

// firstIndex(of:)
let index = numbers.firstIndex(of: 5)       // Optional(4)

// allSatisfy
let allPositive = numbers.allSatisfy { $0 > 0 }  // true

Array Slicing​

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// Slice mit Range
let middle = numbers[3...6]                 // [4, 5, 6, 7]

// Prefix (erste N Elemente)
let first5 = numbers.prefix(5)              // [1, 2, 3, 4, 5]

// Suffix (letzte N Elemente)
let last3 = numbers.suffix(3)               // [8, 9, 10]

// Drop first/last
let withoutFirst = numbers.dropFirst(2)     // [3, 4, 5, 6, 7, 8, 9, 10]
let withoutLast = numbers.dropLast(2)       // [1, 2, 3, 4, 5, 6, 7, 8]

// Prefix/Suffix while
let lessThan5 = numbers.prefix { $0 < 5 }   // [1, 2, 3, 4]

Kombinieren und Teilen​

// Zwei Arrays kombinieren
let arr1 = [1, 2, 3]
let arr2 = [4, 5, 6]
let combined = arr1 + arr2                  // [1, 2, 3, 4, 5, 6]

// Reversed
let numbers = [1, 2, 3, 4, 5]
let reversed = numbers.reversed()           // [5, 4, 3, 2, 1]

// Shuffled
let shuffled = numbers.shuffled()           // Zufällige Reihenfolge

// Split
let text = ["a", "b", "-", "c", "d"]
let parts = text.split { $0 == "-" }
// [["a", "b"], ["c", "d"]]

Multidimensionale Arrays​

// 2D Array
var matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

// Zugriff
let element = matrix[1][2]                  // 6

// Iteration
for row in matrix {
    for element in row {
        print(element, terminator: " ")
    }
    print()
}

// Schachbrett
var board = Array(repeating: Array(repeating: 0, count: 8), count: 8)

SwiftUI mit Arrays​

struct FruitListView: View {
    let fruits = ["Apple", "Banana", "Orange", "Grape"]

    var body: some View {
        List(fruits, id: \.self) { fruit in
            Text(fruit)
        }
    }
}

// Mit @State
struct TodoListView: View {
    @State private var todos = ["Buy milk", "Call mom"]
    @State private var newTodo = ""

    var body: some View {
        VStack {
            HStack {
                TextField("New todo", text: $newTodo)
                Button("Add") {
                    todos.append(newTodo)
                    newTodo = ""
                }
            }

            List {
                ForEach(todos, id: \.self) { todo in
                    Text(todo)
                }
                .onDelete { indices in
                    todos.remove(atOffsets: indices)
                }
            }
        }
    }
}

Praktische Beispiele​

Filtern und Sortieren​

struct Person {
    let name: String
    let age: Int
}

var people = [
    Person(name: "Anna", age: 25),
    Person(name: "Bob", age: 30),
    Person(name: "Charlie", age: 20),
    Person(name: "David", age: 35)
]

// Erwachsene über 25, nach Alter sortiert
let filtered = people
    .filter { $0.age > 25 }
    .sorted { $0.age < $1.age }

for person in filtered {
    print("\(person.name): \(person.age)")
}
// Output:
// Bob: 30
// David: 35

Gruppieren​

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// Gruppieren nach gerade/ungerade
let grouped = Dictionary(grouping: numbers) { $0 % 2 == 0 ? "even" : "odd" }
print(grouped)
// ["even": [2, 4, 6, 8, 10], "odd": [1, 3, 5, 7, 9]]

Unique Values​

let numbers = [1, 2, 2, 3, 3, 3, 4, 5, 5]

// Set für unique values
let unique = Array(Set(numbers)).sorted()
// [1, 2, 3, 4, 5]

// Oder manuell
var uniqueNumbers: [Int] = []
for number in numbers {
    if !uniqueNumbers.contains(number) {
        uniqueNumbers.append(number)
    }
}

Performance Tipps​

// ✅ Gut - Kapazität reservieren
var numbers = [Int]()
numbers.reserveCapacity(1000)
for i in 0..<1000 {
    numbers.append(i)
}

// ❌ Schlecht - Viele Reallokationen
var numbers2 = [Int]()
for i in 0..<1000 {
    numbers2.append(i)           // Möglicherweise mehrfaches Resizing
}

// ✅ Gut - removeAll(keepingCapacity:)
numbers.removeAll(keepingCapacity: true)

// ✅ Gut - Batch Operations
numbers.append(contentsOf: [1, 2, 3])

// ❌ Schlecht
numbers.append(1)
numbers.append(2)
numbers.append(3)

Best Practices​

  1. Verwende let wenn möglich: Immutable Arrays sind sicherer
let fruits = ["Apple", "Banana"]     // Kann nicht geändert werden
  1. Type Inference nutzen: Weniger Code
let numbers = [1, 2, 3]              // Statt: let numbers: [Int] = [1, 2, 3]
  1. Safe Access: Prüfe Indices
if array.indices.contains(index) {
    print(array[index])
}
  1. Functional Programming: Nutze map, filter, reduce
let result = numbers.filter { $0 > 5 }.map { $0 * 2 }

Common Use Cases​

  • Lists: Todo-Listen, Kontakte, Produkte
  • Data Storage: API-Responses, lokale Daten
  • UI Elements: TableView/List Datenquelle
  • Batch Processing: Mehrere Operationen auf Collections
  • Search & Filter: Suchergebnisse filtern
  • Statistics: Summen, Durchschnitte berechnen
  • Collections: Set, Dictionary
  • Higher-Order Functions: map, filter, reduce
  • Sequences: Protocol für Iteration
  • Slices: Array Subsequences