Question

class Car {
    engine:number;
    detials:{
        good:'Boy'
    }
}

使用ModelProperty<T>构建时，

类new ModelProperty<Car>('engine',22);应该engine的属性是Car和22的属性，与engine的类型相同，即number。

export class ModelProperty<T, P extends keyof T, V  = T[P]> {
    constructor(public name: P, public value: V) { }
    fun(t: T){
        let value: any = t[this.name]; // Should not be any
        let valueWhyError: V = t[this.name]; //Error.. Why?
    }
}
let engine2 = new ModelProperty<Car,'engine'>('engine','22'); // Gives error as '22' should be number.. working great.
let engine1 = new ModelProperty<Car,'engine'>('engine',2); // But there is repeatation 'engine', 'engine'

如果engine V应该是number。但是函数do中的那一行给出了错误。
构造函数不应为<Car,'engine'>，而应为<Car>。默认情况下，它的以下属性取决于参数。
如何使其适用于new ModelProperty<Car>(['details','good'],'Girl')等嵌套属性。

Answer 1

对于第一个问题，您对V参数的方法存在的问题是您为其指定了默认值，但这并不意味着V必须扩展T[P]，只是这是默认值，您可以使用V的任何类型参数调用构造函数。只需在适当的地方使用T[P]，即使您正确约束（V extends T[P] = T[P]）编译器，它仍然无法正确遵循V可从T[P]分配的内容。

export class ModelProperty<T, P extends keyof T> {
    constructor(public name: P, public value: T[P]) { }
    fun(t: T){
        let value = t[this.name]; // is T[P]
    }
}

至于你的第二个重复问题，这是类型参数和推理工作方式的一个不幸的副作用，如果你指定泛型参数的默认值，那么将使用默认值并且不会进行推理。如果您未指定K的默认值，则无法仅指定T的值，还必须指定K。简单的解决方法是使用两种函数方法：

export class ModelProperty<T, P extends keyof T> {
    constructor(public name: P, public value: T[P]) { }

    static for<T>() {
        return function <P extends keyof T>(name: P, value: T[P]){
            new ModelProperty<T, P>(name, value);
        } 
    }
}
const carModelCreator = ModelProperty.for<Car>();
let engine2 = carModelCreator('engine','22'); // Gives error as '22' should be number.. working great.
let engine1 = carModelCreator('engine',2); // But there is repeatation 'engine', 'engine'

对于第三期嵌套路径，类不能有可变数量的类型参数，因此您可以选择为每个路径长度创建专用类。

export class ModelProperty2<T, P extends keyof T,  P2 extends keyof T[P]> {
    constructor(public name: [P, P2], public value: T[P][P2]) { }

    static for<T>() {
        return function <P extends keyof T, P2 extends keyof T[P]>(name: [P, P2],  value: T[P][P2]){
            new ModelProperty2<T, P, P2>(name, value);
        } 
    }
}
const carModelCreator = ModelProperty2.for<Car>();
let engine2 = carModelCreator(['detials', 'good'],'22'); //error 
let engine2 = carModelCreator(['detials', 'good'],'Boy'); //ok

或者如果你想要，你可以创建一个返回实例ModelProperty的重载函数，其中唯一的类型参数是最后一个属性的值，路径是string []。您在创建实例时获得类型安全性，但在

之后信息丢失

export class ModelProperty<T, V> {
    constructor(public name: string[], public value: V) { }


    static for<T>() {
        function helper<P extends keyof T, P2 extends keyof T[P]>(name: [P, P2],  value: T[P][P2])
        function helper<P extends keyof T>(name: [P],  value: T[P])
        function helper(name: string[],  value: any){
            return new ModelProperty<T, any>(name, value);
        } 

        return helper;
    }
}
const carModelCreator = ModelProperty.for<Car>();
let engine1 = carModelCreator(['engine'], 22); // ok
let engine2 = carModelCreator(['detials', 'good'],'Boy'); //ok

泛型`keyof``中的打字稿混淆扩展了keyof``typeof`等

1 个答案: