{"department":"Development","description":null,"descriptionStatus":null,"descriptionUpdatedAt":null,"id":"20256edf-4ad8-49ee-a65c-a33b3dfc8ec6","label":"TypeScript","shortDescription":null,"slug":"typescript","updatedAt":"2023-09-11T07:00:34.811Z","quizzes":[{"difficulty":"beginner","id":"8hsIMTdyim","questionCount":18,"questions":[{"index":0,"options":["A superset of JavaScript that adds optional static typing","A replacement for JavaScript with completely different syntax","A database query language similar to SQL","A JavaScript framework for building user interfaces"],"question":"What is TypeScript?","difficulty":"beginner","explanation":"TypeScript is a superset of JavaScript that adds optional static typing and compile-time type checking, while maintaining full compatibility with existing JavaScript code.","correctIndex":0},{"index":1,"options":["The property is private and inaccessible outside the class","The property is required and must be provided","The property is optional and may be omitted","The property is read-only and cannot be modified"],"question":"What does the `?` modifier indicate when used on a property in a TypeScript interface?","difficulty":"beginner","explanation":"The `?` modifier marks a property as optional, meaning objects implementing the interface are not required to include that property.","correctIndex":2},{"index":2,"options":["function add(number a, number b): number","function add(a: number, b: number) -> number","function add(a: number, b: number) returns number","function add(a: number, b: number): number"],"question":"Which of the following is the correct syntax to specify the return type of a function in TypeScript?","difficulty":"beginner","explanation":"In TypeScript, the return type is specified after the parameter list using a colon (`:`), followed by the type, before the function body.","correctIndex":3},{"index":3,"options":["undefined","never","void","null"],"question":"What is the TypeScript type that represents a value that will never occur (e.g., the return type of a function that always throws an error)?","difficulty":"beginner","explanation":"The `never` type represents values that never occur, such as the return type of a function that always throws an exception or never returns.","correctIndex":1},{"index":4,"options":["interface","struct","class","type"],"question":"Which TypeScript keyword is used to define a contract that describes the shape of an object?","difficulty":"beginner","explanation":"The `interface` keyword defines a contract specifying the properties and methods an object must have, enabling type checking and structural typing in TypeScript.","correctIndex":0},{"index":5,"options":["let age: number = 30;","let age = 30 : number;","let age (number) = 30;","let age = \"30\" as number;"],"question":"How do you correctly declare a variable `age` in TypeScript that must always hold a number?","difficulty":"beginner","explanation":"In TypeScript, the type annotation follows the variable name, separated by a colon.","correctIndex":0},{"index":6,"options":["It compiles without errors.","It crashes at runtime.","It throws a type error: Type 'number' is not assignable to type 'string'.","It implicitly converts 45 to a string."],"question":"You have the code `let id = \"123\"; id = 45`. What happens when you compile this TypeScript code?","difficulty":"beginner","explanation":"TypeScript infers the type of 'id' as string based on the initial assignment. Assigning a number to it violates the type constraint.","correctIndex":2},{"index":7,"options":["It is used only for variables that are null.","It is exactly the same as 'any'.","It represents a value that will never be defined.","It allows any value but requires type checking before performing operations on it."],"question":"What is the purpose of the 'unknown' type in TypeScript?","difficulty":"beginner","explanation":"The 'unknown' type is a type-safe counterpart of 'any' that requires type checking before performing operations on it.","correctIndex":3},{"index":8,"options":["void","unknown","any","never"],"question":"Which type should you prefer when you don't know the type of a value at compile time, as a best practice?","difficulty":"beginner","explanation":"The unknown type is safer than any because it requires type checking before you can perform operations on the value, preventing accidental misuse.","correctIndex":1},{"index":9,"options":["Interfaces can be extended and merged, making them better for defining public APIs","Interfaces are required for all TypeScript classes","Interfaces can represent union types, while type aliases cannot","Interfaces perform better at runtime than type aliases"],"question":"What is a key advantage of using `interface` over `type` for defining object shapes in TypeScript?","difficulty":"beginner","explanation":"Interfaces support declaration merging and can be extended by other interfaces, making them ideal for defining extensible public APIs and class contracts.","correctIndex":0},{"index":10,"options":["--noImplicitAny","--forceConsistent","--strictNullChecks","--strict"],"question":"Which TypeScript compiler option enables all strict type-checking options at once?","difficulty":"beginner","explanation":"The --strict flag enables all strict type-checking options including strictNullChecks, noImplicitAny, strictFunctionTypes, and others in one setting.","correctIndex":3},{"index":11,"options":["Returns undefined instead of throwing an error if the object is null or undefined","Throws an error if the property doesn't exist","Makes the property optional in the type definition","Converts null values to undefined automatically"],"question":"What does the optional chaining operator (?.) do when accessing a property on a potentially null or undefined object?","difficulty":"beginner","explanation":"Optional chaining short-circuits and returns undefined when the object before ?. is null or undefined, preventing runtime errors from accessing properties on nullish values.","correctIndex":0},{"index":12,"options":["Prevents the variable from being reassigned","Narrows the type to its most specific literal version, making properties readonly","Makes the variable immutable at runtime","Converts the variable to a const enum"],"question":"What does using `as const` on an object or array do in TypeScript?","difficulty":"beginner","explanation":"The `as const` assertion narrows types to their literal versions and makes all properties readonly, which is useful for defining constant values with precise types.","correctIndex":1},{"index":13,"options":["webpack.config.js","tsconfig.json",".tsrc","package.json"],"question":"What is the standard configuration file used to customize the behavior of the TypeScript compiler in a project?","difficulty":"beginner","explanation":"The tsconfig.json file is used to specify the root files and the compiler options required to compile a TypeScript project.","correctIndex":1},{"index":14,"options":["tsc","webpack","node","npm"],"question":"Which command-line tool is the official compiler used to convert TypeScript code into JavaScript?","difficulty":"beginner","explanation":"tsc stands for TypeScript Compiler and is the official command-line tool provided by Microsoft to compile TypeScript files into JavaScript.","correctIndex":0},{"index":15,"options":["npm install @types/express","tsc --add-types express","npm install express --typings","npm install express-types"],"question":"In the TypeScript ecosystem, how do you typically install type definitions for a third-party library like Express?","difficulty":"beginner","explanation":"TypeScript uses the DefinitelyTyped repository to provide type definitions, which are distributed as packages under the @types namespace on npm.","correctIndex":0},{"index":16,"options":[".ts",".tsx",".d.ts",".js"],"question":"What file extension is used for a TypeScript declaration file that contains only type information and no runtime code?","difficulty":"beginner","explanation":"The .d.ts extension stands for declaration file and is used to declare types for existing JavaScript code without providing any implementation.","correctIndex":2},{"index":17,"options":["tsc --watch","npm start","nodemon","ts-node"],"question":"Which tool allows you to execute TypeScript files directly in a Node.js environment without compiling them to JavaScript first?","difficulty":"beginner","explanation":"ts-node is an execution engine for TypeScript that compiles and runs TypeScript files on the fly without needing a separate build step.","correctIndex":3}]},{"difficulty":"intermediate","id":"jHt8kmaJdH","questionCount":24,"questions":[{"index":0,"options":["It extracts and captures a type from a pattern within the conditional type's `extends` clause.","It infers the type of a generic parameter from a function call outside the conditional type.","It creates an inferred tuple type from a rest parameter array.","It explicitly declares a new type alias within the current scope."],"question":"In a conditional type, what is the purpose of the `infer` keyword?","difficulty":"intermediate","explanation":"The `infer` keyword is used within the `extends` clause of a conditional type to deduce and capture a specific type that can then be referenced in the true branch.","correctIndex":0},{"index":1,"options":["`object`","`\"name\" | \"age\"`","`string`","`string | number`"],"question":"What will be the resulting type of `keyof { name: string, age: number }`?","difficulty":"intermediate","explanation":"The `keyof` operator produces a union of string or numeric literal types representing the exact keys of the given object type.","correctIndex":1},{"index":2,"options":["`unknown` is implicitly assigned to all unannotated variables, while `any` must be explicitly typed.","`unknown` forces the developer to narrow the type using type guards before performing operations on it, whereas `any` disables type checking entirely.","`unknown` allows any operation on the variable, while `any` throws runtime errors.","`any` can only represent primitive types, while `unknown` represents complex objects."],"question":"Why might a developer use `unknown` instead of `any` for a variable whose type is not known at design time?","difficulty":"intermediate","explanation":"Unlike `any`, which bypasses type checking allowing any operation, `unknown` is a type-safe counterpart that requires type narrowing before any operations can be performed on the value.","correctIndex":1},{"index":3,"options":["Enums","Type aliases","Abstract classes","Interfaces"],"question":"Which TypeScript construct supports declaration merging, allowing developers to split a definition across multiple blocks?","difficulty":"intermediate","explanation":"Interfaces support declaration merging, where the compiler merges the members of multiple interfaces with the same name, while type aliases cannot be redeclared.","correctIndex":3},{"index":4,"options":["To cast a value to a new type while preserving its original runtime type.","To check if two types are exactly identical at runtime.","To enforce that a class implements all members of an interface and alters the class's inferred type.","To ensure an expression matches a specific type without widening the inferred type of the expression."],"question":"What is the primary purpose of the `satisfies` operator?","difficulty":"intermediate","explanation":"The `satisfies` operator validates that an expression conforms to a given type without changing the inferred type of the expression, preserving its specific literal types.","correctIndex":3},{"index":5,"options":["The union members share the same discriminant value, causing ambiguity.","The discriminant property was not narrowed using a type guard (like `if` or `switch`) before accessing the property.","The interface definitions are missing the `implements` keyword.","TypeScript does not support discriminated unions properly without a runtime polyfill."],"question":"When debugging a function that accepts a discriminated union, why might TypeScript still throw a type error when accessing a property that only exists on one member of the union?","difficulty":"intermediate","explanation":"TypeScript requires control flow analysis via type guards (like checking the discriminant property) to narrow down the union type before accessing member-specific properties.","correctIndex":1},{"index":6,"options":["`as const`","`satisfies`","Type assertion (`as`)","`implements`"],"question":"You want to ensure an object conforms to a specific type without widening or losing the literal types of its properties. Which operator should you use?","difficulty":"intermediate","explanation":"The `satisfies` operator validates that an expression matches a type without altering the inferred type, preserving literal types and allowing access to specific properties.","correctIndex":1},{"index":7,"options":["It allows TypeScript to guess the type of `T` if it is not provided.","It forces TypeScript to infer the most general type instead of a specific one.","It extracts a sub-type from `T` that matches the pattern in `U` to be used in `X`.","It infers missing generic parameters at runtime based on the function arguments."],"question":"In a conditional type like `T extends U ? X : Y`, what does the `infer` keyword allow you to do?","difficulty":"intermediate","explanation":"The `infer` keyword is used within the `extends` clause of a conditional type to extract a specific type from a complex type structure, making it available in the true branch.","correctIndex":2},{"index":8,"options":["`any` causes runtime performance issues during exception handling.","`unknown` automatically converts the error to a string, making it easier to log.","`any` is deprecated in newer TypeScript versions for use within `catch` blocks.","`unknown` enforces type checking before operating on the variable, preventing accidental property access on non-object errors."],"question":"In a `catch` block, why is it considered a best practice to type the caught variable as `unknown` instead of `any`?","difficulty":"intermediate","explanation":"Typing the caught variable as `unknown` forces the developer to perform type narrowing (e.g., checking if it's an instance of Error) before accessing properties, avoiding runtime errors and type safety breaches.","correctIndex":3},{"index":9,"options":["A custom mapped type that recursively applies `Readonly` to nested objects.","`Readonly`","`ReadonlyArray`","`Readonly` with the `--deepReadonly` compiler flag enabled."],"question":"You need to create a type that makes all properties of an existing type `T` deeply readonly, meaning not even nested objects can be modified. Which approach works best?","difficulty":"intermediate","explanation":"The built-in `Readonly` utility type is shallow and does not apply to nested properties. A custom recursive mapped type is required to enforce deep immutability.","correctIndex":0},{"index":10,"options":["TypeScript only performs excess property checking on object literals directly assigned to typed variables","TypeScript widens the type of userData to include role","The userData variable is inferred as any when passed through assignment","The role property is implicitly cast to never"],"question":"Why does TypeScript not report an excess property error in the second assignment below?\n\ninterface User { name: string; age: number; }\nconst userData = { name: \"Alice\", age: 30, role: \"admin\" };\nconst user2: User = userData;","difficulty":"intermediate","explanation":"Excess property checking only applies to object literals directly assigned to a typed variable. When the object passes through an intermediate variable, it is structurally compatible even with extra properties.","correctIndex":0},{"index":11,"options":["It allows assigning values that do not match the declared type","It validates the type while preserving the inferred literal types of the values","It performs runtime validation of the values at execution time","It automatically makes all properties readonly without explicit declaration"],"question":"What is the primary advantage of using the `satisfies` operator over a type annotation when validating an object against a type?","difficulty":"intermediate","explanation":"The `satisfies` operator ensures an expression matches a type without widening the inferred type, preserving literal types and allowing access to properties not in the target type.","correctIndex":1},{"index":12,"options":["Always, TypeScript enforces exhaustive checks on all discriminated unions","Only when the default case is explicitly handled","Only when the function has an explicit return type annotation","Never, missing cases produce a runtime error but not a compile-time error"],"question":"Given a discriminated union, when will TypeScript report a compile-time error for a missing case in a switch statement?","difficulty":"intermediate","explanation":"Without an explicit return type, TypeScript infers the return type to include undefined for unhandled cases. An explicit return type forces TypeScript to flag that not all code paths return the expected type.","correctIndex":2},{"index":13,"options":["Use Pick for required keys combined with Partial>> for optional keys","Use type assertions to selectively override inferred types on individual fields","Apply Partial to the entire base type and override required fields individually","Use Required on the entire base type to enforce all fields"],"question":"When designing a configurable API type where some fields from a base type should remain required and others should become optional, which pattern is considered best practice?","difficulty":"intermediate","explanation":"Combining Pick for required keys with Partial for optional keys provides explicit, type-safe control over which fields are required versus optional, avoiding the pitfalls of Partial on the entire type.","correctIndex":0},{"index":14,"options":["All keys from T whose values include null in their union","All values from T that are not null","All keys from T whose value type cannot be assigned null","All keys from T, with null and undefined removed from their value types"],"question":"What does the following conditional type extract?\n\ntype NonNullableKeys = {\n [K in keyof T]: null extends T[K] ? never : K\n}[keyof T];","difficulty":"intermediate","explanation":"For each key K, if null extends T[K] (meaning null is assignable to the value type), it maps to never and is filtered out. Keys whose values cannot be null are kept, resulting in a union of those key names.","correctIndex":2},{"index":15,"options":["The variable `user1` is inferred as `any`, bypassing the type checker.","TypeScript performs excess property checks only on object literals directly assigned to typed variables.","The `const` declaration on `user1` makes it readonly, which is compatible with","Variables implicitly cast to their target type when assigned, but object literals do not."],"question":"Given the interface `interface User { id: number; name: string; }`, why does `const user3: User = { id: 1, name: 'Alice', age: 30 }` fail with an excess property error, while `const user1 = { id: 1, name: 'Alice', age: 30 }; const user2: User = user1;` succeeds?","difficulty":"intermediate","explanation":"TypeScript performs excess property checking only on object literals directly assigned to typed variables. When an object is assigned to an intermediate variable, its type is inferred, and the excess property check is bypassed during the subsequent assignment.","correctIndex":1},{"index":16,"options":["object","undefined","number","null"],"question":"What is the output of typeof null in JavaScript?","difficulty":"beginner","explanation":"Due to a historical bug in JavaScript, typeof null returns 'object'.","correctIndex":0},{"index":17,"options":["any","void","never","unknown"],"question":"Which of the following types represents all values in TypeScript?","difficulty":"advanced","explanation":"The 'unknown' type is the type-safe counterpart of 'any' and represents any possible value, requiring type checking before operations are performed on it.","correctIndex":3},{"index":18,"options":["To access a specific property of an object.","To remove a key from an object type.","To declare a new key in an interface.","To create a union type from the keys of an object type."],"question":"What is the purpose of the 'keyof' keyword in TypeScript?","difficulty":"intermediate","explanation":"The 'keyof' operator takes an object type and produces a string or numeric literal union of its keys.","correctIndex":3},{"index":19,"options":["It enforces that each file can be safely transpiled in isolation, preventing features that rely on cross-file type analysis.","It disables type checking to improve build performance.","It allows TypeScript to emit ECMAScript modules instead of CommonJS.","It ensures that declaration files (.d.ts) are generated for every source file."],"question":"What is the primary reason for enabling the `isolatedModules` compiler option in a TypeScript project that uses a transpiler like Babel or esbuild?","difficulty":"intermediate","explanation":"Tools like Babel and esbuild transpile files individually without understanding the full type system. `isolatedModules` flags code that would fail under single-file transpilation, such as `const enum` or `namespace` re-exports.","correctIndex":0},{"index":20,"options":["tsc --watch","tsc --project tsconfig.json --outDir dist","tsc --build","tsc --declaration --emitDeclarationOnly"],"question":"When using TypeScript Project References in a monorepo, which command should be used to build the project to ensure correct incremental builds and dependency resolution?","difficulty":"intermediate","explanation":"The `--build` (or `-b`) flag is specifically designed for Project References. It enables incremental builds and handles dependencies between referenced projects automatically, which standard `tsc` does not do.","correctIndex":2},{"index":21,"options":["TypeScript's `tsc` compiler does not rewrite import paths in the emitted JavaScript output.","Node.js requires the `TS_NODE_PATHS` environment variable to resolve aliases.","The `baseUrl` was not set correctly in `tsconfig.json`.","The `moduleResolution` setting is set to `node` instead of `classic`."],"question":"You configure path aliases in `tsconfig.json` using the `paths` option (e.g., `@/*` mapping to `src/*`). The code compiles without errors, but Node.js throws a 'Module not found' error at runtime. What is the most likely cause?","difficulty":"intermediate","explanation":"TypeScript's compiler leaves path aliases intact in the compiled JavaScript output. Node.js cannot resolve these aliases natively, so a runtime resolver (like `tsconfig-paths`) or a build-time path rewriter (like `tsc-alias`) must be used.","correctIndex":0},{"index":22,"options":["Convert the library's source code to TypeScript locally in `node_modules`.","Create a local `.d.ts` file, declare the module using `declare module 'my-lib'`, and add it to the `include` or `typeRoots` in `tsconfig.json`.","Add `// @ts-ignore` above every import of the library.","Set `noImplicitAny` to `false` in `tsconfig.json` to bypass the type errors."],"question":"You are using a JavaScript library that lacks built-in TypeScript types and does not have a `@types` package on DefinitelyTyped. What is the best practice to provide types for this library in your project?","difficulty":"intermediate","explanation":"Creating a local declaration file with `declare module` allows you to define types for untyped packages safely. This is the standard workflow for integrating untyped dependencies without suppressing errors globally.","correctIndex":1},{"index":23,"options":["The parser provides linting rules, while the plugin converts TypeScript source code into an AST.","The plugin handles rule configuration, while the parser executes the linting process.","The parser transpiles TypeScript to JavaScript, while the plugin runs the transpiled code.","The parser converts TypeScript source code into an AST that ESLint can understand, while the plugin provides linting rules specific to TypeScript."],"question":"When configuring ESLint for a TypeScript project, what are the distinct roles of `@typescript-eslint/parser` and `@typescript-eslint/eslint-plugin`?","difficulty":"intermediate","explanation":"The parser is responsible for converting TypeScript code into an Abstract Syntax Tree (AST) that ESLint can evaluate, while the plugin provides a set of linting rules specific to TypeScript features and best practices.","correctIndex":3}]},{"difficulty":"advanced","id":"mnnMndsjjZ","questionCount":25,"questions":[{"index":0,"options":["`false` and `true`","`true` and `false`","`boolean` and `boolean`","`boolean` and `false`"],"question":"Given the types `type Distributed = T extends string ? true : false` and `type NonDistributed = [T] extends [string] ? true : false`, what are the evaluated types of `Distributed` and `NonDistributed` respectively?","difficulty":"advanced","explanation":"Conditional types distributed over bare type parameters distribute across union constituents, yielding `true | false` (which is `boolean`). Wrapping the type parameter in a tuple prevents distribution, evaluating the union as a single entity against the constraint, which fails.","correctIndex":3},{"index":1,"options":["It widens the inferred type of the variable to match the target type, allowing for broader assignment.","It enables runtime type checking for the assigned value against the target type.","It allows the variable to be reassigned to any subtype of the target type without compiler errors.","It ensures the variable conforms to the target type while preserving the specific literal types of the assigned value."],"question":"What is the primary architectural benefit of using the `satisfies` operator over a type annotation (e.g., `const x: T = ...`) when declaring a variable?","difficulty":"advanced","explanation":"The `satisfies` operator guarantees that an expression matches a specific type without widening the expression's inferred type, preserving narrower literal types for downstream usage.","correctIndex":3},{"index":2,"options":["Interfaces are compiled to JavaScript prototype chains, whereas type aliases are compiled to plain objects.","Interfaces use nominal typing internally, bypassing the slower structural subtyping checks.","Interfaces support lazy evaluation and structural merging, whereas type intersections are eagerly expanded into flat structural types.","Interfaces are stripped at compile time, whereas type aliases are preserved in the AST."],"question":"When defining complex object shapes that might be extended later, using `interface` is generally preferred over `type` intersections for compiler performance. What internal mechanism makes `interface` more performant in these scenarios?","difficulty":"advanced","explanation":"Interfaces are merged and evaluated lazily by the compiler, whereas type intersections are eagerly expanded into flat structural representations, which can degrade performance for highly complex types.","correctIndex":2},{"index":3,"options":["Function type definitions within call signatures.","Constructor signatures in class definitions.","Arrow functions assigned to variables.","Method declarations inside object types."],"question":"Under `strictFunctionTypes`, function parameter types are correctly contravariant. However, there is a specific syntactic context where parameter bivariance is still permitted for practical compatibility. Which context is this?","difficulty":"advanced","explanation":"`strictFunctionTypes` enforces contravariance for function types written as property signatures, but method signatures in object types remain bivariant to maintain compatibility with built-in types like `Array`.","correctIndex":3},{"index":4,"options":["The property key becomes optional.","The property is assigned the `never` type.","The property is removed from the resulting object type.","The compiler throws a type error."],"question":"In a mapped type, what is the effect of using the `as` keyword to remap keys (e.g., `{ [K in keyof T as ...]: T[K] }`) when the remapping clause evaluates to `never`?","difficulty":"advanced","explanation":"When key remapping in a mapped type produces `never`, the property is completely filtered out from the resulting object type, allowing for type-safe key filtering.","correctIndex":2},{"index":5,"options":["{ value: string } | { value: number }","{ value: string | number }","never","{ value: string } & { value: number }"],"question":"Consider the following TypeScript code:\n```typescript\ntype Wrap = T extends unknown ? { value: T } : never;\ntype Result = Wrap;\n```\nWhat is the resulting type of `Result`?","difficulty":"advanced","explanation":"When a conditional type's checked type is a naked type parameter, it distributes over unions. `Wrap` distributes into `Wrap | Wrap`, yielding `{ value: string } | { value: number }`.","correctIndex":0},{"index":6,"options":["unknown","\"https://api.example.com\"","string","string | number"],"question":"```typescript\nconst config = {\n api: \"https://api.example.com\",\n timeout: 5000,\n} satisfies Record;\n```\nWhat is the type of `config.api` after this declaration?","difficulty":"advanced","explanation":"The `satisfies` operator validates the value conforms to the specified type while preserving the inferred literal types, so `config.api` retains its literal type rather than widening to `string`.","correctIndex":1},{"index":7,"options":["Yes, because `ClickHandler` is a subtype of `Handler`","No, because `strictFunctionTypes` disables all structural subtyping","Yes, because `{ type: \"click\"; payload: MouseEvent }` is a subtype of `{ type: string; payload: unknown }`","No, because function parameters are contravariant — assigning a `ClickHandler` to `Handler` would allow calling it with events it cannot safely handle"],"question":"```typescript\ntype Handler = (event: { type: string; payload: unknown }) => void;\ntype ClickHandler = (event: { type: \"click\"; payload: MouseEvent }) => void;\n\nconst click: ClickHandler = (event) => { /* ... */ };\nconst handler: Handler = click; // Line A\n```\nDoes Line A compile successfully under `strictFunctionTypes`?","difficulty":"advanced","explanation":"Under `strictFunctionTypes`, function parameter types are checked contravariantly. A `ClickHandler` cannot be assigned to `Handler` because `Handler` accepts a broader input type than `ClickHandler` can safely process.","correctIndex":3},{"index":8,"options":["string & number (reduces to `never`)","number","string | number","string"],"question":"```typescript\ntype InferBoth = T extends {\n a: (arg: infer U) => void;\n b: (arg: infer U) => void;\n} ? U : never;\n\ntype Result = InferBoth<{\n a: (arg: string) => void;\n b: (arg: number) => void;\n}>;\n```\nWhat is the resulting type of `Result`?","difficulty":"advanced","explanation":"When the same `infer` type variable appears in multiple contravariant positions (function parameters), TypeScript infers an intersection of the inferred types. `string & number` reduces to `never`.","correctIndex":0},{"index":9,"options":["Re-exporting a `const enum` member from another module","Using `as const` assertion on a variable declaration","Declaring an interface in a declaration file","Assigning a type alias to a generic interface"],"question":"Which of the following will produce a compiler error when `isolatedModules` is enabled?","difficulty":"advanced","explanation":"`isolatedModules` requires each file to be transpilable independently. Re-exporting `const enum` members from another module fails because the transpiler cannot inline the enum value without cross-file type information.","correctIndex":0},{"index":10,"options":["string | number","never","string & number","unknown"],"question":"Consider the following type:\n\ntype Merge = T extends { a: infer U; b: infer U } ? U : never;\ntype Result = Merge<{ a: string; b: number }>;\n\nWhat is the resulting type of `Result`?","difficulty":"advanced","explanation":"When the same `infer` type variable appears in multiple positions, TypeScript infers the intersection of all inferred types. Since `string & number` reduces to `never`, the result is `never`.","correctIndex":1},{"index":11,"options":["`satisfies` allows implicit `any` while type annotation does not","`satisfies` widens literal types while type annotation preserves them","There is no practical difference; they are interchangeable","`satisfies` validates the type without widening, preserving the inferred literal types for property access"],"question":"What is the key behavioral difference between using `satisfies` versus a type annotation when assigning an object literal?","difficulty":"advanced","explanation":"The `satisfies` operator validates that a value conforms to a type without replacing the inferred type, so property access retains narrower literal types rather than widening them to the annotation's broader type.","correctIndex":3},{"index":12,"options":["Type instantiation is excessively deep and possibly infinite","Maximum call stack size exceeded","Type 'any' is not assignable to type 'never'","Cannot find name"],"question":"TypeScript enforces a limit on recursive type instantiation depth to prevent infinite recursion in the type system. What specific error does it produce when this limit is exceeded?","difficulty":"advanced","explanation":"TypeScript detects excessively deep type instantiation and reports this specific diagnostic error, preventing runaway recursive type computation in the type checker.","correctIndex":0},{"index":13,"options":["Enums","Namespaces","Interfaces","Type aliases"],"question":"Which TypeScript construct does NOT support declaration merging?","difficulty":"advanced","explanation":"Type aliases cannot participate in declaration merging. Interfaces, namespaces, and enums all support some form of merging across declarations of the same name.","correctIndex":3},{"index":14,"options":["It ensures the type parameter can only receive const assertions","It allows TypeScript to infer literal types for the array elements without requiring `as const` at the call site","It prevents the generic parameter from being a union type","It makes the array elements readonly at runtime"],"question":"In TypeScript, what does the `const` modifier on a generic type parameter enable?\n\nfunction createRoutes(routes: T): T {\n return routes;\n}\nconst result = createRoutes([\"home\", \"about\", \"contact\"]);","difficulty":"advanced","explanation":"The `const` modifier on type parameters enables TypeScript to infer literal types (e.g., `\"home\"` instead of `string`) from mutable values at the call site, without requiring the caller to use `as const`.","correctIndex":1},{"index":15,"options":["Wrap the type parameter in a tuple: `[T] extends [unknown] ? T[] : never`","Change `unknown` to `any` in the conditional check","Wrap the result in an array: `T extends unknown ? [T[]] : never`","Add a generic constraint: `` to the type declaration"],"question":"A developer writes the following utility type expecting it to produce `(string | number)[]`:\n\n```typescript\ntype Wrap = T extends unknown ? T[] : never;\ntype Result = Wrap;\n```\n\nThe actual result is `string[] | number[]`. Which modification correctly produces `(string | number)[]`?","difficulty":"advanced","explanation":"Conditional types distribute over union types when the checked type is a naked type parameter. Wrapping T in a tuple prevents distribution, producing the desired `(string | number)[]`.","correctIndex":0},{"index":16,"options":["`const config = { theme: \"dark\", sizes: [1, 2, 3] } as Record;` — validates and preserves narrow types","`const config: Record = { theme: \"dark\" as const, sizes: [1, 2, 3] as const };` — validates and preserves narrow types","`const config = { theme: \"dark\", sizes: [1, 2, 3] } satisfies Record;` — validates and preserves narrow types","`const config: Record = { theme: \"dark\", sizes: [1, 2, 3] };` — validates and preserves narrow types"],"question":"A developer wants to validate that an object conforms to `Record` while preserving the narrowest inferred types for each property (e.g., keeping `sizes` as `number[]` rather than `string | number[]`). Which approach achieves both goals?","difficulty":"advanced","explanation":"The `satisfies` operator validates that an expression matches a type while preserving the narrower inferred type for each property, unlike type annotations which widen property types to the declared type.","correctIndex":2},{"index":17,"options":["`string | number` — multiple `infer U` bindings in the same conditional always infer a union of all matched types","`never` — `infer U` appears in contravariant positions (function parameters), so TypeScript infers the intersection `string & number`, which is `never`","`unknown` — conflicting `infer U` bindings from different positions resolve to `unknown`","`string` — TypeScript uses only the first `infer U` binding, scanning left to right"],"question":"What is the resulting type of `Result` in the following code, and why?\n\n```typescript\ntype ExtractParam = T extends { a: (x: infer U) => void; b: (x: infer U) => void } ? U : never;\ntype Result = ExtractParam<{ a: (x: string) => void; b: (x: number) => void }>;\n```","difficulty":"advanced","explanation":"When `infer` appears in multiple contravariant positions (like function parameters), TypeScript infers the intersection of all inferred types. Since `string & number` is `never`, the result is `never`.","correctIndex":1},{"index":18,"options":["The `opts` variable is inferred as type `Config`, so no excess properties exist in the second assignment","The second assignment produces a type error that is silently suppressed when `strictNullChecks` is disabled","Excess property checking is a special check that only applies when an object literal is directly assigned to a typed location, not when assigning a variable whose type was already inferred","TypeScript uses different compatibility rules: object literals must match exactly, while variables only need structural compatibility"],"question":"A developer is confused by the following behavior:\n\n```typescript\ninterface Config { debug: boolean; }\nconst c1: Config = { debug: true, verbose: true }; // Error\nconst opts = { debug: true, verbose: true };\nconst c2: Config = opts; // No error\n```\n\nWhich explanation is correct?","difficulty":"advanced","explanation":"Excess property checking is a targeted check applied only to object literals at their assignment point. Variables with inferred types are subject to normal structural compatibility, which allows excess properties.","correctIndex":2},{"index":19,"options":["Replace the utility type with `Readonly` and add `as const` assertions at each property level","Use `any` as the return type for the recursive branch and cast at call sites","Use a depth-limited recursive pattern with a counter type parameter that decrements on each recursion, providing a base case to terminate","Add `\"skipLibCheck\": true` to tsconfig.json to bypass deep type checking"],"question":"A library author creates a recursive utility type that causes \"Type instantiation is excessively deep and possibly infinite\" errors for deeply nested input types:\n\n```typescript\ntype DeepReadonly = {\n readonly [K in keyof T]: T[K] extends object ? DeepReadonly : T[K];\n};\n```\n\nWhich approach is the recommended way to handle this?","difficulty":"advanced","explanation":"A depth counter pattern (e.g., ``) with a base case when depth reaches 0 prevents infinite recursion and resolves the instantiation depth error while preserving type safety.","correctIndex":2},{"index":20,"options":["The referenced project must set 'outDir' to a directory within node_modules for resolution","The referenced project must have 'declaration: true' so that type definitions are emitted for downstream consumers","The referenced project must use 'moduleResolution: node16' or 'nodenext'","The referenced project must set 'noEmit: true' to avoid conflicting output files"],"question":"When using TypeScript project references with 'composite: true', which configuration constraint is required for the referenced project to enable proper incremental builds?","difficulty":"advanced","explanation":"Composite projects require declaration: true so that .d.ts files are generated, enabling downstream projects to resolve types without rechecking the referenced project's source.","correctIndex":1},{"index":21,"options":["They are deeply merged with parent values, preserving both parent and child entries","They completely override the parent values; child arrays replace parent arrays entirely","They are merged only if the child configuration omits 'compilerOptions'","Only 'include' merges with parent values, while 'exclude' and 'files' override"],"question":"When a tsconfig.json extends another configuration, how are top-level array properties such as 'include', 'exclude', and 'files' handled during configuration merging?","difficulty":"advanced","explanation":"When extending a tsconfig, array properties like include, exclude, and files are replaced entirely by the child's values rather than merged, which is a common source of misconfiguration.","correctIndex":1},{"index":22,"options":["TypeScript automatically rewrites path aliases in emitted JavaScript, requiring no additional configuration","The 'baseUrl' must be set to 'node_modules' for path aliases to resolve correctly at runtime","Bundlers or build tools must be configured to resolve the same path aliases since tsc emits them unchanged in JavaScript output","Path aliases are resolved at runtime by the Node.js module system when 'moduleResolution' is set to 'node'"],"question":"When using the 'paths' option in tsconfig.json for module aliasing, what critical limitation must be addressed in the build pipeline for production output?","difficulty":"advanced","explanation":"TypeScript's paths option only affects type resolution during compilation; emitted JavaScript retains the original alias strings, requiring bundlers like webpack or tools like tsc-alias to rewrite them.","correctIndex":2},{"index":23,"options":["It tracks which files have been linted to skip ESLint processing in subsequent runs","It stores the compiled JavaScript output to skip future transpilation of unchanged files","It caches dependency graphs, file hashes, and type-checking state to enable faster subsequent compilations","It contains source maps and breakpoint metadata for debugging incremental builds"],"question":"What is the primary purpose and content of the .tsbuildinfo file generated when 'incremental' or 'composite' is enabled in tsconfig.json?","difficulty":"advanced","explanation":"The .tsbuildinfo file serializes TypeScript's internal incremental state including file hashes and dependency relationships, allowing the compiler to skip rechecking unchanged files.","correctIndex":2},{"index":24,"options":["esbuild and SWC do not support 'target' options below ES2015","esbuild and SWC require a separate tsconfig.json per entry point file","esbuild and SWC cannot process .tsx files containing JSX syntax","esbuild and SWC do not perform const enum inlining or type-only import elision as tsc does"],"question":"When using esbuild or SWC for TypeScript transpilation instead of tsc, which behavioral difference is most likely to cause runtime errors in existing TypeScript code?","difficulty":"advanced","explanation":"Unlike tsc, esbuild and SWC strip types syntactically without understanding TypeScript semantics, so const enums are not inlined and type-only imports are not elided, potentially causing runtime failures.","correctIndex":3}]}]}

TypeScript Quiz

Pick your level

Beginner

Intermediate

Advanced