ค้นหาอาร์เรย์สำหรับวัตถุประเภทที่ให้ไว้

นี่คือตัวอย่างง่ายๆ สังเกตว่าฉันส่งคืน Animal เผื่อเลือก เนื่องจากการค้นหาอาจล้มเหลว (คอมไพเลอร์ไม่รู้ว่าคุณจะมีสัตว์ประเภทนั้นเพียงตัวเดียวเสมอ):

class Animal {
    let name: String

    init(name: String) {
        self.name = name
    }
}

class Cat: Animal {
    init() {
        super.init(name: "Cat")
    }
}

class Dog: Animal {
    init() {
        super.init(name: "Dog")
    }
}

struct Zoo {
    static var animals: [Animal] = []

    static func getAnimal<T: Animal>(animalType: T.Type) -> Animal? {
        for animal in animals {
            if animal is T {
                return animal
            }
        }
        return nil
    }
}

Zoo.animals.append(Cat())

Zoo.getAnimal(Cat) // Returns the cat as optional
Zoo.getAnimal(Dog)

พูดง่ายๆ ก็คือ T เป็นประเภททั่วไปของคุณ T.Type ระบุว่าคุณกำลังส่งประเภท T เป็นพารามิเตอร์

คุณสามารถใช้ตัวดำเนินการเอกลักษณ์ === เพื่อตรวจสอบว่าประเภทขององค์ประกอบอาร์เรย์เท่ากับประเภททั่วไปหรือไม่:

if animal.dynamicType === animalType {
    return animal
}

คุณไม่สามารถใช้ไวยากรณ์ is หรือ as กับประเภทที่ไม่รู้จัก การเรียงลำดับประเภทการสะท้อนที่คุณกำลังมองหาสามารถทำได้โดยใช้วิธี kindOfClass ของ NSObject ตราบใดที่ Animal เป็นคลาสย่อยของ NSObject:

class Animal: NSObject {

    class func getAnimalOfType<T: Animal>(animals: [Animal], animalType: T.Type) -> Animal? {
        for animal in animals {
            if animal.isKindOfClass(animalType) {
                return animal
            }
        }
        return nil
    }

}

class Zebra: Animal { }
class Whale: Animal { }
var animals = [Zebra(), Whale()]
Animal.getAnimalOfType(animals, animalType: Zebra.self)

หาก Animal ไม่ใช่ประเภทย่อยของ NSObject คุณสามารถทำได้เสมอ--แต่ดูเหมือนว่าจะแฮ็กเล็กน้อยสำหรับฉัน:

 if "\(animal.dynamicType)" == "\(animalType)" {
      return animal
 }

struct Test<T: Hashable> {

    static func test(t: Any) {
        println(t is T)
    }
}

Test<Int>.test(3)

ในตัวอย่างนี้ ฉันกำลังส่งประเภท (Int ในกรณีของฉัน AnimalType ในตัวคุณ) ไปยังโครงสร้างและตัวแปร (Int ของฉัน (3) สัตว์ของคุณ) เป็นพารามิเตอร์ของการทดสอบฟังก์ชันคงที่ ฉันใช้ T: Hashable คุณจะต้องทดสอบกับ T: Animal