Swift Academy · Pelajaran

Casting Kondisional dengan as?

Coba lakukan casting yang mengembalikan nilai opsional jika gagal.

Casting Kondisional dengan as? adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 2 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.

Pengecoran Kondisional

Operator pengecoran kondisional as? mencoba melakukan penurunan tipe dan mengembalikan nilai opsional: nilai yang dibungkus jika berhasil, 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 Bersifat Opsional

Karena pengecoran dapat gagal, tipe hasilnya adalah Dog?, bukan Dog. Anda harus membuka bungkusnya sebelum menggunakannya.

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))

Membuka Bungkus dengan if let

Cara yang umum digunakan untuk memakai as? adalah di dalam pengikatan if let, yang menjalankan isi blok hanya ketika pengecoran berhasil.

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")
}

Pengecoran yang Gagal Menghasilkan nil

Ketika instans bukan tipe tujuan, as? menghasilkan nil dan isi blok if let dilewati.

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 dapat menggunakan guard let untuk melakukan pengecoran lebih awal dan keluar jika pengecoran gagal, sehingga alur normal tetap tidak menjorok.

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"))

Pengecoran Kondisional dalam Perulangan

Mengiterasi larik campuran dan melakukan pengecoran kondisional pada setiap elemennya adalah cara yang rapi untuk menangani berbagai subkelas dengan aman.

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())
    }
}

Melakukan Pengecoran ke Protokol

as? juga memeriksa kepatuhan terhadap protokol: operator ini mengembalikan nilai jika instans mematuhi protokol tersebut, dan nil jika tidak.

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()) }
}

Nilai Pengganti Setelah Pengecoran

Anda dapat memasangkan as? dengan operator ?? untuk menyediakan nilai pengganti ketika pengecoran 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)

Merangkai Pemanggilan Pengecoran Opsional

Perantaian opsional memungkinkan Anda memanggil metode pada hasil pengecoran; seluruh ekspresi menjadi nil jika pengecoran 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 Pengecoran Kondisional Lebih Diutamakan

as? tidak pernah menyebabkan program mogok; pengecoran yang gagal hanya menghasilkan nil. Karena itu, operator ini merupakan pilihan bawaan yang aman untuk penurunan tipe.

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 Pengecoran Kondisional

Jika digabungkan: deteksi subtipe dengan aman, lakukan tindakan terhadapnya, dan sediakan penanganan pengganti dengan baik jika tidak ditemukan.

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")))

Pemeriksaan Singkat

Ingat kembali tipe hasil pengecoran kondisional.

Ringkasan: Pengecoran Kondisional dengan as?

Anda telah mempelajari bahwa as? melakukan penurunan tipe yang aman dan mengembalikan nilai opsional, bahwa if let dan guard let membuka bungkus kasus yang berhasil, serta bahwa operator ini tidak pernah menyebabkan program mogok karena kegagalan hanya menghasilkan nil, sehingga menjadi operator penurunan tipe yang lebih disarankan.

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()) }
}

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Casting Kondisional dengan as?” gratis?

Ya — teks lengkap “Casting Kondisional dengan as?” 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 “Casting Kondisional dengan as?”?

Coba lakukan casting yang mengembalikan nilai opsional jika gagal. 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 2 dari 4.

Berapa lama pelajaran “Casting Kondisional dengan as?” 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