打字稿中的打字稿松散打字

Question

When using destructuring assignment and variable as property name Typescript seems like loses types.

 interface O { [val: string]: string; } const o: O = { foo: '' }; const f = (name: string) => { const {[name]: value} = o; // now `value` has type any, how to make it type `string`? const value1 = o[name] || ''; // and `value1` has correct type `string` }; 

Answer 1

I don't think it's typescript a bug, there are some issues on this code

const {[name]: value} = o ;

what is this line, you are defining a const with no name, then using something like type and assigning o

Also what is value ?

Since I don't know what was your idea I can suggest these codes:

If you want to consider it as type

const x : {[name:string]:string} = o;

If you want to use it as value

const x = {[name] : 'my value'};

Answer 2

Edit:

After thinking it some more, its obvious that both cases should return the same result, and typescript probably doesn't considered the possible prototype of the object. so it should return string type.

And you must protect the two cases of missing entries and possible non string prototype access.

Original:

The value given to the destructuring is a string , and can be any string , including things like __proto__ or constructor that will result in a non string type.

If you know the optional keys that you might have, then this will work:

const f = (name: keyof typeof o) => {
    const {[name]: value} = o;
    // now `value` has type string
};

I think the bug is in the latter example without destructuring. By passing certain strings you might get a non string value.