Question

我正在寻找一种根据对象类型分叉逻辑的安全方法。我还没找到如何检查对象是否属于特定的泛型类型。

class Test {
    static function main() {
        var aa = new AA<Int>();
        //ERROR: Cast type parameters must be Dynamic
        //var a:A<Int> = cast(aa, A<Int>); 

        //ERROR: Unexpected )
        //var a:A<Int> = Std.instance(aa, A<Int>);

        //OK, but throw run-time exception with flash target. 
        var a:A<Int> = cast aa; 
        a.printName();

        //Run-time exception
        a = cast "String is obviously wrong type";
    }
}

class A<T> {
    public function new () { }
    public function printName() {
        trace("Generic name: A");
    }
}

class AA<T> extends A<T> {
    public function new () { super(); }
    override public function printName() {
        trace("Generic name AA");
    }
}

是否有合法的方法来检查对象是否属于泛型类型？

Answer 1

通常没有很好的方法可以做到这一点，因为信息在运行时不再可用。您可以使用often suggested for Java相同的解决方法，即在您的类中存储泛型类型：

class Main {
    static function main() {
        var a = new A<Int>(Int);

        trace(a.typeParamIs(Int)); // true
        trace(a.typeParamIs(Bool)); // false
    }
}

class A<T> {
    var type:Any;

    public function new (type:Any) {
        this.type = type;
    }

    public function typeParamIs(type:Any):Bool {
        return this.type == type;
    }
}

或者，如果A的字段类型为T，则可以使用此Type.typeOf()：

class Main {
    static function main() {
        checkType(new A<Int>(5)); // Int
        checkType(new A<Bool>(true)); // Bool
        checkType(new A<B>(new B())); // B
        checkType(new A<B>(null)); // unhandled type TNull
    }

    static function checkType<T>(a:A<T>) {
        trace(switch (Type.typeof(a.value)) {
            case TInt: "Int";
            case TBool: "Bool";
            case TClass(cls) if (cls == B): "B";
            case other: throw "unhandled type " + other;
        });
    }
}

class A<T> {
    public var value:T;
    public function new (value:T) {
        this.value = value;
    }
}

class B {
    public function new() {}
}

正如您所看到的，虽然这通常有效，但在某些情况下可能会导致意外行为 - 例如value为null时。另请注意Type.typeOf()的文档：

每个平台可能会有所不同。应尽量减少对此的假设，以避免意外。

进一步阅读：mailing list thread这已经讨论了一段时间。这里提到了一个宏解决方案，如果你不需要在运行时知道类型。

如何在Haxe中检查该对象是泛型的实例

1 个答案: