Typen mit is prüfen
Prüfen Sie den Typ einer Instanz vor dem Casting.
Typen mit is prüfen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.
Der Operator is
Der Typprüfoperator is gibt einen Bool zurück, der angibt, ob eine Instanz einem bestimmten Typ oder Untertyp entspricht. Er führt kein Casting durch, sondern prüft lediglich.
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)Zugehörigkeit zu einem Untertyp prüfen
is ist wahr, wenn die Instanz genau diesen Typ oder eine beliebige Unterklasse davon besitzt. Ein Dog ist ein 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)is in Bedingungen verwenden
Sie können anhand einer Typprüfung mit if verzweigen und abhängig vom Laufzeittyp unterschiedliches Verhalten wählen.
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")
}Typen in einer Sammlung zählen
Eine nützliche Anwendung von is besteht darin, in einem gemischten Array zu zählen, wie viele Elemente einem bestimmten Typ entsprechen.
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 mit Protokollen
is prüft auch, ob eine Instanz einem Protokoll entspricht, und gibt in diesem Fall true zurück.
protocol Flyer {}
class Bird: Flyer {}
class Fish {}
let creatures: [Any] = [Bird(), Fish()]
for c in creatures { print(c is Flyer) }is oder as?
is beantwortet nur eine Ja-Nein-Frage. as? geht weiter und liefert den Wert, wenn Sie die Member der Unterklasse verwenden müssen.
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()) }Mit is absichern
Verwenden Sie is in einem guard, um frühzeitig abzubrechen, wenn eine Instanz nicht den erwarteten Typ hat.
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"))is in switch kombinieren
Sie können Typprüfungen indirekt mit switch behandeln, aber Pattern Matching mit case is ist übersichtlich, wenn mehrere Typen verarbeitet werden.
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 prüft den Laufzeittyp
is untersucht den tatsächlichen Laufzeittyp, nicht den deklarierten Variablentyp. Eine als Animal typisierte Variable, die einen Dog enthält, besteht die Prüfung is Dog.
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)Vor einer erzwungenen Typumwandlung prüfen
Ein sicheres Muster besteht darin, mit is zu prüfen und erst danach as! zu verwenden, weil Sie den Typ bereits nachgewiesen haben.
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())
}Beispielzusammenfassung zur Typprüfung
Zusammen bieten is zum Prüfen und as? zur Typumwandlung ein vollständiges, sicheres Werkzeugset für Laufzeittypen.
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) }
}Kurzer Test
Rufen Sie sich in Erinnerung, was der Operator is zurückgibt.
Zusammenfassung: Typen mit is prüfen
Sie haben gelernt, dass is einen Bool für die Zugehörigkeit zu einem Laufzeittyp zurückgibt, einschließlich Unterklassen und Protokollkonformität, dass sich der Operator gut mit dem Filtern und switch case is kombinieren lässt und dass eine Prüfung mit is vor einem as! eine erzwungene Typumwandlung sicher macht.
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)Häufig gestellte Fragen
Ist die Lektion „Typen mit is prüfen“ kostenlos?
Ja — der vollständige Text von „Typen mit is prüfen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Typen mit is prüfen“?
Prüfen Sie den Typ einer Instanz vor dem Casting. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Swift Academy zu starten?
Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Typen mit is prüfen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?
Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Grundlagen von Upcasting und Downcasting
- Bedingtes Casting mit as?
- Erzwungenes Casting mit as! und seine Risiken
- Typen mit is prüfen