Swift Academy · Lekcja

Ograniczenia parametrów typów

Wymaganie zgodności parametrów generycznych z protokołami.

Ograniczenia parametrów typów to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 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.

Podsumowanie typów generycznych

Funkcja generyczna używa parametru typu, takiego jak <T>, dzięki czemu działa z wieloma typami. Jednak nieograniczony T można jedynie przekazywać dalej, bez sprawdzania jego właściwości. Ograniczenia udostępniają dodatkowe możliwości.

func identity<T>(_ x: T) -> T { x }
print(identity(5))
print(identity("hi"))

Ograniczenie Comparable

Zapis <T: Comparable> gwarantuje, że wartości typu T obsługują operator <, > i podobne operatory, dzięki czemu można je porównywać.

func largest<T: Comparable>(_ a: T, _ b: T) -> T {
    a > b ? a : b
}
print(largest(3, 9))
print(largest("apple", "pear"))

Dlaczego potrzebne są ograniczenia

Bez Comparable kompilator odrzuca wyrażenie a > b, ponieważ nie każdy typ je obsługuje. Ograniczenie jest obietnicą, która sprawia, że operacja jest dozwolona.

func minOf<T: Comparable>(_ list: [T]) -> T? {
    list.min()
}
print(minOf([4, 2, 8])!)

Ograniczenie Equatable

Equatable udostępnia operatory == i !=. Należy go używać do zliczania lub wyszukiwania pasujących elementów.

func count<T: Equatable>(_ x: T, in list: [T]) -> Int {
    list.filter { $0 == x }.count
}
print(count(2, in: [2, 3, 2, 2]))

Ograniczenie Hashable

Hashable pozwala używać wartości jako elementów Set lub kluczy słownika.

func unique<T: Hashable>(_ list: [T]) -> [T] {
    Array(Set(list))
}
print(unique([1, 1, 2, 3, 3]).sorted())

Ograniczenia protokołów

Dowolny protokół może być ograniczeniem. W tym przykładzie własny protokół udostępnia swoją metodę dla parametru generycznego.

protocol Speaker { func speak() -> String }
struct Dog: Speaker { func speak() -> String { "Woof" } }

func announce<T: Speaker>(_ x: T) {
    print(x.speak())
}
announce(Dog())

Ograniczenia klas

Można wymagać, aby T dziedziczył po określonej klasie, uzyskując dostęp do jej składowych.

class Animal { func name() -> String { "animal" } }
class Cat: Animal { override func name() -> String { "cat" } }

func describe<T: Animal>(_ x: T) { print(x.name()) }
describe(Cat())

Wiele ograniczeń

Za pomocą & można połączyć ograniczenia, aby wymagać zgodności z kilkoma protokołami jednocześnie.

func show<T: CustomStringConvertible & Equatable>(_ a: T, _ b: T) {
    print(a.description, a == b)
}
show(5, 5)

Wiele parametrów typu

Funkcja może mieć kilka ograniczonych parametrów, z których każdy ma własne wymagania.

func zipMap<K: Hashable, V>(_ keys: [K], _ vals: [V]) -> [K: V] {
    var d: [K: V] = [:]
    for (k, v) in zip(keys, vals) { d[k] = v }
    return d
}
print(zipMap(["a", "b"], [1, 2]))

Ograniczenia typów

Typy generyczne, a nie tylko funkcje, również mogą przyjmować ograniczenia. Generyczna struktura może wymagać, aby jej parametr był zgodny z protokołem.

struct SortedBox<T: Comparable> {
    var items: [T]
    var smallest: T? { items.min() }
}
print(SortedBox(items: [5, 1, 9]).smallest!)

Ograniczenia numeryczne

Standardowe protokoły, takie jak Numeric, pozwalają kodowi generycznemu wykonywać działania arytmetyczne na typach Int, Double i innych.

func sum<T: Numeric>(_ list: [T]) -> T {
    list.reduce(0, +)
}
print(sum([1, 2, 3]))
print(sum([1.5, 2.5]))

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat ograniczeń parametrów typu.

Podsumowanie

Ograniczenia parametrów typu (<T: Protocol> lub <T: SomeClass>) informują kompilator, co może robić typ generyczny. Zobaczyłeś Comparable, Equatable, Hashable, Numeric, własne protokoły, ograniczenia klas, wiele ograniczeń połączonych za pomocą & oraz ograniczenia typów generycznych.

Często zadawane pytania

Czy lekcja „Ograniczenia parametrów typów” jest bezpłatna?

Tak — pełny tekst „Ograniczenia parametrów typów” 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 „Ograniczenia parametrów typów”?

Wymaganie zgodności parametrów generycznych z protokołami. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Ograniczenia parametrów typów”?

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

← Powrót do Swift Academy