Swift Academy · Pelajaran

Penaipan Bersyarat dengan as?

Cuba lakukan penaipan yang mengembalikan pilihan apabila gagal.

Pelajaran 2 daripada 413 langkah

Penaipan Bersyarat dengan as? 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.

Penukaran Bersyarat

Operator penukaran bersyarat as? cuba melakukan penurunan jenis dan mengembalikan nilai pilihan: nilai dibalut jika berjaya, atau nil jika gagal.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
let maybe = a as? Dog
print(maybe != nil)

Hasilnya ialah Nilai Pilihan

Oleh sebab penukaran itu mungkin gagal, jenis hasilnya ialah Dog?, bukannya Dog. Anda mesti menyahbungkusnya sebelum digunakan.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
let maybe: Dog? = a as? Dog
print(type(of: maybe))

Menyahbungkus dengan if let

Cara lazim menggunakan as? ialah dalam ikatan if let, yang hanya menjalankan kandungan apabila penukaran itu berjaya.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
if let dog = a as? Dog {
    print(dog.bark())
} else {
    print("Not a dog")
}

Penukaran Gagal Mengembalikan nil

Apabila tika itu bukan jenis sasaran, as? menghasilkan nil dan kandungan if let tidak dijalankan.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
if let dog = a as? Dog {
    print(dog.bark())
} else {
    print("That is not a dog")
}

Menggabungkan dengan guard let

Anda juga boleh menggunakan guard let untuk melakukan penukaran lebih awal dan keluar jika penukaran gagal, sambil mengekalkan laluan utama tanpa lekukan tambahan.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
func describe(_ a: Animal) {
    guard let cat = a as? Cat else {
        print("Not a cat")
        return
    }
    print(cat.meow())
}
describe(Cat(name: "Mia"))
describe(Dog(name: "Rex"))

Penukaran Bersyarat dalam Gelung

Mengulangi tatasusunan bercampur dan menukar jenis setiap elemen secara bersyarat ialah cara yang kemas untuk mengendalikan subkelas yang berbeza dengan selamat.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia"), Dog(name: "Buddy")]
for a in zoo {
    if let dog = a as? Dog {
        print(dog.bark())
    }
}

Menukar kepada Protokol

as? juga menguji pematuhan protokol: ia mengembalikan nilai jika tika tersebut mematuhi protokol, dan nil jika sebaliknya.

protocol Greeter { func greet() -> String }
class Person: Greeter { func greet() -> String { return "Hi" } }
class Rock {}
let items: [Any] = [Person(), Rock()]
for item in items {
    if let g = item as? Greeter { print(g.greet()) }
}

Penggunaan Nilai Sandaran Selepas Penukaran

Anda boleh menggandingkan as? dengan operator ?? untuk menyediakan nilai sandaran apabila penukaran gagal.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
let sound = (a as? Dog)?.bark() ?? "unknown sound"
print(sound)

Merantai Panggilan Penukaran Pilihan

Perantaian pilihan membolehkan anda memanggil kaedah pada hasil penukaran; keseluruhan ungkapan menjadi nil jika penukaran gagal.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
let bark = (a as? Dog)?.bark()
print(bark as Any)

Mengapa Penukaran Bersyarat Diutamakan

as? tidak pernah menyebabkan program ranap; penukaran yang gagal hanya menghasilkan nil. Oleh itu, ia ialah pilihan lalai yang selamat untuk penurunan jenis.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let unknown: Animal = Cat(name: "Mia")
let result = unknown as? Dog
print("Crashes? No. Value is nil:", result == nil)

Contoh Ringkasan Penukaran Bersyarat

Kesimpulannya: kenal pasti subjenis dengan selamat, lakukan tindakan terhadapnya, dan gunakan laluan sandaran dengan baik jika sebaliknya.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
func sound(of a: Animal) -> String {
    if let d = a as? Dog { return d.bark() }
    if let c = a as? Cat { return c.meow() }
    return "silence"
}
print(sound(of: Dog(name: "Rex")))
print(sound(of: Cat(name: "Mia")))

Semakan Pantas

Ingat jenis hasil penukaran bersyarat.

Jawab dalam pelajaran interaktif

Ulang Kaji: Penukaran Bersyarat dengan as?

Anda telah mempelajari bahawa as? melakukan penurunan jenis yang selamat dan mengembalikan nilai pilihan, bahawa if let serta guard let menyahbungkus kes yang berjaya, dan bahawa ia tidak pernah menyebabkan program ranap kerana kegagalan hanya menghasilkan nil. Oleh itu, ia ialah operator penurunan jenis yang diutamakan.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let pets: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for p in pets {
    if let d = p as? Dog { print(d.bark()) } else if let c = p as? Cat { print(c.meow()) }
}

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 “Penaipan Bersyarat dengan as?” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Swift Academy, termasuk “Penaipan Bersyarat dengan as?”, 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 “Penaipan Bersyarat dengan as?”?

Cuba lakukan penaipan yang mengembalikan pilihan apabila gagal. 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 “Penaipan Bersyarat dengan as?” 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