PricingLoginStart free
Swift Academy · Pelajaran

Casting Paksa dengan as! dan Risikonya

Gunakan as! hanya jika casting dijamin berhasil.

Pelajaran 3 dari 413 langkah

Casting Paksa dengan as! dan Risikonya adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 3 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 Paksa

Operator pengecoran paksa as! melakukan penurunan tipe dan membuka bungkusnya dalam satu langkah. Operator ini langsung memberikan tipe nonopsional, tetapi menyebabkan program mogok 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 dog = a as! Dog
print(dog.bark())

Tanpa Pembungkusan Opsional

Berbeda dari as?, hasil as! adalah tipe biasa, bukan nilai opsional. Tidak ada yang perlu dibuka bungkusnya.

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 dog: Dog = a as! Dog
print(type(of: dog))

Risiko as!

Jika instans sebenarnya bukan tipe tujuan, as! memicu penghentian saat program berjalan dan menghentikan program. Tidak ada pemulihan.

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 cat = a as! Cat  // would crash at runtime
print("Only force-cast when certain")

Kapan Pengecoran Paksa Aman

Gunakan as! hanya ketika Anda benar-benar yakin akan tipenya, misalnya tepat setelah memeriksanya dengan is.

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 a is Dog {
    let dog = a as! Dog
    print(dog.bark())
}

Pengecoran Paksa Setelah Jaminan Tipe

Jika logika kode Anda menjamin tipenya, pengecoran paksa mendokumentasikan kepastian tersebut. Namun, tetap utamakan as? jika Anda tidak yakin.

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 barkIfDog(_ a: Animal) {
    guard a is Dog else { return }
    let dog = a as! Dog
    print(dog.bark())
}
barkIfDog(Dog(name: "Rex"))

Membandingkan as? dan as!

as? aman dan mengembalikan nilai opsional; as! bersifat memaksa dan menyebabkan program mogok jika gagal. Pilih berdasarkan tingkat kepastian Anda.

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 safe = a as? Dog
let forced = a as! Dog
print(safe?.bark() ?? "nil")
print(forced.bark())

Pengecoran Paksa pada Koleksi

Pengecoran paksa juga dapat dilakukan pada seluruh koleksi, seperti array as! [Dog], tetapi risiko program mogok yang sama berlaku untuk setiap elemen.

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 animals: [Animal] = [Dog(name: "Rex"), Dog(name: "Buddy")]
let dogs = animals as! [Dog]
for d in dogs { print(d.bark()) }

Pola yang Berbahaya

Melakukan pengecoran paksa pada larik yang berisi elemen yang salah akan menyebabkan program mogok. Karena itu, koleksi campuran sebaiknya menggunakan as? untuk setiap elemen.

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 animals: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
// let dogs = animals as! [Dog] // would crash on the Cat
for a in animals {
    if let d = a as? Dog { print(d.bark()) }
}

Membuka Bungkus Paksa vs Pengecoran Paksa

Tanda ! dalam as! secara konsep mirip dengan membuka bungkus nilai opsional secara paksa: praktis, tetapi berbahaya jika asumsinya salah.

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 viaOptional = (a as? Dog)!
let viaForce = a as! Dog
print(viaOptional.name, viaForce.name)

Praktik Terbaik

Jadikan as? sebagai pilihan bawaan. Simpan as! untuk kasus ketika kegagalan menunjukkan kesalahan pemrogram yang ingin segera Anda ketahui selama pengembangan.

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 process(_ a: Animal) -> String {
    if let d = a as? Dog { return d.bark() }
    return "not a dog"
}
print(process(Dog(name: "Rex")))
print(process(Cat(name: "Mia")))

Contoh Ringkasan Pengecoran Paksa

Ketika tipe sudah diverifikasi, as! terlihat rapi. Jika ragu, pengecoran kondisional yang aman adalah alat yang tepat.

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 known: Animal = Dog(name: "Rex")
if known is Dog {
    print((known as! Dog).bark())
}

Pemeriksaan Singkat

Pahami bahaya pengecoran paksa.

Jawab di pelajaran interaktif

Ringkasan: Pengecoran Paksa dan Risikonya

Anda telah mempelajari bahwa as! melakukan penurunan tipe dan membuka bungkusnya menjadi tipe nonopsional, tetapi menyebabkan program mogok saat gagal; operator ini hanya boleh digunakan ketika tipenya sudah pasti, sering kali setelah pemeriksaan is, dan as? tetap merupakan pilihan bawaan yang lebih 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 a: Animal = Dog(name: "Rex")
if a is Dog { print((a as! Dog).bark()) } else { print("safe skip") }
Gratis untuk memulai

Belajar Swift dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
122
Pelajaran
409
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Casting Paksa dengan as! dan Risikonya” gratis?

Ya — teks lengkap “Casting Paksa dengan as! dan Risikonya” 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 Paksa dengan as! dan Risikonya”?

Gunakan as! hanya jika casting dijamin berhasil. 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 3 dari 4.

Berapa lama pelajaran “Casting Paksa dengan as! dan Risikonya” 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

  1. Dasar-Dasar Upcasting dan Downcasting
  2. Casting Kondisional dengan as?
  3. Casting Paksa dengan as! dan Risikonya
  4. Memeriksa Tipe dengan is
← Kembali ke Swift Academy