Question

我很惊讶我们在TypeScript Docs中没有看到很多关于施法的信息。尝试在TypeScript中创建一个简单的tryCast函数，类似于我们在.Net中的函数。所以基本上，尝试强制转换为指定的类型，如果失败则返回null / nothing。也许应该使用typescript generic ＆LT;＆＃39; T＆GT;语法，以及除了原始类型之外如何使它与对象一起工作？

function tryCast(obj: any, type: string) : any {
    if (typeof obj === type) {
        switch (type) {
            case 'number':
                return Number(obj);
            case 'string':
                return String(obj);
            case 'boolean':
                return Boolean(obj);
        }
    }

    return null;
}

function testCast() {
    var num: number = 123;  
    var str: string = tryCast(num, 'string');

    if (!str) {
        console.log('Cast failed');
    }
    else {
        console.log('Cast succeeded');
    }   
}

Answer 1

这是一个有趣的问题。我无法想象一个好的情况，这种情况经常发生，足以保证通用功能。大多数时候，我会根据具体情况处理。通常对基元使用typeof，对用户定义类型使用duck typing。然而，这是一个很好的练习，所以我会试一试。

您的代码正在执行typeof检查，但随后它会将变量冗余地传递给构造函数。如果typeof obj === 'number'那么你已经拥有了一个数字，则不需要＆＃34;施放＆＃34;。以下是 @mallison 给出的答案的修改版本。我还为此解决方案添加了一个类，但是接口并不像您希望的那样工作。

// Overloaded function
function tryCast(o: number, t: "number"): number;
function tryCast(o: string, t: "string"): string;
function tryCast(o: boolean, t: "boolean"): boolean;
function tryCast(o: IFace, t: "IFace"): IFace;
function tryCast(o: Function, t: "function"): Function;
function tryCast<T>(o: any, t: string): T;
function tryCast<T>(o: T, t: any): T {
     if (t === typeof o || (o['constructor'] && t === o['constructor']['name'])) {
        return o;
     } else  {
        return null;
     }
}

// Usage examples
var s1 = tryCast(70, 'string');
var s2 = tryCast('hello world', 'string');
var b1 = tryCast({b:true}, 'boolean');
var b2 = tryCast(true, 'boolean');
var n1 = tryCast('nan', 'number');
var n2 = tryCast(91, 'number');

var f1 = tryCast(123, 'function');
var f2 = tryCast(function foo() { return 1}, 'function');

class Classy { public sanDeigo = true; }
var c1 = tryCast<Classy>({soFly:false}, 'Classy');
var c2 = tryCast<Classy>(new Classy(), 'Classy');

interface IFace { eyes: number; hasMouth: boolean; }
var i1 = tryCast<IFace>({ eyes: 2, fake: true }, 'IFace');
var i2 = tryCast<IFace>({ eyes: 2, hasMouth: true }, 'IFace');

// Runtime tests
document.write(`
    s1:${s1},   // expect null<br/>
    s2:${s2},   // expect string<br/>
    b1:${b1},   // expect null<br/>
    b2:${b2},   // expect boolean<br/>
    n1:${n1},   // expect null<br/>
    n2:${n2},   // expect number<br/>
    f1:${f1},   // expect null<br/>
    f2:${f2},   // expect function<br/>
    c1:${c1},   // expect null<br/>
    c2:${c2},   // expect Classy<br/>
    i1:${i1},   // expect null<br/>
    i2:${i2},   // expect IFace...but its not!<br/>
`);

// Compiler tests
s1.toUpperCase();
s2.toUpperCase();

b1.valueOf();
b2.valueOf();

n1.toFixed(2);
n2.toFixed(2);

f1.apply(this);
f2.apply(this);

c1.sanDeigo;
c2.sanDeigo;

i1.eyes;
i2.eyes;

如果编译并运行the code，您将看到以下输出：

s1:null, // expect null
s2:hello world, // expect string
b1:null, // expect null
b2:true, // expect boolean
n1:null, // expect null
n2:91, // expect number
f1:null,    // expect null
f2:function foo() { return 1; },    // expect function
c1:null,    // expect null
c2:[object Object], // expect Classy
i1:null,    // expect null
i2:null,    // expect IFace...but its not!

那是怎么回事？没有通用的方法来构建接口，因为它是一个编译时实体。运行时不了解接口。该类是有效的，因为我们知道TypeScript将如何编译代码，但如果构造函数名称与类名称不同，这可能在将来不起作用（您可能希望在生产中使用它之前检查ES6规范）。

同样，在运行时检查接口类型的唯一方法是使用前面提到的duck typing。我将给你留下我认为正确的解决方案，你将无法在编译时知道类型。

$.getJSON('data.json', function(data: IFace) {
    if (data && data.eyes > 0 && data.hasMouth) {
        // this looks like an IFace to me!
    } else {
        // data is no good!
    }
});

Answer 2

这是你要找的吗？

interface IFoo { bar: any; }

function tryCast(obj: number, type: "number"): number;
function tryCast(obj: string, type: "string"): string;
function tryCast(obj: boolean, type: "boolean"): boolean;
function tryCast(obj: IFoo, type: "IFoo"): IFoo;
function tryCast(obj: any, type: string): any;
function tryCast(obj: any, type: string): any {

    // Do fancy stuff to cast things
}

// IFoo
tryCast({ bar: 'hi' }, 'IFoo');

// any (NULL)
tryCast({}, 'string');

// boolean
tryCast( !!1 , 'boolean');

// any (NULL)
tryCast(123, 'boolean');

// number
tryCast(123, 'number');

// string
tryCast( 123 + '', 'string');

如何在TypeScript中创建TryCast（.Net等效）

2 个答案: