Sprawdzanie typów za pomocą is
Sprawdzanie typu instancji przed rzutowaniem.
Sprawdzanie typów za pomocą is to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.
Operator is
Operator sprawdzania typu is zwraca wartość typu Bool, która informuje, czy instancja jest danego typu lub jego podtypu. Nie wykonuje rzutowania, a jedynie sprawdza typ.
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)Sprawdzanie przynależności do podtypu
Operator is zwraca wartość true, gdy instancja jest dokładnie danego typu lub dowolnej jego podklasy. Dog jest obiektem typu 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)Używanie is w warunkach
Za pomocą if można rozgałęziać wykonanie na podstawie sprawdzenia typu, wybierając działanie zależnie od typu w czasie wykonania.
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")
}Zliczanie typów w kolekcji
Praktycznym zastosowaniem is jest zliczanie elementów określonego typu w tablicy zawierającej różne typy.
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 z protokołami
is sprawdza także, czy instancja jest zgodna z protokołem, i zwraca true, jeśli tak jest.
protocol Flyer {}
class Bird: Flyer {}
class Fish {}
let creatures: [Any] = [Bird(), Fish()]
for c in creatures { print(c is Flyer) }is a as?
is odpowiada tylko „tak” lub „nie”. as? idzie o krok dalej i zwraca wartość, jeśli trzeba użyć elementów klasy podrzędnej.
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()) }Sprawdzanie za pomocą is
Użyj is w guard, aby wcześniej zakończyć działanie, gdy instancja nie ma oczekiwanego typu.
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"))Łączenie is w switch
Sprawdzanie typów można pośrednio połączyć z switch, ale dopasowanie wzorców za pomocą case is zapewnia czytelny zapis podczas obsługi kilku typów.
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 sprawdza typ w czasie wykonania
is sprawdza rzeczywisty typ w czasie wykonania, a nie zadeklarowany typ zmiennej. Zmienna typu Animal, która przechowuje obiekt Dog, przejdzie sprawdzenie 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)Weryfikowanie przed wymuszonym rzutowaniem
Bezpieczny wzorzec polega na sprawdzeniu za pomocą is, a dopiero potem użyciu as!, ponieważ typ został wcześniej potwierdzony.
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())
}Przykład podsumowujący sprawdzanie typów
Razem is do sprawdzania i as? do rzutowania zapewniają kompletny, bezpieczny zestaw narzędzi do pracy z typami w czasie wykonania.
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) }
}Szybkie sprawdzenie
Przypomnij sobie, co zwraca operator is.
Podsumowanie: sprawdzanie typów za pomocą is
Dowiedzieli się Państwo, że is zwraca wartość Bool informującą o przynależności do typu w czasie wykonania, uwzględniając klasy podrzędne i zgodność z protokołem, że dobrze współpracuje z filtrowaniem oraz switch case is, a sprawdzenie za pomocą is przed użyciem as! sprawia, że wymuszone rzutowanie jest bezpieczne.
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)Często zadawane pytania
Czy lekcja „Sprawdzanie typów za pomocą is” jest bezpłatna?
Tak — pełny tekst „Sprawdzanie typów za pomocą is” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Sprawdzanie typów za pomocą is”?
Sprawdzanie typu instancji przed rzutowaniem. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Swift Academy?
Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Sprawdzanie typów za pomocą is”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?
Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Podstawy rzutowania w górę i w dół
- Warunkowe rzutowanie za pomocą as?
- Wymuszone rzutowanie za pomocą as! i jego zagrożenia
- Sprawdzanie typów za pomocą is