Swift Academy · Pelajaran

Membangun Rangkaian Lazy Kustom

Buat rangkaian Anda sendiri yang dievaluasi secara lazy.

Membangun Rangkaian Lazy Kustom adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Mengapa Evaluasi Malas Kustom?

Selain map dan filter, Anda dapat membuat urutan yang dievaluasi secara malas untuk hal-hal seperti generator tak terbatas atau aliran hasil komputasi mahal yang seharusnya berjalan sesuai permintaan.

Tipe LazySequence

Memanggil .lazy membungkus koleksi dalam konformer LazySequenceProtocol. Operasi yang Anda tambahkan menghasilkan pembungkus malas lainnya:

let view = [1, 2, 3].lazy
let mapped = view.map { $0 * 2 }
print(Array(mapped))  // [2, 4, 6]  -- LazyMapSequence

Urutan Berbasis Permintaan

Urutan kustom berbasis permintaan: setiap panggilan pada iterator menghitung nilai berikutnya hanya ketika diminta. Berikut generator Fibonacci:

struct Fibonacci: Sequence, IteratorProtocol {
    var a = 0, b = 1
    mutating func next() -> Int? {
        let r = a
        (a, b) = (b, a + b)
        return r
    }
}
print(Array(Fibonacci().prefix(6)))  // [0, 1, 1, 2, 3, 5]

Tak Terbatas, Dikonsumsi secara Malas

Karena nilai diambil sesuai permintaan, urutan tak terbatas aman selama Anda mengambil sebagian urutan yang berhingga:

struct Naturals: Sequence, IteratorProtocol {
    var n = 1
    mutating func next() -> Int? { defer { n += 1 }; return n }
}
print(Array(Naturals().prefix(4)))  // [1, 2, 3, 4]

Memenuhi LazySequenceProtocol

Mengadopsi LazySequenceProtocol membuat tipe Anda sendiri dapat dirangkai secara malas dengan map/filter juga:

struct Counter: Sequence, IteratorProtocol, LazySequenceProtocol {
    var n = 0; let limit: Int
    mutating func next() -> Int? {
        guard n < limit else { return nil }
        defer { n += 1 }
        return n
    }
}
print(Array(Counter(n: 0, limit: 3).map { $0 * 10 }))  // [0, 10, 20]

sequence(first:next:)

Standard library menyediakan pembuat urutan untuk urutan malas kustom tanpa tipe baru:

let powers = sequence(first: 1) { $0 <= 16 ? $0 * 2 : nil }
print(Array(powers))  // [1, 2, 4, 8, 16, 32]

sequence(state:next:)

Simpan keadaan yang lebih kaya di antara setiap langkah:

let fibs = sequence(state: (0, 1)) { (s: inout (Int, Int)) -> Int? in
    let r = s.0
    s = (s.1, s.0 + s.1)
    return r
}
print(Array(fibs.prefix(6)))  // [0, 1, 1, 2, 3, 5]

Pembungkus AnySequence

Sembunyikan tipe konkret di balik AnySequence saat mengekspos API:

func evens(upTo n: Int) -> AnySequence<Int> {
    AnySequence((0...n).lazy.filter { $0 % 2 == 0 })
}
print(Array(evens(upTo: 8)))  // [0, 2, 4, 6, 8]

Aliran Komputasi Malas

Tunda pekerjaan yang mahal sampai setiap elemen benar-benar dikonsumsi:

let stream = (1...5).lazy.map { (n: Int) -> Int in
    print("computing \(n)")
    return n * n
}
print(stream.first!)  // computing 1, then 1

Menghentikan Generator

Kembalikan nil dari next() untuk mengakhiri urutan dengan bersih:

let countdown = sequence(state: 3) { (s: inout Int) -> Int? in
    guard s > 0 else { return nil }
    defer { s -= 1 }
    return s
}
print(Array(countdown))  // [3, 2, 1]

Menyatukan Semuanya

Gabungkan generator kustom dengan operator malas untuk membuat alur sesuai permintaan:

let primesIsh = sequence(first: 2) { $0 < 20 ? $0 + 1 : nil }
    .lazy
    .filter { n in (2..<n).allSatisfy { n % $0 != 0 } }
print(Array(primesIsh))  // [2, 3, 5, 7, 11, 13, 17, 19]

Pemeriksaan Singkat

Apa yang menandakan akhir dari urutan IteratorProtocol kustom?

Ringkasan

Anda telah mempelajari urutan malas kustom:

.lazy menghasilkan pembungkus LazySequenceProtocol
Implementasikan Sequence + IteratorProtocol; next() mengembalikan nil untuk berhenti
Gunakan sequence(first:next:) / sequence(state:next:) sebagai pembuat cepat
Bungkus dalam AnySequence untuk menyembunyikan tipe konkret

Kursus selesai! Berikutnya: pembahasan mendalam tentang closures.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Rangkaian Lazy Kustom” gratis?

Ya — teks lengkap “Membangun Rangkaian Lazy Kustom” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun Rangkaian Lazy Kustom”?

Buat rangkaian Anda sendiri yang dievaluasi secara lazy. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Membangun Rangkaian Lazy Kustom” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy