Typescript

Question 1

Type annotation

Answer 1

Explicitly writing a type for a variable/param/return. Example: let x: number = 3;

Question 2

Type inference

Answer 2

TypeScript infers a type when you don’t annotate. Example: let x = 3; // x: number

Question 3

Structural typing

Answer 3

Compatibility is based on shape (members), not “named” types. Example: {id:string} is assignable to any type requiring id:string

Question 4

Assignability

Answer 4

Whether a value of type A can be used where type B is expected (A “assignable to” B). Example: “hi” assignable to string; string not assignable to “hi”

Question 5

Literal type

Answer 5

A type that is a specific value. Example: “open” (not string), 1 (not number), true (not boolean).

Question 6

Widening

Answer 6

When a literal becomes a broader primitive type in inference. Example: let s = “a”; // s: string (widened from “a”)

Question 7

Const assertion (as const)

Answer 7

Freezes values to literal types + readonly. Example: const a = [“x”, 1] as const; // readonly [“x”, 1]

Question 8

Type assertion (cast)

Answer 8

Telling TS “treat this as X” without runtime conversion. Example: value as SomeType

Question 9

satisfies operator

Answer 9

Checks a value matches a type without changing the value’s inferred type. Example: const x = {a:1} satisfies Record<string, number>

Question 10

any

Answer 10

Opt-out of type checking; anything goes. Example: let x: any = 1; x.foo.bar(); // allowed

Question 11

unknown

Answer 11

Top type you must narrow before use. Example: let x: unknown; x.toFixed() // error until narrowed

Question 12

never

Answer 12

Type of values that never occur (impossible) or functions that never return. Example: function fail(): never { throw new Error() }

Question 13

void

Answer 13

Function returns nothing meaningful. Example: function log(): void { console.log(“hi”) }

Question 14

Union type

Answer 14

Either/or type. Example: string | number

Question 15

Intersection type

Answer 15

Combine requirements of both types. Example: A & B requires all members from A and B

Question 16

Optional property

Answer 16

Property may be missing. Example: type U = { flags?: {admin:boolean} } // flags can be absent

Question 17

Nullable / undefined union

Answer 17

When a type explicitly includes null/undefined. Example: {admin:boolean} | undefined

Question 18

Narrowing

Answer 18

Refining a broader type to a more specific type along a control-flow path. Example: if (typeof x === “string”) { x.toUpperCase() }

Question 19

Type guard

Answer 19

A runtime check TS recognizes to narrow types. Example: typeof x === “string”, x instanceof Date, “prop” in obj

Question 20

User-defined type guard

Answer 20

A function returning a predicate like x is T. Example: function isFoo(x:any): x is Foo { return “foo” in x }

Question 21

Discriminated union (tagged union)

Answer 21

Union of objects with a common literal “tag” property used for narrowing. Example: {kind:”a”,…}|{kind:”b”,…}

Question 22

Control-flow analysis

Answer 22

TS tracks possible execution paths to compute narrowed types in each branch. Example: after if (x) { /* x non-null */ }

Question 23

keyof operator

Answer 23

Produces a union of property names. Example: type K = keyof User // “id” | “name” | “flags”

Question 24

Indexed access type

Answer 24

Access a property’s type via indexing. Example: type Name = User[“name”]

Question 25

Generic

Answer 25

Types parameterized by other types (“type variables”). Example: Array, function id(x:T):T

Question 26

Type parameter

Answer 26

The variable in a generic. Example: function f(x:T){} // T is a type parameter

Question 27

Type argument

Answer 27

The specific type you plug into a generic. Example: f("hi") // string is a type argument

Question 28

Type parameter inference

Answer 28

TS infers type arguments from values. Example: id("hi") infers T=string

Question 29

Generic constraint

Answer 29

Restrict a type parameter with extends. Example: function len(x:T){ return x.length }

Question 30

Default type parameter

Answer 30

A fallback if caller doesn’t provide a type argument. Example: type Box = {value:T}

Question 31

Generic “relationship”

Answer 31

Generics often express that two things share a type. Example: function pair(a:T,b:T):[T,T] keeps them the same T

Question 32

Overload signatures

Answer 32

Multiple call signatures for one function (often in libs). Example: function f(x:string):string; function f(x:number):number;

Question 33

Call signature

Answer 33

A function type written as a signature. Example: type Fn = (x:number) => string

Question 34

Conditional type

Answer 34

Type-level if/else using extends. Example: T extends string ? "S" : "N"

Question 35

infer keyword

Answer 35

Within conditional types, captures a type part into a new type variable. Example: T extends (infer U)[] ? U : T

Question 36

Distributive conditional type

Answer 36

If the checked type is a naked type param, condition applies to each union member. Example: (A|B) extends ... becomes (A extends ...)|(B extends ...)

Question 37

Mapped type

Answer 37

Create a new object type by iterating keys. Example: type ReadonlyT = { [K in keyof T]: T[K] }

Question 38

Mapped type modifiers

Answer 38

Add/remove readonly/optional. Example: { [K in keyof T]-?: T[K] } removes optional

Question 39

Utility types (built-in)

Answer 39

Standard helpers like Partial, Pick, Omit, ReturnType, Parameters, Awaited, etc.

Question 40

Pick

Answer 40

Select a subset of properties. Example: Pick

Question 41

Omit

Answer 41

Remove properties. Example: Omit

Question 42

Partial

Answer 42

Make all props optional. Example: Partial

Question 43

Required

Answer 43

Make all props required. Example: Required

Question 44

NonNullable

Answer 44

Remove null and undefined from a type. Example: NonNullable gives {admin:boolean}

Question 45

ReturnType

Answer 45

Extract function return type. Example: ReturnType<() => number> is number

Question 46

Parameters

Answer 46

Extract function parameter tuple. Example: Parameters<(a:string,b:number)=>void> is [string, number]

Question 47

Awaited

Answer 47

Recursively unwrap Promise-like types. Example: Awaited> is string

Question 48

Template literal type

Answer 48

Build string types from pieces. Example: type Event = `on${Capitalize}`

Question 49

Declaration file (.d.ts)

Answer 49

Type-only file describing JS APIs. Often what you read when deciphering library types.

Question 50

Module augmentation

Answer 50

Add/merge types into an existing module’s declarations. Example: declare module "lib" { interface Options { ... } }

Question 51

Declaration merging

Answer 51

Certain declarations with the same name merge (interfaces, namespaces, etc.). Example: interface X {a:number} interface X {b:number} => X has a & b

Question 52

DefinitelyTyped (@types/…)

Answer 52

Community repo that provides typings for JS libraries via @types packages. Example: @types/lodash