Swift Academy · Lekcja

Generyczne subskrypty i rozszerzenia

Stosowanie ograniczeń do subskryptów i rozszerzeń.

Generyczne subskrypty i rozszerzenia 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.

Generyczne subskrypty

Subskrypty mogą być generyczne i przyjmować własne parametry typu, niezależne od typu, w którym są zdefiniowane. Dzięki temu jeden subskrypt może obsługiwać wiele typów wejściowych.

struct Lookup {
    let data = [1, 2, 3, 4, 5]
    subscript<S: Sequence>(indices idx: S) -> [Int] where S.Element == Int {
        idx.map { data[$0] }
    }
}
print(Lookup()[indices: [0, 2, 4]])

Po co używać generycznych subskryptów?

Do tego samego subskryptu można przekazać Array, Set lub Range indeksów, ponieważ akceptuje on dowolny element typu Sequence zawierający wartości Int.

struct Lookup {
    let data = [10, 20, 30, 40]
    subscript<S: Sequence>(_ idx: S) -> [Int] where S.Element == Int {
        idx.map { data[$0] }
    }
}
let l = Lookup()
print(l[0...1])
print(l[[3, 0]])

Ograniczone rozszerzenia

Konstrukcja extension ... where dodaje składowe dostępne tylko wtedy, gdy ograniczenie jest spełnione. Pojawiają się one w typie wyłącznie dla pasujących argumentów generycznych.

extension Array where Element: Numeric {
    func sumAll() -> Element { reduce(0, +) }
}
print([1, 2, 3].sumAll())
print([1.5, 2.5].sumAll())

Rozszerzenie dla konkretnego typu elementu

Użyj where Element == String, aby dodać pomocnicze metody specyficzne dla String tylko do tablic ciągów znaków.

extension Array where Element == String {
    func shout() -> [String] { map { $0.uppercased() + "!" } }
}
print(["hi", "bye"].shout())

Ograniczone rozszerzenie z protokołem

Dodaj funkcjonalność, gdy elementy są zgodne z własnym protokołem.

protocol Priced { var price: Double { get } }
struct Item: Priced { let price: Double }
extension Collection where Element: Priced {
    var total: Double { reduce(0) { $0 + $1.price } }
}
print([Item(price: 2), Item(price: 3)].total)

Generyczny subskrypt zwracający Optional

Subskrypt może być generyczny i zwracać wartość opcjonalną, na przykład podczas bezpiecznego indeksowania kolekcji.

extension Array {
    subscript(safe i: Int) -> Element? {
        indices.contains(i) ? self[i] : nil
    }
}
print([1, 2, 3][safe: 1] ?? -1)
print([1, 2, 3][safe: 9] ?? -1)

Generyczny subskrypt słownika

Generyczne subskrypty mogą przyjmować sekwencję kluczy i zwracać odpowiadające im wartości.

extension Dictionary {
    subscript<S: Sequence>(keys ks: S) -> [Value] where S.Element == Key {
        ks.compactMap { self[$0] }
    }
}
let d = ["a": 1, "b": 2, "c": 3]
print(d[keys: ["a", "c"]].sorted())

Łączenie z where dla Self

Rozszerzenia typów generycznych mogą ograniczać opakowany typ, udostępniając dopasowane do niego API.

struct Stack<T> { var items: [T] = [] }
extension Stack where T: Comparable {
    var peakMax: T? { items.max() }
}
var s = Stack<Int>(); s.items = [3, 9, 1]
print(s.peakMax!)

Generyczny subskrypt z wieloma parametrami

Subskrypt może jednocześnie przyjmować kilka argumentów i własne parametry typu.

struct Grid {
    let rows = [[1, 2], [3, 4]]
    subscript(_ r: Int, _ c: Int) -> Int { rows[r][c] }
}
print(Grid()[1, 0])

Tylko do odczytu a odczyt i zapis

Podobnie jak właściwości, subskrypty mogą mieć tylko get albo zarówno get, jak i set, aby umożliwiać modyfikowanie wartości.

struct Pad {
    var values = [0, 0, 0]
    subscript(i: Int) -> Int {
        get { values[i] }
        set { values[i] = newValue }
    }
}
var p = Pad(); p[1] = 7
print(p.values)

Połączenie wszystkiego

Generyczne subskrypty i ograniczone rozszerzenia pozwalają tworzyć wyraziste, bezpieczne typowo interfejsy API, które dostosowują się do używanych typów elementów lub argumentów.

extension Array where Element: Comparable {
    subscript(topAfterSort i: Int) -> Element { sorted()[i] }
}
print([5, 1, 9, 3][topAfterSort: 0])

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat generycznych subskryptów i ograniczonych rozszerzeń.

Podsumowanie

Generyczne subskrypty deklarują własne parametry typu i klauzule where, dzięki czemu jeden subskrypt może akceptować wiele typów wejściowych. Ograniczone rozszerzenia (where Element: ... lub == ...) dodają składowe tylko wtedy, gdy warunki są spełnione. Razem pozwalają tworzyć bezpieczne typowo i elastyczne interfejsy API.

Często zadawane pytania

Czy lekcja „Generyczne subskrypty i rozszerzenia” jest bezpłatna?

Tak — pełny tekst „Generyczne subskrypty i rozszerzenia” 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 „Generyczne subskrypty i rozszerzenia”?

Stosowanie ograniczeń do subskryptów i rozszerzeń. Ć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 „Generyczne subskrypty i rozszerzenia”?

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