Kontrol af typer med is
Test en instans’ type, før De caster den.
Kontrol af typer med is er en gratis Swift Academy-lektion på CoddyKit. Dette er lektion 4 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.
is-operatoren
Typekontroloperatoren is returnerer en Bool, der fortæller, om en instans er af en given type (eller undertype). Den laver ikke casting; den tester blot.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a is Dog)
print(a is Cat)Test af undertypetilhørsforhold
is er true, når instansen er præcis den pågældende type eller en af dens underklasser. En Dog er et Animal.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a is Animal)
print(a is Dog)Brug af is i betingelser
Du kan forgrene på et typetjek med if og vælge adfærd ud fra typen under kørsel.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
if a is Cat {
print("It is a cat")
} else {
print("Not a cat")
}Optælling af typer i en samling
En praktisk anvendelse af is er at tælle, hvor mange elementer i et array med blandede typer der matcher en bestemt type.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia"), Dog(name: "Buddy")]
let dogCount = zoo.filter { $0 is Dog }.count
print("Dogs:", dogCount)is med protokoller
is tjekker også, om en instans overholder en protokol, og returnerer true, når den gør.
protocol Flyer {}
class Bird: Flyer {}
class Fish {}
let creatures: [Any] = [Bird(), Fish()]
for c in creatures { print(c is Flyer) }is sammenlignet med as?
is svarer kun ja eller nej. as? går videre og giver dig værdien, hvis du har brug for at bruge medlemmerne fra underklassen.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print("Check only:", a is Dog)
if let d = a as? Dog { print("Use it:", d.bark()) }Beskyttelse med is
Brug is i en guard til at afslutte tidligt, når en instans ikke har den forventede type.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
func onlyForCats(_ a: Animal) {
guard a is Cat else {
print("Skipping non-cat")
return
}
print("Processing a cat")
}
onlyForCats(Cat(name: "Mia"))
onlyForCats(Dog(name: "Rex"))Kombinering af is i switch
Du kan indirekte skifte ud fra typekontroller, men mønstermatchning med case is er overskuelig, når du håndterer flere typer.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let items: [Any] = [Dog(name: "Rex"), 42, "hello"]
for item in items {
switch item {
case is Dog: print("a dog")
case is Int: print("an integer")
default: print("something else")
}
}is tjekker typen under kørsel
is undersøger den faktiske type under kørsel, ikke variablens erklærede type. En variabel af typen Animal, der indeholder en Dog, består is Dog-tjekket.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let declaredAsAnimal: Animal = Dog(name: "Rex")
print("Runtime is Dog:", declaredAsAnimal is Dog)Validering før en tvungen typekonvertering
Et sikkert mønster er at tjekke med is og først derefter bruge as!, fordi du har bevist typen.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
if a is Dog {
let d = a as! Dog
print(d.bark())
}Eksempel på typetjek
Samlet giver is til tjek og as? til typekonvertering dig et komplet og sikkert værktøjssæt til typer under kørsel.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for a in zoo {
if a is Dog { print("dog:", a.name) }
if a is Cat { print("cat:", a.name) }
}Hurtigt tjek
Husk, hvad operatoren is returnerer.
Opsummering: Tjek af typer med is
Du har lært, at is returnerer en Bool for tilhørsforhold til typen under kørsel, herunder underklasser og overholdelse af protokoller, at den fungerer godt sammen med filtrering og switch case is, og at et tjek med is før en as! gør en tvungen typekonvertering sikker.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia"), Dog(name: "Buddy")]
print("Cats:", zoo.filter { $0 is Cat }.count)
print("Dogs:", zoo.filter { $0 is Dog }.count)
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
Ofte stillede spørgsmål
Er lektionen “Kontrol af typer med is” gratis?
Ja — alle 3 lektioner i læringssporet Swift Academy, inklusive “Kontrol af typer med is”, 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 “Kontrol af typer med is”?
Test en instans’ type, før De caster den. 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 4 af 4.
Hvor lang tid tager lektionen “Kontrol af typer med is”?
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
- Grundlæggende upcasting og downcasting
- Betinget casting med as?
- Tvungen casting med as! og dens risici
- Kontrol af typer med is