Swift Academy · Lektion

Generiska funktioner och typer

Skriv generiska funktioner och typer med typparametrar (t.ex. ). Se hur kompilatorn härleder typer och håller koden säker och återanvändbar.

Lektion 1 av 38 steg

Generiska funktioner och typer är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 1 av 3. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 3 lektioner.

Varför generics?

Generics låter Er skriva en enda funktion eller typ som fungerar med många typer och samtidigt förblir typsäker. Ni kommer att se <T> för typparametrar och hur inferens förenklar anrop.

Generisk funktion

En generisk funktion använder en typparameter (<T>). Kompilatorn kontrollerar typerna vid varje anrop.

// Generic swap for any type T
func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 1, y = 2
swapValues(&x, &y)
print(x, y)  // 2 1

var s1 = "A", s2 = "B"
swapValues(&s1, &s2)
print(s1, s2) // B A

Generisk typ

Även typer kan vara generiska: deklarera Stack<Element> och återanvänd den för Int, String med mera.

// A minimal generic stack
struct Stack<Element> {
    private var items: [Element] = []
    mutating func push(_ x: Element) { items.append(x) }
    mutating func pop() -> Element? { items.popLast() }
    var top: Element? { items.last }
}

var intStack = Stack<Int>()
intStack.push(10); intStack.push(20)
print(intStack.top ?? -1)   // 20

var textStack = Stack<String>()
textStack.push("hi"); textStack.push("bye")
print(textStack.pop() ?? "?")

Typinferens

Swift härleder ofta generiska typer, så Ni behöver sällan ange dem explicit vid anrop.

// The compiler infers T from arguments/assignments
func makePair<T>(_ a: T, _ b: T) -> (T, T) { (a, b) }

let pair1 = makePair(1, 2)          // T inferred as Int
let pair2 = makePair("a", "b")      // T inferred as String
print(pair1, pair2)

Undvik duplicering

Utan generics måste Ni upprepa koden för varje typ. Generics eliminerar duplicering och behåller samtidigt statiska kontroller.

// Non-generic overloads would duplicate logic:
func eqInt(_ a: Int, _ b: Int) -> Bool { a == b }
func eqStr(_ a: String, _ b: String) -> Bool { a == b }
// A single generic can replace both:

Anteckningar och namngivning

Anteckningar:

Använd tydliga namn: T, Element eller domänspecifika namn.
Håll API:erna små och fokuserade.
Nästa steg: lägg till begränsningar med where för att begränsa T vid behov.

Betydelsen av <T>

Snabb kontroll: Vad betyder <T> i en generisk funktion?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Sammanfattning: Definiera generiska funktioner med <T> och skapa generiska typer som Stack<Element>. Swift härleder typer vid anrop, vilket gör koden återanvändbar och säker.

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Generiska funktioner och typer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Generiska funktioner och typer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 3 lektioner.

Vad lär jag mig i ”Generiska funktioner och typer”?

Skriv generiska funktioner och typer med typparametrar (t.ex. ). Se hur kompilatorn härleder typer och håller koden säker och återanvändbar. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 3.

Hur lång tid tar lektionen ”Generiska funktioner och typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Swift Academy