I encountered a problem that I simplified by creating the function below :
function setProperty<T extends Record<string, string>>(obj: T, key: keyof T) {
obj[key] = "hello";
}
The code does not compile, obj[key] is underlined in red and I get the error :
Type 'string' is not assignable to type 'T[keyof T]'.ts(2322)
I understand that it is because of the keyword "extends" but I don't know how to solve my problem.
Can you help me with this ?
There are two ways to solve your problem depending on your usecase. If you just want to set any string as a value to any particular key, you don't need to use generics:
function setProperty(obj: Record<string, string>, key: string) {
obj[key] = "hello";
}
However if your object has specific keys and specific values you can use generics like this so the compiler type checks your arguments:
function setProperty<T extends Record<string, string>, K extends keyof T, V extends T[K]>(obj: T, key: K, value: V) {
obj[key] = value
}
type ObjectValue = 'foo' | 'bar'
type A = {
foo: ObjectValue,
baz: 'baz'
}
const a: A = {
foo: 'foo',
baz: 'baz'
}
setProperty(a, 'foo', 'bar') // works
setProperty(a, 'foo', 'baz') // type error
This also has a nice benefit of InteliSense sugsestions.
EDIT:
Since OP wanted just to type check the key and set an arbitrary string, this solution should be better:
function setProperty<K extends string>(obj: Record<K, string>, key: K) {
obj[key] = "hello";
}
obj of type Record<string, string>. If it doesn't work please specify me the type of obj argument that is being passed to the function.function setProperty<K extends string>(obj: Record<K, string>, key: K) { obj[key] = "hello"; }Just use Object.assign
type StringValue<Obj> = {
[Prop in keyof Obj]: Obj[Prop] extends string ? Prop : never
}[keyof Obj]
/**
* Obtain all keys with string value
* Only these keys are allowed
*/
type Result = StringValue<{ age: number, name: string }> // name
function setProperty<
Value,
Obj extends Record<string, Value>
>(obj: Obj, key: StringValue<Obj>) {
Object.assign(obj, { [key]: 'hello' })
}
const user = {
age: 42,
name: 'John',
surname: 'Doe'
}
setProperty(user, 'name') // ok
setProperty(user, 'surname') // ok ok
setProperty(user, 'age') // expected error, because age is a number
With help of StringValue utility type, TS will allow only keys with string value.
Please try to aboid mutations in TS. See this article.
I'm not sure if this will achieve the result you're looking for with your use case, but if you simply want this to compile, you can use a type assertion.
function setProperty<T extends Record<string, string>>(obj: T, key: keyof T) {
obj[key] = "hello" as T[keyof T];
}
"hello" has literal type hello. The Typescript compiler can see that you want to set a value on obj, which has keys with type keyof T. It can't infer that type hello is of the required type unless you assert it is as above.
However if you want to set the value on obj[key] to hello, I'd personally use the first approach from Michael Vrana's answer.
const str: string = "hello". Actually obj[key] is not of type string but of a type that extends string and that's why that problem happens I guess.