Swift Academy · Pelajaran

Pelaksanaan Lalai dalam Extension

Sediakan tingkah laku dikongsi melalui extension protokol.

Pelajaran 2 daripada 413 langkah

Pelaksanaan Lalai dalam Extension ialah pelajaran Swift Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Swift Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Masalahnya

Protokol mengisytiharkan keperluan tetapi tidak menyediakan tingkah laku. Jika setiap jenis yang mematuhinya perlu mengulangi logik yang sama, anda akan menduplikasi kod. Sambungan protokol menyelesaikan masalah ini dengan menyediakan pelaksanaan lalai.

protocol Greeter {
    func greet() -> String
}

Menambahkan Nilai Lalai

Sambungan pada protokol boleh melaksanakan sesuatu keperluan. Jenis yang mematuhi protokol menerima tingkah laku itu secara percuma melainkan jenis tersebut menggantikannya.

protocol Greeter { func greet() -> String }

extension Greeter {
    func greet() -> String { "Hello!" }
}

struct Robot: Greeter {}
print(Robot().greet())

Menggantikan Nilai Lalai

Jenis yang mematuhi protokol boleh menyediakan pelaksanaannya sendiri, yang diberi keutamaan berbanding nilai lalai daripada sambungan.

protocol Greeter { func greet() -> String }
extension Greeter { func greet() -> String { "Hello!" } }

struct French: Greeter {
    func greet() -> String { "Bonjour!" }
}
print(French().greet())

Menambahkan Kaedah Tambahan

Sambungan boleh menambahkan kaedah baharu sepenuhnya yang langsung tiada dalam protokol. Setiap jenis yang mematuhinya mendapat kaedah tersebut secara automatik.

protocol Named { var name: String { get } }

extension Named {
    func loudName() -> String { name.uppercased() }
}

struct City: Named { let name: String }
print(City(name: "paris").loudName())

Sifat Terhitung Lalai

Sambungan juga boleh menyediakan sifat terhitung sebagai nilai lalai.

protocol Sized {
    var width: Double { get }
    var height: Double { get }
}

extension Sized {
    var area: Double { width * height }
}

struct Rect: Sized { let width: Double; let height: Double }
print(Rect(width: 2, height: 5).area)

Membina Berdasarkan Keperluan

Pelaksanaan lalai boleh memanggil keperluan protokol itu sendiri, lalu menggabungkan tingkah laku yang lebih kaya daripada kontrak minimum yang mesti disediakan oleh setiap jenis.

protocol Summable {
    var values: [Int] { get }
}

extension Summable {
    var total: Int { values.reduce(0, +) }
}

struct Cart: Summable { let values: [Int] }
print(Cart(values: [10, 20, 30]).total)

Sambungan Berkekangan

Gunakan klausa where supaya nilai lalai hanya digunakan apabila syarat tambahan dipenuhi. Di sini, nilai lalai hanya wujud apabila Self juga merupakan Equatable.

protocol Container {
    associatedtype Item
    var items: [Item] { get }
}

extension Container where Item: Equatable {
    func contains(_ x: Item) -> Bool { items.contains(x) }
}

struct Bag: Container { let items: [Int] }
print(Bag(items: [1, 2, 3]).contains(2))

Nilai Lalai dan Keperluan Bersama

Anda boleh mengisytiharkan kaedah dalam protokol AND menyediakan nilai lalai. Menyenaraikannya dalam protokol membolehkan penghantaran dinamik melalui jenis protokol.

protocol Logger {
    func log() -> String
}
extension Logger {
    func log() -> String { "default log" }
}

struct A: Logger {}
struct B: Logger { func log() -> String { "B log" } }

let loggers: [Logger] = [A(), B()]
for l in loggers { print(l.log()) }

Perkara Penting tentang Penghantaran Statik

Jika sesuatu kaedah hanya terdapat dalam sambungan (bukan dalam protokol), panggilan melalui nilai berjenis protokol menggunakan versi daripada sambungan, walaupun jenis konkrit mentakrifkan versinya sendiri. Isytiharkan kaedah itu dalam protokol untuk membolehkan penghantaran dinamik.

protocol P {}
extension P { func who() -> String { "P-default" } }
struct Q: P { func who() -> String { "Q" } }

let direct = Q()
let asP: P = Q()
print(direct.who())
print(asP.who())

Mengurangkan Kod Berulang

Gabungan permukaan keperluan yang kecil dengan nilai lalai yang kaya ialah teras reka bentuk berorientasikan protokol: jenis yang mematuhi protokol melaksanakan minimum yang diperlukan, manakala tingkah laku dikongsi diletakkan di satu tempat.

protocol Identifiable { var id: Int { get } }
extension Identifiable {
    var tag: String { "ID-" + String(id) }
}
struct Order: Identifiable { let id: Int }
print(Order(id: 7).tag)

Menggabungkan Beberapa Sambungan

Anda boleh membahagikan nilai lalai merentasi beberapa sambungan untuk pengaturan; semuanya menyumbang kepada jenis yang mematuhi protokol.

protocol Money { var cents: Int { get } }
extension Money { var dollars: Double { Double(cents) / 100 } }
extension Money { var label: String { "$" + String(format: "%.2f", dollars) } }

struct Price: Money { let cents: Int }
print(Price(cents: 1299).label)

Semakan Pantas

Uji pemahaman anda tentang nilai lalai sambungan protokol.

Jawab dalam pelajaran interaktif

Ringkasan

Sambungan protokol menyediakan pelaksanaan lalai, membolehkan jenis yang mematuhinya mewarisi tingkah laku dikongsi dan menggantikannya apabila perlu. Anda boleh menambahkan kaedah tambahan dan sifat terhitung, mengehadkan nilai lalai dengan where, serta mempelajari peraturan penghantaran statik berbanding dinamik: isytiharkan kaedah dalam protokol untuk penghantaran dinamik.

Percuma untuk bermula

Pelajari Swift dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 122
Pelajaran: 409

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pelaksanaan Lalai dalam Extension” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Swift Academy, termasuk “Pelaksanaan Lalai dalam Extension”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pelaksanaan Lalai dalam Extension”?

Sediakan tingkah laku dikongsi melalui extension protokol. Anda berlatih Swift Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Swift Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Swift Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Pelaksanaan Lalai dalam Extension” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy