Swift Academy · Lektion

Typeinferens og eksplicitte typer

Lær, hvordan Swift udleder typer, og hvornår De bør angive dem eksplicit.

Lektion 2 af 412 trin

Typeinferens og eksplicitte typer er en gratis Swift Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Swift Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Swift Academy-kurset indeholder 4 lektioner i alt.

Velkommen

Swift er et *statisk typet* sprog — hver værdi har en type, der er kendt på kompileringstidspunktet. Men du behøver sjældent selv at skrive typen, fordi Swift udleder den for dig.

Hvad er typeinferens?

Swift undersøger værdien på højre side og udleder automatisk typen: ```swift let message = "Hello" // inferred as String let count = 42 // inferred as Int let price = 9.99 // inferred as Double ``` Der kræves ingen typeannotering — kompileren finder ud af det.

Eksplicitte typeannoteringer

Du kan altid angive typen eksplicit med et kolon: ```swift let message: String = "Hello" let count: Int = 42 let price: Double = 9.99 ``` Det er nyttigt, når den udledte type ikke er den, du ønsker.

Når inferensen vælger den forkerte type

Flydende kommatal-litteraler har som standard typen `Double`. Hvis du har brug for `Float`, skal du annotere typen eksplicit: ```swift let inferred = 3.14 // Double let explicit: Float = 3.14 // Float ``` Heltalslitteraler har tilsvarende som standard typen `Int` — tilføj en annotering for `Int32`, `UInt8` osv.

Typesikkerhed i praksis

Når en type først er fastlagt, kan den ikke ændres: ```swift var score = 0 // Int score = "ten" // ❌ cannot assign String to Int ``` Typesikkerhed fanger denne type fejl på kompileringstidspunktet, længe før programmet kører.

Funktionen type(of:)

Brug `type(of:)` til at undersøge typen under kørsel: ```swift let value = 42 print(type(of: value)) // Int let name = "Alice" print(type(of: name)) // String ``` Det er nyttigt til fejlfinding af overraskelser ved typeinferens.

Typealiaser

`typealias` giver en eksisterende type et nyt navn for at forbedre læsbarheden: ```swift typealias Celsius = Double typealias UserID = Int var temperature: Celsius = 36.6 var userId: UserID = 1001 ``` Typealiaser er kun kosmetiske — den underliggende type ændres ikke.

Annoteringer uden initialisering

Når du deklarerer en variabel uden en initialværdi, *skal* du annotere typen: ```swift var name: String // ✓ annotation required name = "Bob" var total: Int total = 0 ``` Swift kan ikke udlede en type, når der ikke findes en værdi.

Numeriske litteraler og læsbarhed

Swift tillader understregninger i numeriske litteraler for at gøre dem mere læsbare: ```swift let million = 1_000_000 let hex = 0xFF_EC_D3 let binary = 0b1111_0000 ``` Kompileren ignorerer understregningerne — de er kun kosmetiske.

Typekonvertering — ingen implicitte konverteringer

Swift konverterer aldrig implicit mellem typer. Du skal gøre det eksplicit: ```swift let intVal: Int = 5 let dblVal: Double = Double(intVal) // explicit conversion let sum = Double(intVal) + 2.5 ``` Det undgår vanskelige fejl, der skyldes utilsigtede numeriske konverteringer.

Hurtigt tjek

Hvilken type udleder Swift for `let x = 3.14`?

Besvar den i den interaktive lektion

Opsummering

Vigtigste pointer: • Swift udleder typer fra initialværdier — der kræves normalt ingen annotering • Eksplicitte annoteringer (`: Type`) tilsidesætter inferensen • Flydende kommatal har som standard typen `Double`, heltal typen `Int` • Ingen implicitte konverteringer — brug `Int()`, `Double()` osv. • `type(of:)` viser typen under kørsel Næste emne: kernetyperne — tal, Bool og Character.

Gratis at komme i gang

Lær Swift med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 122
Lektioner: 409

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Typeinferens og eksplicitte typer” gratis?

Ja — alle 3 lektioner i læringssporet Swift Academy, inklusive “Typeinferens og eksplicitte typer”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Swift Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Typeinferens og eksplicitte typer”?

Lær, hvordan Swift udleder typer, og hvornår De bør angive dem eksplicit. Du øver dig i Swift Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Swift Academy?

Der kræves ingen tidligere erfaring. Swift Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Typeinferens og eksplicitte typer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Swift Academy-lektion?

Ja. Alle Swift Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

let kontra var: Konstanter og variabler
Typeinferens og eksplicitte typer
Tal, boolske værdier og tegn
Grundlæggende om String og interpolation

← Tilbage til Swift Academy