令人惊讶的是，即使Swift类不是NSObject的子类，Swift中的所有类似乎都是从SwiftObject派生的。SwiftObject本身没有超类。
首先，处理ObjC运行时函数的 Package 器结构：

import Foundation
struct ClassInfo : CustomStringConvertible, Equatable {
    let classObject: AnyClass
    let className: String
    init?(_ classObject: AnyClass?) {
        guard classObject != nil else { return nil }
        self.classObject = classObject!
        let cName = class_getName(classObject)!
        self.className = String(cString: cName)
    }
    var superclassInfo: ClassInfo? {
        let superclassObject: AnyClass? = class_getSuperclass(self.classObject)
        return ClassInfo(superclassObject)
    }
    var description: String {
        return self.className
    }
    static func ==(lhs: ClassInfo, rhs: ClassInfo) -> Bool {
        return lhs.className == rhs.className
    }
}

字符串
以下是您可以如何使用它：

class Mother { }
class ChildFoo: Mother { }
class ChildBar: Mother { }
class AnIrrelevantClass { }
let motherClassInfo = ClassInfo(Mother.self)!
var subclassList = [ClassInfo]()
var count = UInt32(0)
let classList = objc_copyClassList(&count)!
for i in 0..<Int(count) {
    if let classInfo = ClassInfo(classList[i]),
        let superclassInfo = classInfo.superclassInfo,
        superclassInfo == motherClassInfo
    {
        subclassList.append(classInfo)
    }
}
print(subclassList)

型
这只执行一个浅层搜索，所以它不会清理孙子类，但你明白的想法。

Jean Le Moignan代码的优化版本

static func subclasses<T>(of theClass: T) -> [T] {
        var count: UInt32 = 0, result: [T] = []
        let allClasses = objc_copyClassList(&count)!
        let classPtr = address(of: theClass)
        for n in 0 ..< count {
            let someClass: AnyClass = allClasses[Int(n)]
            guard let someSuperClass = class_getSuperclass(someClass), address(of: someSuperClass) == classPtr else { continue }
            result.append(someClass as! T)
        }
        return result
    }

个字符
对于每个Type，在运行时只有一个元类示例，因此，它们上的指针是唯一的。出于某种原因，操作符===不允许用于AnyClass，但我们可以直接比较指针
性能测试：

let start = CFAbsoluteTimeGetCurrent()
        let found = RuntimeUtils.subclasses(of:UIViewController.self)
        let diff = CFAbsoluteTimeGetCurrent() - start
        print("Took \(diff) seconds, \(found.count) found")

型
产出：
字符串（描述：theClass）：Took 1.0465459823608398 seconds, 174 found
地址（of：theClass）：Took 0.2642860412597656 seconds, 174 found

以下是基于Code Different之前的答案的变体，但更短：

func subclasses<T>(of theClass: T) -> [T] {
    var count: UInt32 = 0, result: [T] = []
    let allClasses = objc_copyClassList(&count)!
    for n in 0 ..< count {
        let someClass: AnyClass = allClasses[Int(n)]
        guard let someSuperClass = class_getSuperclass(someClass), String(describing: someSuperClass) == String(describing: theClass) else { continue }
        result.append(someClass as! T)
    }
    return result
}

字符串
返回类型将根据接收变量的类型，这要归功于泛型。
我想把它作为AnyClass的一个扩展来写，但不幸的是Swift不允许。

objc_copyClassList返回的结果不再是可验证的。这是有效的：

public func subclasses<T>(of theClass: T) -> [T] {
    var count: UInt32 = 0, result: [T] = []
    let classList = objc_copyClassList(&count)!
    defer { free(UnsafeMutableRawPointer(classList)) }
    let classes = UnsafeBufferPointer(start: classList, count: Int(count))
    let classPtr = address(of: theClass)
    for someClass in classes {
        guard let someSuperClass = class_getSuperclass(someClass), address(of: someSuperClass) == classPtr else { continue }
        result.append(someClass as! T)
    }
    return result
}
public func address(of object: Any?) -> UnsafeMutableRawPointer {
    return Unmanaged.passUnretained(object as AnyObject).toOpaque()
}

字符串