0Pricing
Swift Academy · Lekcja

Niestandardowe iteratory i wskazówki dotyczące wydajności

Implementujcie niestandardowe iteratory i sekwencje oraz dbajcie o ich wydajność: przejście jednokrotne, unikanie dodatkowych alokacji i używanie leniwych widoków.

Niestandardowe iteratory i wskazówki dotyczące wydajności to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 z 3. 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 3 lekcji w sumie.

Własne iteratory 101

Należy utworzyć własne IteratorProtocol i Sequence. Iteratory zwykle pozwalają na jednokrotne przejście i muszą zwracać nil na końcu.

Przykład IteratorProtocol

Należy zaimplementować next(), aby przy każdym wywołaniu zwracać jeden element i aktualizować stan; aby zakończyć iterację, należy zwrócić nil.

struct CountdownIterator: IteratorProtocol {
    var current: Int
    mutating func next() -> Int? {
        guard current >= 0 else { return nil }
        defer { current -= 1 }   // advance state
        return current
    }
}

var it = CountdownIterator(current: 3)
while let n = it.next() { print(n, terminator: " ") }  // 3 2 1 0
print("")

Opakowanie Sequence

Sequence udostępnia makeIterator(). Dzięki temu można używać for-in, map, filter itd.

struct Countdown: Sequence {
    let start: Int
    func makeIterator() -> CountdownIterator {
        CountdownIterator(current: start)
    }
}

for n in Countdown(start: 5) {
    print(n, terminator: " ")   // 5 4 3 2 1 0
}
print("")

Skrót AnyIterator

AnyIterator/AnySequence umożliwiają szybkie tworzenie iteratorów za pomocą domknięcia — jest to przydatne w przypadku lekkich generatorów.

// Build an iterator from a closure
var i = 1
let anyIt = AnyIterator<Int> {
    guard i <= 3 else { return nil }
    defer { i += 1 }
    return i * 10
}
let numbers = AnySequence(anyIt)
for x in numbers { print(x, terminator: " ") } // 10 20 30
print("")

lazy dla oszczędności pracy

Należy preferować .lazy, gdy potrzebna jest tylko część potoku; pozwala to ograniczyć liczbę alokacji i wykonywanych operacji.

let big = Array(1...10_000)
// Eager: builds two intermediate arrays
let eager = big.map { $0 * 2 }.filter { $0 % 3 == 0 }
// Lazy: no temporaries; work is done during collection
let lazyView = big.lazy.map { $0 * 2 }.filter { $0 % 3 == 0 }
let result = Array(lazyView.prefix(5)) // only first 5 actually computed
print(result)

Wskazówki dotyczące wydajności

Wskazówki:

  • Należy zachowywać prostotę iteratorów — aktualizować stan i zwracać nil na końcu.
  • Należy używać .lazy, aby unikać tablic pośrednich.
  • Gdy znany jest rozmiar wyniku, należy zarezerwować jego pojemność (res.reserveCapacity(n)).
  • Należy preferować algorytmy Collection, gdy potrzebne są wielokrotne przejścia lub indeksy.

Reguła iteratora

Szybkie sprawdzenie: Co musi zrobić next() na końcu iteracji?

Podsumowanie

Podsumowanie: Należy napisać minimalny IteratorProtocol, opakować go w Sequence i, gdy to możliwe, zwiększać wydajność potoków za pomocą .lazy oraz prealokacji.

Często zadawane pytania

Czy lekcja „Niestandardowe iteratory i wskazówki dotyczące wydajności” jest bezpłatna?

Tak — pełny tekst „Niestandardowe iteratory i wskazówki dotyczące wydajności” 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 3 lekcji w sumie.

Co nauczysz się w „Niestandardowe iteratory i wskazówki dotyczące wydajności”?

Implementujcie niestandardowe iteratory i sekwencje oraz dbajcie o ich wydajność: przejście jednokrotne, unikanie dodatkowych alokacji i używanie leniwych widoków. Ć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 3 z 3.

Ile czasu zajmuje lekcja „Niestandardowe iteratory i wskazówki dotyczące wydajności”?

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

  1. Hierarchie Sequence/Collection
  2. Map/Filter/Reduce, leniwe sekwencje
  3. Niestandardowe iteratory i wskazówki dotyczące wydajności
← Powrót do Swift Academy