Q: What should the return type of an async function be, and why does users.map(async (u) => fetchUser(u.id)) not give an array of users?

The return type of an async function is always Promise , for example Promise , otherwise the compiler reports an error. map with an async callback returns an array of promises, not an array of values, so you cannot access fields of the result. The right way is to wait with await Promise.all(...) before further processing, such as filter. For a tuple of promises Promise.all returns a tuple of values, while allSettled returns a tuple of objects with a status.

Question 1

What does TypeScript add to JavaScript?

Accepted Answer

TypeScript adds static types for variables, functions and objects. Checking happens before the program runs, at compile time or in the editor, and then plain JavaScript without types runs in the browser or Node. This catches typos and wrong arguments early and gives autocomplete. Types also work as living documentation for the code.

Question 2

Will TypeScript protect you from invalid data that a client sent in a request? Why?

Accepted Answer

No. Types exist only during development and compilation, and are erased at runtime. So JSON.parse returns any, and a type annotation on its result is just a promise nobody verifies. Data from outside (requests, files, queues, environment variables) must be checked at runtime, that is, validated, for example with a schema or a DTO with a validator.

Question 3

Why does TypeScript complain about an extra field in a fresh object literal, but not when the same object is first put into a variable? Does the type trim the extra field at runtime?

Accepted Answer

The excess property check applies only to a fresh literal that is assigned directly to a typed place. For a variable, ordinary structural compatibility applies: if the required fields are present, extra ones are allowed. At runtime the type trims nothing, so a field that is not in the type still goes, for example, into the API's JSON response. To make sure toResponse(user) cannot return passwordHash, you must build the result explicitly from allowed fields instead of relying on the type.

Question 4

Why can let role = 'admin' not be passed to a function that accepts 'admin' | 'user', while const role = 'admin' can? What does as const add?

Accepted Answer

let widens the literal to string, because the variable can be reassigned, while const keeps the literal type 'admin'. as const makes an array a readonly tuple of literals and an object one with readonly literal fields. From it (typeof ROLES)[number] gives the union 'admin' | 'user'. Node runs .ts directly through type stripping and does not check types, so checking is done with tsc --noEmit.

Question 5

A parameter has the type string | string[] | null. Why does if (typeof input === 'object') not remove null, and how do you narrow the type correctly?

Accepted Answer

typeof null returns 'object', so such a check does not exclude null, and TypeScript rightly says input may be null. At runtime this would give a TypeError. Correct options: an explicit input !== null, Array.isArray(input) for an array, or input?.length. In general narrowing must match the real behavior of JavaScript, not intuition.

Question 6

How does Record<Status, string> differ from { [key: string]: string }? What happens if a new value is added to the Status union?

Accepted Answer

Record with a union of keys requires all keys: if a new value is added to Status, the compiler shows an error in every map where it is missing. This is an exhaustiveness check for maps. An index signature says that any string key exists, and that is untrue: reading loose.refunded.length compiles and then fails at runtime with a TypeError because the value is undefined. For a closed set of keys Record is more honest.

Question 7

What should the return type of an async function be, and why does users.map(async (u) => fetchUser(u.id)) not give an array of users?

Accepted Answer

The return type of an async function is always Promise, for example Promise, otherwise the compiler reports an error. map with an async callback returns an array of promises, not an array of values, so you cannot access fields of the result. The right way is to wait with await Promise.all(...) before further processing, such as filter. For a tuple of promises Promise.all returns a tuple of values, while allSettled returns a tuple of objects with a status.

Question 8

How does extending through interface extends differ from & for types? When do you choose interface and when type?

Accepted Answer

extends checks compatibility immediately at declaration: if a field conflicts, there is an error in the interface itself. & silently gives never for a conflicting field, and the error appears only when you try to create a value. An interface merges when declared again (declaration merging), while type gives Duplicate identifier. A practical rule: interface for object shapes and extending external types, type for union, mapped and conditional types.

Question 9

JSON.parse returns any. How do any, unknown and never differ? What type should a function that reads a payload from a queue return?

Accepted Answer

any turns off checking and infects everything it touches. unknown accepts anything but does not let you do anything without narrowing. never is a value that does not exist: the bottom type that appears in exhaustive switch statements and in functions that only throw. A payload from a queue is typed as unknown and narrowed through validation, not through as.

Question 10

refunded was added to the events union, but the handler was not updated. How do you make the compiler catch this, and why is it better than default: return 'unknown'?

Accepted Answer

For a discriminated union, a switch on the type field narrows the type in each branch. In default only the unhandled variant remains, and with full coverage that is never. If you call assertNever(e) there, a new event becomes a compile error (the value is not assignable to never). A silent default hides the new event instead, and the bug is found in production.

Question 11

A custom type guard x is User lets through an object without email, the code compiles without errors, and in production it fails. Who is to blame and how do you fix it?

Accepted Answer

A type predicate is the function author's promise, the compiler does not check its body. If the guard checks only id, it lets through an object without email, and then user.email.toLowerCase() throws a TypeError. Fix: check every required field or use a schema (zod safeParse, class-validator). A separate test for the guard catches the case when it became outdated after adding a new required field.

Question 12

How do you type pluck(items, key) so that the key is checked and the result has the right type? What are K extends keyof T and T[K]?

Accepted Answer

The signature is function pluck<T, K extends keyof T>(items: T[], key: K): T[K][]. T is inferred from the array, K from the key literal, and T[K] is an indexed access type: the type of the field. The constraint K extends keyof T gives both autocomplete and an error if the field name is misspelled. For pluck(users, 'age') the result is number[].

Question 13

A function get(key): T reads from process.env and returns . Everything compiles, but at runtime it is a string. Why does the generic guarantee nothing here, and how is it fixed?

Accepted Answer

process.env always holds strings. A generic only in the return type is a hidden as: the compiler trusts <number>, and there is no runtime check. The right way is to validate and convert environment variables at application start, for example with a schema, and access them through a typed config. Then PORT=abc breaks startup immediately, not on the first request.

Question 14

Why does Omit with a typo compile while Pick does not? What follows for a response DTO when the field passwordHash is renamed?

Accepted Answer

The second parameter of Omit is constrained by keyof any, not keyof T, so a typo is not an error. Pick requires K extends keyof T and catches it. If passwordHash is renamed, Omit silently stops excluding anything, and the hash goes into the response. Fix: your own StrictOmit or Pick with an explicit list of allowed fields (a whitelist instead of a blacklist).

Question 15

How do you get the result type of an async service method without duplication? Why are Awaited and NonNullable needed here?

Accepted Answer

ReturnType for an async method gives Promise, not User. Awaited unwraps the Promise, and NonNullable removes null and undefined, so NonNullable>> is User. This way the type comes straight from the service signature and cannot drift from it. For overloaded functions ReturnType takes only the last signature.

Question 16

How do you get, using a mapped type with as, a type Getters<User> with the keys getName and getAge?

Accepted Answer

A mapped type with key remapping: { [K in keyof T as get${Capitalize<string & K>}]: () => T[K] }. The as part transforms the key, and string & K drops keys of type symbol and number so that Capitalize works. For User { name: string; age: number } you get getName: () => string and getAge: () => number. This pattern is used for getters, events and filtering fields by type.

Question 17

What does infer do in a conditional type? How do you get the parameter type and return type of a handler without writing them by hand?

Accepted Answer

infer introduces a type variable inside extends and fills it when the pattern matches. For example, T extends (p: infer P) => infer R ? [P, R] : never extracts the parameter type and the return type. The built-in Parameters, ReturnType and Awaited are made the same way. This lets you derive types from existing functions instead of duplicating them, and keeps them consistent when things change.

Question 18

How does private in TypeScript differ from #field in JavaScript? What will JSON.stringify show for each?

Accepted Answer

private is checked only by the compiler and erased, so at runtime the field is ordinary: JSON.stringify, Object.keys and logs show it. #pin is a truly private JavaScript field, inaccessible from outside at runtime, and serialization does not see it. Consequence: a private apiKey easily ends up in an API response or a log, so for secrets #field is safer. With private fields Proxy and spies can throw a TypeError.

Question 19

Why does the variable e in catch (e) have the type unknown under strict, and how do you correctly get the error message?

Accepted Answer

Under strict, useUnknownInCatchVariables applies: throw can throw anything, even a string or a number, so unknown is the honest type. Accessing e.message without a check gives a compile error, and at runtime for a thrown string it would be undefined. The right way: e instanceof Error ? e.message : String(e). catch (e: any) only hides the problem.

Question 20

Does strict: true catch access to a nonexistent array element or map key? What does noUncheckedIndexedAccess change?

Accepted Answer

No. With strict, arr[0] has the element type and byId['u1'] the value type, although both can be undefined at runtime, so there are zero compile errors. The noUncheckedIndexedAccess flag adds | undefined to such reads, and then the compiler forces checks. It is not part of strict and is enabled separately. The cost: noise in index loops, which is cured with for...of, at() with a check, or an explicit branch.

Question 21

tsconfig has paths: { '@app/*': ['src/*'] }, tsc passes, but node dist/main.js fails in Docker. What is the error and why?

Accepted Answer

The error is Cannot find module '@app/...' (MODULE_NOT_FOUND). paths is only a hint for resolving types: tsc does not rewrite the specifier in the generated JS. Locally it often works through ts-node with tsconfig-paths or a dev build server, while plain tsc in Docker does not. Fix: subpath imports (#app/*) in package.json, tsconfig-paths/register, tsc-alias or a bundler. In CI it is worth checking that the built dist really starts.

Question 22

How does a numeric enum differ from a string one at runtime? Why does enum break when running .ts through type stripping?

Accepted Answer

A numeric enum creates a reverse mapping: Object.keys(Status) gives ['0', '1', 'Active', 'Blocked'], and Status[0] returns 'Active'. A string enum has no reverse mapping. An enum generates real runtime code, so with type stripping Node cannot simply erase it and reports an unsupported syntax error. Alternative: a union of literals with an as const object. Also a numeric enum is dangerous if numbers are stored in the DB and a new value is inserted in the middle.

Question 23

Why does Object.keys(user) return string[] and not (keyof User)[]? Why is the fix through as (keyof User)[] dangerous?

Accepted Answer

TypeScript types structurally, so at runtime an object may have extra keys that the type does not describe. string[] is the honest answer. The cast as (keyof User)[] compiles but may let through, for example, loginCount, and later indexed access will give undefined. Safer: an explicit list of keys, Object.entries with a check, or a Map.

Question 24

The code compiles under strict, review passed, and in prod it fails for some users. Which two places with as and ! most often 'lie', and what do you do about it?

Accepted Answer

as User does not check the data, it only turns off type checking: if the real object is different, the error comes at runtime. ! removes undefined from the type with no runtime check, so user.profile!.email fails if there is no profile. Fix: validate unknown with a schema, use ?. and an explicit branch for the missing value. A useful lint rule: no-non-null-assertion and limiting as to system boundaries.

Question 25

An import endpoint responds 200 before the records are saved, and save errors are not visible anywhere. Inside is items.forEach(async (i) => await save(i)). Why did TypeScript not catch this?

Accepted Answer

forEach does not wait for the promises from an async callback and returns undefined, so the code moves on and the response is sent earlier. TypeScript allows a callback that returns a Promise where void is expected. A rejected promise is handled by nobody: it is an unhandledRejection, which in Node 15+ can crash the process. Fix: for...of with await or Promise.all (with limited concurrency), plus the lint rules no-floating-promises and no-misused-promises.

Question 26

Why does an assertion function asserts v is ... work when declared with function, but not when the same signature is in a const with an arrow?

Accepted Answer

For narrowing through asserts, TypeScript requires the call name to have an explicit type annotation. A function declaration has an explicit signature, while const x = (v) => ... gets an inferred type, and the compiler reports that an explicit annotation is needed. So the narrowing does not apply and later field access is still considered unsafe. Fix: function or an explicit annotation const assertOk: (v: T) => asserts v is NonNullable.

Question 27

A value has already been checked in if, but inside a forEach callback the compiler again considers it possibly undefined. Why, and what changed in TypeScript 5.4?

Accepted Answer

Narrowing of a property (ctx.user) does not survive a callback, because the compiler cannot guarantee the property will not be changed between the check and the call. For let the problem is that the variable may be reassigned after the closure is created. Since TypeScript 5.4, narrowing is preserved in closures if there are no assignments to the variable after it. For properties the reliable fix is const user = ctx.user before the if.

Question 28

How does TypeScript infer T from several arguments? Why does merge(a, b) compile for two objects but merge(1, '1') does not? How do you require b to be the same type as a?

Accepted Answer

The compiler collects candidates for T from the arguments. For objects it can combine the shapes into a union, so the call compiles. For primitives T is fixed by the first candidate (1), and the second argument '1' does not fit. NoInfer (TypeScript 5.4) removes a position from the inference candidates, so b: NoInfer must match the T already inferred from a.

Question 29

A PATCH accepts Partial<User> and does { ...user, ...patch }. The types pass, but the user's name disappears. Why, and which tsconfig flag catches it?

Accepted Answer

Partial makes a field optional, and an optional field without an extra flag allows an explicit undefined value. Spread with undefined overwrites the existing value, while the result type is still User. The exactOptionalPropertyTypes flag forbids an explicit undefined for optional fields and gives an error at the call. In PATCH you should strip undefined before merging or use a whitelist of fields and explicit mapping.

Question 30

What is a distributive conditional type? Why does ToArray<string | number> give string[] | number[], while a version with the [T] wrapper gives (string | number)[]?

Accepted Answer

A conditional type with a 'naked' parameter T is distributive over a union: it is applied to each member separately, and the results are combined. So T extends unknown ? T[] : never for string | number gives string[] | number[]. The wrapper [T] extends [unknown] turns off distribution and treats the union as a whole, hence (string | number)[]. Exclude and Extract are built on distribution.

TypeScript interview questions and answers

Junior questions

1. What does TypeScript add to JavaScript?

2. Will TypeScript protect you from invalid data that a client sent in a request? Why?

3. Why does TypeScript complain about an extra field in a fresh object literal, but not when the same object is first put into a variable? Does the type trim the extra field at runtime?

4. Why can let role = 'admin' not be passed to a function that accepts 'admin' | 'user', while const role = 'admin' can? What does as const add?

5. A parameter has the type string | string[] | null. Why does if (typeof input === 'object') not remove null, and how do you narrow the type correctly?

6. How does Record<Status, string> differ from { [key: string]: string }? What happens if a new value is added to the Status union?

7. What should the return type of an async function be, and why does users.map(async (u) => fetchUser(u.id)) not give an array of users?

Middle questions

1. How does extending through interface extends differ from & for types? When do you choose interface and when type?

2. JSON.parse returns any. How do any, unknown and never differ? What type should a function that reads a payload from a queue return?

3. refunded was added to the events union, but the handler was not updated. How do you make the compiler catch this, and why is it better than default: return 'unknown'?

4. A custom type guard x is User lets through an object without email, the code compiles without errors, and in production it fails. Who is to blame and how do you fix it?

5. How do you type pluck(items, key) so that the key is checked and the result has the right type? What are K extends keyof T and T[K]?

6. A function get<T>(key): T reads from process.env and returns <number>. Everything compiles, but at runtime it is a string. Why does the generic guarantee nothing here, and how is it fixed?

7. Why does Omit<User, 'pasword'> with a typo compile while Pick<User, 'pasword'> does not? What follows for a response DTO when the field passwordHash is renamed?

8. How do you get the result type of an async service method without duplication? Why are Awaited and NonNullable needed here?

9. How do you get, using a mapped type with as, a type Getters<User> with the keys getName and getAge?

10. What does infer do in a conditional type? How do you get the parameter type and return type of a handler without writing them by hand?

11. How does private in TypeScript differ from #field in JavaScript? What will JSON.stringify show for each?

12. Why does the variable e in catch (e) have the type unknown under strict, and how do you correctly get the error message?

13. Does strict: true catch access to a nonexistent array element or map key? What does noUncheckedIndexedAccess change?

14. tsconfig has paths: { '@app/*': ['src/*'] }, tsc passes, but node dist/main.js fails in Docker. What is the error and why?

15. How does a numeric enum differ from a string one at runtime? Why does enum break when running .ts through type stripping?

16. Why does Object.keys(user) return string[] and not (keyof User)[]? Why is the fix through as (keyof User)[] dangerous?

17. The code compiles under strict, review passed, and in prod it fails for some users. Which two places with as and ! most often 'lie', and what do you do about it?

18. An import endpoint responds 200 before the records are saved, and save errors are not visible anywhere. Inside is items.forEach(async (i) => await save(i)). Why did TypeScript not catch this?

Senior questions

1. Why does an assertion function asserts v is ... work when declared with function, but not when the same signature is in a const with an arrow?

2. A value has already been checked in if, but inside a forEach callback the compiler again considers it possibly undefined. Why, and what changed in TypeScript 5.4?

3. How does TypeScript infer T from several arguments? Why does merge(a, b) compile for two objects but merge(1, '1') does not? How do you require b to be the same type as a?

4. A PATCH accepts Partial<User> and does { ...user, ...patch }. The types pass, but the user's name disappears. Why, and which tsconfig flag catches it?

5. What is a distributive conditional type? Why does ToArray<string | number> give string[] | number[], while a version with the [T] wrapper gives (string | number)[]?

6. How do you use template literal types to type route parameters like /orgs/:orgId/users/:userId? What is the cost of such recursion?

7. package.json has "type": "module", and in tsconfig both module and moduleResolution are nodenext. Why does import './users' give an error, and why do you write ./users.js in a .ts file?

8. What are branded types and why are they used for identifiers like UserId and OrderId? Does the brand exist at runtime?

9. Why does TypeScript under strictFunctionTypes catch an unsafe assignment of a handler declared as a function property, but let the same pass for a method?

10. In Nest with emitDecoratorMetadata, a dependency imported through import type breaks DI. What exactly does tsc generate in design:paramtypes for an interface and for import type?

11. A payment service has expected failures (card declined, insufficient funds) and unexpected ones (network, a bug). How do you type them: exceptions or Result? How do they reach the HTTP response?

12. A team wants a base generic repository Repository<T extends Entity> for all services. What is good about it in terms of types, what does tsc catch, and where do you stop generalizing?

Train these questions

Answer out loud and get graded

Other topics

Explore the platform

4. Why can `let role = 'admin'` not be passed to a function that accepts `'admin' | 'user'`, while `const role = 'admin'` can? What does `as const` add?

5. A parameter has the type `string | string[] | null`. Why does `if (typeof input === 'object')` not remove `null`, and how do you narrow the type correctly?

6. How does `Record<Status, string>` differ from `{ [key: string]: string }`? What happens if a new value is added to the `Status` union?

7. What should the return type of an async function be, and why does `users.map(async (u) => fetchUser(u.id))` not give an array of users?

1. How does extending through `interface extends` differ from `&` for types? When do you choose `interface` and when `type`?

2. `JSON.parse` returns `any`. How do `any`, `unknown` and `never` differ? What type should a function that reads a payload from a queue return?

3. `refunded` was added to the events union, but the handler was not updated. How do you make the compiler catch this, and why is it better than `default: return 'unknown'`?

4. A custom type guard `x is User` lets through an object without `email`, the code compiles without errors, and in production it fails. Who is to blame and how do you fix it?

5. How do you type `pluck(items, key)` so that the key is checked and the result has the right type? What are `K extends keyof T` and `T[K]`?

6. A function `get<T>(key): T` reads from `process.env` and returns `<number>`. Everything compiles, but at runtime it is a string. Why does the generic guarantee nothing here, and how is it fixed?

7. Why does `Omit<User, 'pasword'>` with a typo compile while `Pick<User, 'pasword'>` does not? What follows for a response DTO when the field `passwordHash` is renamed?

8. How do you get the result type of an async service method without duplication? Why are `Awaited` and `NonNullable` needed here?

9. How do you get, using a mapped type with `as`, a type `Getters<User>` with the keys `getName` and `getAge`?

10. What does `infer` do in a conditional type? How do you get the parameter type and return type of a handler without writing them by hand?

11. How does `private` in TypeScript differ from `#field` in JavaScript? What will `JSON.stringify` show for each?

12. Why does the variable `e` in `catch (e)` have the type `unknown` under `strict`, and how do you correctly get the error message?

13. Does `strict: true` catch access to a nonexistent array element or map key? What does `noUncheckedIndexedAccess` change?

14. `tsconfig` has `paths: { '@app/': ['src/'] }`, `tsc` passes, but `node dist/main.js` fails in Docker. What is the error and why?

15. How does a numeric `enum` differ from a string one at runtime? Why does `enum` break when running `.ts` through type stripping?

16. Why does `Object.keys(user)` return `string[]` and not `(keyof User)[]`? Why is the fix through `as (keyof User)[]` dangerous?

17. The code compiles under `strict`, review passed, and in prod it fails for some users. Which two places with `as` and `!` most often 'lie', and what do you do about it?

18. An import endpoint responds 200 before the records are saved, and save errors are not visible anywhere. Inside is `items.forEach(async (i) => await save(i))`. Why did TypeScript not catch this?

1. Why does an assertion function `asserts v is ...` work when declared with `function`, but not when the same signature is in a `const` with an arrow?

2. A value has already been checked in `if`, but inside a `forEach` callback the compiler again considers it possibly `undefined`. Why, and what changed in TypeScript 5.4?

3. How does TypeScript infer `T` from several arguments? Why does `merge(a, b)` compile for two objects but `merge(1, '1')` does not? How do you require `b` to be the same type as `a`?

4. A PATCH accepts `Partial<User>` and does `{ ...user, ...patch }`. The types pass, but the user's `name` disappears. Why, and which `tsconfig` flag catches it?

5. What is a distributive conditional type? Why does `ToArray<string | number>` give `string[] | number[]`, while a version with the `[T]` wrapper gives `(string | number)[]`?

6. How do you use template literal types to type route parameters like `/orgs/:orgId/users/:userId`? What is the cost of such recursion?

7. `package.json` has `"type": "module"`, and in `tsconfig` both `module` and `moduleResolution` are `nodenext`. Why does `import './users'` give an error, and why do you write `./users.js` in a `.ts` file?

8. What are branded types and why are they used for identifiers like `UserId` and `OrderId`? Does the brand exist at runtime?

9. Why does TypeScript under `strictFunctionTypes` catch an unsafe assignment of a handler declared as a function property, but let the same pass for a method?

10. In Nest with `emitDecoratorMetadata`, a dependency imported through `import type` breaks DI. What exactly does `tsc` generate in `design:paramtypes` for an interface and for `import type`?

12. A team wants a base generic repository `Repository<T extends Entity>` for all services. What is good about it in terms of types, what does `tsc` catch, and where do you stop generalizing?