0Pricing
Swift Academy · บทเรียน

การตรวจสอบชนิดด้วย is

ตรวจสอบชนิดของอินสแตนซ์ก่อนแปลงชนิด

การตรวจสอบชนิดด้วย is เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

ตัวดำเนินการ is

ตัวดำเนินการ ตรวจสอบชนิด is จะคืนค่า Bool เพื่อบอกว่าอินสแตนซ์เป็นชนิดที่กำหนดหรือชนิดย่อยของมันหรือไม่ ตัวดำเนินการนี้ไม่ได้แคสต์ แต่ทำหน้าที่ตรวจสอบเท่านั้น

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")
print(a is Dog)
print(a is Cat)

การตรวจสอบการเป็นสมาชิกของชนิดย่อย

is จะเป็นจริงเมื่ออินสแตนซ์เป็นชนิดนั้นโดยตรง หรือเป็นคลาสย่อยใด ๆ ของชนิดนั้น Dog จึงเป็น Animal

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")
print(a is Animal)
print(a is Dog)

การใช้ is ในเงื่อนไข

คุณสามารถใช้ if ตรวจสอบชนิดและเลือกการทำงานตามชนิดจริงขณะทำงานได้

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 a is Cat {
    print("It is a cat")
} else {
    print("Not a cat")
}

การนับชนิดในคอลเลกชัน

การใช้ 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 zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia"), Dog(name: "Buddy")]
let dogCount = zoo.filter { $0 is Dog }.count
print("Dogs:", dogCount)

การใช้ is กับโพรโทคอล

is ยังใช้ตรวจสอบได้ว่าอินสแตนซ์สอดคล้องกับโพรโทคอลหรือไม่ โดยคืนค่า true เมื่อสอดคล้อง

protocol Flyer {}
class Bird: Flyer {}
class Fish {}
let creatures: [Any] = [Bird(), Fish()]
for c in creatures { print(c is Flyer) }

is เทียบกับ as?

is ตอบได้เพียงว่าใช่หรือไม่ใช่ ส่วน as? ทำได้มากกว่านั้น โดยคืนค่าให้คุณเมื่อจำเป็นต้องใช้สมาชิกของคลาสย่อย

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")
print("Check only:", a is Dog)
if let d = a as? Dog { print("Use it:", d.bark()) }

การป้องกันด้วย is

ใช้ is ใน guard เพื่อออกจากการทำงานตั้งแต่ต้นเมื่ออินสแตนซ์ไม่ใช่ชนิดที่คาดไว้

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 onlyForCats(_ a: Animal) {
    guard a is Cat else {
        print("Skipping non-cat")
        return
    }
    print("Processing a cat")
}
onlyForCats(Cat(name: "Mia"))
onlyForCats(Dog(name: "Rex"))

การรวม is ใน switch

คุณสามารถตรวจสอบชนิดใน switch ทางอ้อมได้ แต่การจับคู่รูปแบบด้วย case 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 items: [Any] = [Dog(name: "Rex"), 42, "hello"]
for item in items {
    switch item {
    case is Dog: print("a dog")
    case is Int: print("an integer")
    default: print("something else")
    }
}

is ตรวจสอบชนิดขณะทำงาน

is ตรวจสอบชนิดจริงขณะทำงาน ไม่ใช่ชนิดที่ประกาศให้ตัวแปร ตัวแปรที่ระบุชนิดเป็น Animal แต่เก็บ Dog ไว้ จะผ่านการตรวจสอบด้วย is Dog

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 declaredAsAnimal: Animal = Dog(name: "Rex")
print("Runtime is Dog:", declaredAsAnimal is Dog)

การตรวจสอบก่อนแปลงชนิดแบบบังคับ

รูปแบบที่ปลอดภัยคือใช้ is ตรวจสอบก่อน แล้วจึงใช้ as! เพราะคุณได้ยืนยันชนิดแล้ว

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 d = a as! Dog
    print(d.bark())
}

ตัวอย่างสรุปการตรวจสอบชนิด

เมื่อใช้ is เพื่อตรวจสอบและ as? เพื่อแปลงชนิดร่วมกัน คุณจะมีเครื่องมือที่ครบถ้วนและปลอดภัยสำหรับชนิดขณะทำงาน

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")]
for a in zoo {
    if a is Dog { print("dog:", a.name) }
    if a is Cat { print("cat:", a.name) }
}

ตรวจสอบอย่างรวดเร็ว

ทบทวนว่าโอเปอเรเตอร์ is คืนค่าอะไร

ทบทวน: การตรวจสอบชนิดด้วย is

คุณได้เรียนรู้ว่า is คืนค่า Bool เพื่อบอกการเป็นสมาชิกของชนิดขณะทำงาน ซึ่งรวมถึงคลาสย่อยและการสอดคล้องกับโพรโทคอล ว่าสามารถใช้ร่วมกับการกรองและ switch case is ได้ดี และการตรวจสอบด้วย is ก่อนใช้ as! ทำให้การแปลงชนิดแบบบังคับปลอดภัย

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")]
print("Cats:", zoo.filter { $0 is Cat }.count)
print("Dogs:", zoo.filter { $0 is Dog }.count)

คำถามที่พบบ่อย

บทเรียน “การตรวจสอบชนิดด้วย is” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การตรวจสอบชนิดด้วย is” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การตรวจสอบชนิดด้วย is”

ตรวจสอบชนิดของอินสแตนซ์ก่อนแปลงชนิด คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Swift Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การตรวจสอบชนิดด้วย is” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม

ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. พื้นฐานการแปลงชนิดขึ้นและลง
  2. การแปลงชนิดแบบมีเงื่อนไขด้วย as?
  3. การแปลงชนิดแบบบังคับด้วย as! และความเสี่ยง
  4. การตรวจสอบชนิดด้วย is
← กลับไปที่ Swift Academy