Challenge 1: Type math
- TypeScript course
- Advanced
- Lesson 54/57
- 6 min
Solve a task combining template literal and mapped.
Type math: template + mapped
Template literal types combine pieces into a string; mapped types regenerate an object's keys. Combine them to derive names like getX for every property.
type Getters<T> = {
[K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
type Person = { name: string; age: number };
// { getName: () => string; getAge: () => number }The as clause renames the key; Capitalize upper-cases the first letter.
Practice Produce a getter type
Write a Getters<T> type: for each property K produce a get${Capitalize<K>} key whose value is () => T[K]. Define Person as { name: string; age: number }, create a PersonGetters alias, build a value, and print the result of getName().
Starter code
// Getters<T>: her özellik için getX() üretir
// Person: name: string, age: number
// PersonGetters = Getters<Person>
// bir değer oluştur ve getName() çağırıp yazdırSample solution
type Getters<T> = {
[K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
type Person = { name: string; age: number };
type PersonGetters = Getters<Person>;
const g: PersonGetters = {
getName: () => "Ada",
getAge: () => 36,
};
console.log(g.getName());Expected output
Ada
Practice Produce a prefixed type
Write a Prefixed<T, P> type: prefix every key with P (`${P}${K}`). Define Box as Prefixed<{ id: number }, "$">, create a Box value, and print its $id field.
Starter code
// Prefixed<T, P>: her anahtarı P önekiyle birleştirir
// { x: number } ve "$" için { $x: number }
// Box türünü Prefixed<{ id: number }, "$"> ile tanımla
// bir değer oluştur ve $id alanını yazdırSample solution
type Prefixed<T, P extends string> = {
[K in keyof T as `${P}${string & K}`]: T[K]
};
type Box = Prefixed<{ id: number }, "$">;
const b: Box = { $id: 42 };
console.log(b.$id);Expected output
42
Questions and answers
Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.
1 After the definitions below, what is `Getters<Person>`?
type Getters<T> = {
[K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
type Person = { name: string };- { getname: () => string }
- { GetName: () => string }
- { getName: () => string } Correct answer
- { name: () => string }
Explanation: The template literal `get${Capitalize<...>}` turns the `name` key into `getName`; the value type becomes `() => T[K]`, i.e. `() => string`.
2 Capitalize the key
type Getters<T> = {
[K in keyof T as `get${____<string & K>}`]: () => T[K]
};type Getters<T> = {
[K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};Explanation: To upper-case the first letter use the built-in `Capitalize` type; `Uppercase` upper-cases every letter.
3 Type math parts
| Term | Meaning |
|---|---|
keyof T |
T's keys |
Capitalize<S> |
upper-cases first letter |
`get${...}` |
adds a string prefix |
as |
renames the key |