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

Question

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

Class ModelProperty<T> when constructed with new ModelProperty<Car>('engine',22); should work as engine is a property of Car and 22 as same type as engine ie 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'

1. In case of engine V should mean number . But that line in function do gives error.
2. Constructor should not be <Car,'engine'> but only <Car> . Its following properties should be by default depending upon the argument.
3. How to make it work for nested property like new ModelProperty<Car>(['details','good'],'Girl') .

Answer 1

For the first issue, the problem with your approach for the V parameter is that you specify the default for it, but that does not mean V MUST extend T[P] , just that that is the default, you can invoke the constructor with really any type parameter for V . Just use T[P] where appropriate, as even if you constrain it properly ( V extends T[P] = T[P] ) the compiler it will still not be able to correctly follow that V is assignable from 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]
    }
}

As for your second issue of repetition, this is an unfortunate side effect of the way type parameters and inference work, if you specify a default for the generic parameter, that default will be used and no inference will take place. If you don't specify the default for K , you can't specify just the value for T , you must also specify K . The simple workaround is to use a two function approach :

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'

As for the third issue of nested paths, classes can't have a variable number of type parameters, so you have the option of creating dedicated classes for each path length.

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

Or if you want you can create a single overloaded function that returns an instance ModelProperty where the only type parameter is the value of the last property, and the path is string[]. You get type safety when you create the instance but the info is lost after

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