Swift: Spickzettel

Apples moderne, sichere Sprache für iOS und macOS

Ausführen: Online im Swift Playground oder lokal: Datei main.swift mit swift main.swift ausführen (Xcode oder Swift-Toolchain nötig).

print("Hallo Swift!")
let name = "Mia"
print("Hallo, \(name)!")
print("2 + 3 =", 2 + 3)
print("Mehrere", "Werte", separator: "-", terminator: "!\n")

import Foundation          // für pow, sqrt, round ...

let i = 42
let d = 3.5
print(Double(i) + d, Int(d), Int(3.99), Double(7) / 2, 7 / 2, 7 % 3, -7 % 3)
print(i.isMultiple(of: 2), abs(-5), max(3, 9), min(3, 9), pow(2.0, 10.0))
print(Int.max, Int8.max, UInt8.min)
let (rest, zahl) = (7 % 3, 2 << 3)
print(rest, zahl, 5 & 3, 5 | 3, 5 ^ 3, ~5)
print(10.0 / 3.0, (10.0 / 3.0 * 100).rounded() / 100, 2.5.rounded(), 3.5.rounded(), 3.7.rounded(.down))
print(String(42) + "!", Int("123") ?? 0, Int("abc") ?? -1, Double("2.5")!)
print(i.description, d.description, 1.0 == 1, "5" == String(5))

func gruss(an name: String, mit anrede: String = "Hallo") -> String {
    return "\(anrede), \(name)!"
}

func quadrat(_ x: Int) -> Int { x * x }           // _ : kein Bezeichner beim Aufruf; Einzeiler ohne return

func minMax(_ zahlen: [Int]) -> (min: Int, max: Int) {
    (zahlen.min()!, zahlen.max()!)                 // Rückgabe als benanntes Tupel
}

func summe(_ zahlen: Int...) -> Int { zahlen.reduce(0, +) }      // variadisch

func tausche(_ a: inout Int, _ b: inout Int) {     // inout: Variable wird verändert
    let t = a; a = b; b = t
}

func fakultaet(_ n: Int) -> Int { n <= 1 ? 1 : n * fakultaet(n - 1) }

print(gruss(an: "Mia"), gruss(an: "Tom", mit: "Hi"))
print(quadrat(7), summe(1, 2, 3, 4), fakultaet(10))
let ergebnis = minMax([4, 9, 1, 7])
print(ergebnis.min, ergebnis.max, ergebnis)
var x = 1, y = 2
tausche(&x, &y)
print(x, y)

func addierer(_ n: Int) -> (Int) -> Int { { $0 + n } }          // Funktion als Rückgabewert
let plus5 = addierer(5)
print(plus5(10), addierer(1)(1))

struct Punkt {
    var x: Double
    var y: Double = 0                          // Standardwert

    var abstand: Double { (x * x + y * y).squareRoot() }      // berechnete Eigenschaft

    mutating func verschiebe(dx: Double, dy: Double) {        // mutating: ändert self
        x += dx; y += dy
    }

    static let ursprung = Punkt(x: 0)
    func beschreibung() -> String { "(\(x), \(y))" }
}

var a = Punkt(x: 3, y: 4)
var b = a                                       // Kopie!
b.verschiebe(dx: 1, dy: 1)
print(a.beschreibung(), b.beschreibung(), a.abstand, Punkt.ursprung.x)

struct Konto {
    private(set) var stand: Double = 0
    let inhaber: String
    var historie: [Double] = []

    mutating func einzahlen(_ betrag: Double) {
        guard betrag > 0 else { return }
        stand += betrag
        historie.append(betrag)
    }
    init(inhaber: String, startstand: Double = 0) {
        self.inhaber = inhaber
        self.stand = startstand
    }
}
var k = Konto(inhaber: "Mia", startstand: 100)
k.einzahlen(50); k.einzahlen(-5)
print(k.inhaber, k.stand, k.historie)

protocol Beschreibbar {
    var name: String { get }
    func beschreibe() -> String
}

extension Beschreibbar {
    func beschreibe() -> String { "Ich bin \(name)" }            // Standardimplementierung
    func lautBeschreibe() -> String { beschreibe().uppercased() }
}

struct Hund: Beschreibbar { let name: String }
struct Auto: Beschreibbar {
    let name: String
    let ps: Int
    func beschreibe() -> String { "\(name) mit \(ps) PS" }
}

let dinge: [any Beschreibbar] = [Hund(name: "Rex"), Auto(name: "Golf", ps: 110)]
for d in dinge { print(d.beschreibe(), "|", d.lautBeschreibe()) }

// Wichtige Standardprotokolle: Equatable, Comparable, Hashable, Codable, CustomStringConvertible
struct Version: Comparable, CustomStringConvertible {
    let major: Int, minor: Int
    static func < (a: Version, b: Version) -> Bool { (a.major, a.minor) < (b.major, b.minor) }
    var description: String { "v\(major).\(minor)" }
}
let versionen = [Version(major: 1, minor: 4), Version(major: 1, minor: 0), Version(major: 2, minor: 1)]
print(versionen.sorted(), versionen.max()!, Version(major: 1, minor: 0) < Version(major: 1, minor: 1))

import Foundation

func laden(_ id: Int) async -> String {
    try? await Task.sleep(nanoseconds: 50_000_000)       // simuliert Netzwerk
    return "Nutzer \(id)"
}

func laden(mitFehler: Bool) async throws -> Int {
    if mitFehler { throw URLError(.badURL) }
    return 42
}

let eins = await laden(1)
print(eins)

async let a = laden(2)                    // parallel starten
async let b = laden(3)
print(await a, await b)

let alle = await withTaskGroup(of: String.self) { gruppe in
    for id in 10...13 { gruppe.addTask { await laden(id) } }
    var ergebnisse: [String] = []
    for await r in gruppe { ergebnisse.append(r) }
    return ergebnisse.sorted()
}
print(alle)

do { print(try await laden(mitFehler: false)); print(try await laden(mitFehler: true)) }
catch { print("Fehler:", error is URLError) }

let task = Task { await laden(99) }
print(await task.value)

import Foundation

let text = """
Swift ist schnell. Swift ist sicher, und Swift macht Spaß!
Sicher und schnell: das ist Swift.
"""

let woerter = text
    .lowercased()
    .components(separatedBy: CharacterSet.letters.inverted)
    .filter { !$0.isEmpty }

var haeufigkeit: [String: Int] = [:]
for w in woerter { haeufigkeit[w, default: 0] += 1 }

let top = haeufigkeit.sorted { ($0.value, $1.key) > ($1.value, $0.key) }.prefix(4)
print("\(woerter.count) Wörter, \(haeufigkeit.count) verschiedene")
for (w, n) in top {
    print(w.padding(toLength: 8, withPad: " ", startingAt: 0), String(repeating: "#", count: n), n)
}
print("Längstes Wort:", woerter.max { $0.count < $1.count }!)

let konstante = 1        var variable: Int = 2        let (a, b) = (1, 2)
func f(label param: Int = 0) -> Int { return param }     f(label: 3)
if cond { } else if { } else { }     guard cond else { return }     switch x { case 1, 2: ...; default: ... }
for i in 0..<n { }       for (i, x) in arr.enumerated() { }     while c { }     repeat { } while c
let o: Int? = nil        if let v = o { }       o ?? 0       o?.description       o!
struct S { var a = 0; mutating func m() { } }     class C: Basis { override func f() { } }
enum E { case a, b(Int) }     protocol P { func f() }     extension T: P { }
func g<T: Comparable>(_ x: T) { }     enum Err: Error { case x }     func h() throws { }     do { try h() } catch { }