Question

我正在寻找一种转换函数或方法，可以让我保留打字稿在结果对象上推断类型（获取类型检查和代码提示）的能力。在下面的示例中，C（和相关的E）是证明存在问题的场景。

class Wrapper<T> {
    constructor(private val: T) { }

    value(): T {
        return this.val;
    }
}

// A 
var wrappedNum = new Wrapper(1);
// Typescript infers value() and that it returns a number
wrappedNum.value().toFixed(1); 

// B
var wrappedNumArray = [1, 2, 3].map(function(val) { return new Wrapper(val); });
// Typescript infers that for each element in array, value() returns number
wrappedNumArray[0].value().toFixed(1); 

// C
// ** Typing of properties is lost in this transformation **
function wrapObject(obj) {
    var targ = {};

    for(var key in obj) {
        targ[key] = new Wrapper(obj[key]);
    }

    return targ;
}

var wrappedObj = wrapObject({a: 1});
// Typescript does not infer the existence of `a` on wrappedObj
wrappedObj.a; 

// D
// Typescript infers `a` and its type
({ a: 1 }).a.toFixed(1); 

// E
// ** Typing of properties is lost in this transformation **
function noop(obj) {
    return obj;
}

// Typescript does not infer the existence of `a` on noop transformed object
noop({ a: 1 }).a; 

// F
function getValue() {
    return { a: 1 };
}

// Typescript infers the existence of `a` and its type
getValue().a.toFixed(1);

C＆amp;有没有办法E的结构可以使类型推断在对传递的对象结构不可知时起作用吗？

Answer 1

<强> C

对于C，我想不出办法做到这一点。妥协是使用dictionary-like type，然后用泛型将其映射出来。

例如：

debugger;

<强>电子

使用泛型：

function wrapObject<T>(obj: T) {
    var targ: { [key: string]: Wrapper<T>; } = {};

    for(var key in obj) {
        targ[key] = new Wrapper<T>(obj[key]);
    }

    return targ;
}

var wrappedObj = wrapObject({a: 1});
wrappedObj["a"].value; // ok

在Handbook中了解有关泛型的更多信息。

转换对象属性，以便在typescript中保留隐式类型

1 个答案: