TypeScript MCQ

What is TypeScript primarily known as?

Which file extension is used for TypeScript files?

Which command compiles a TypeScript file to JavaScript using the TypeScript compiler?

How do you declare a variable named age of type number in TypeScript?

Which type represents a value that can be any type and disables type checking?

What does the "void" return type indicate for a function?

How do you define an array of strings in TypeScript?

What keyword is used to define a custom type alias?

Which symbol marks a property as optional in an interface?

What is the purpose of an interface in TypeScript?

Which of these is a valid TypeScript union type declaration?

What does the "readonly" modifier do to a property?

Which TypeScript feature allows enumerating a fixed set of named constants?

What is the default value of the first member in a numeric enum?

How do you annotate a function parameter "name" as a string?

Which configuration file is used to configure the TypeScript compiler options for a project?

What does the "never" type represent?

How do you specify that a function parameter is optional?

Which keyword is used to implement an interface in a class?

What is the correct syntax to create a tuple of a string and a number?

What does the "as" keyword do in TypeScript?

Which built-in utility type makes all properties of a type optional?

What is the output type of "typeof" used in a type context, e.g. "type T = typeof someVar"?

Which symbol is used for non-null assertion in TypeScript?

How do you define a constant variable in TypeScript that cannot be reassigned?

What does "strict mode" in tsconfig.json enable?

Which of the following correctly defines a function type?

What is "type inference" in TypeScript?

Which access modifier makes a class member accessible only within the class itself?

What is the default access modifier for class members in TypeScript if none is specified?

How do you represent a value that could be either a string or null?

What does "npx tsc --init" do?

Which of these is a primitive type in TypeScript?

How do you import a named export "add" from a module "math.ts"?

What is the purpose of the "export" keyword?

Which TypeScript feature lets you create a new type by extending an existing interface?

What does the double equals (==) versus triple equals (===) distinction inherited from JavaScript mean in TypeScript?

How do you define a class property with a default value in TypeScript?

Which loop syntax iterates over the values of an array in TypeScript?

What is the result type of "5 as const" assigned to a variable?

What is a generic function in TypeScript?

What does the "keyof" operator produce?

Given "interface Point { x: number; y: number; }", what is the type of "keyof Point"?

What is the purpose of mapped types like "{ [K in keyof T]: boolean }"?

What does the utility type "Pick<T, K>" do?

What does the utility type "Omit<T, K>" do?

What is a discriminated union in TypeScript?

What does "strictNullChecks" do when enabled?

What is the difference between an "interface" and a "type" alias for object shapes?

What does the following do? "function isString(val: unknown): val is string { return typeof val === 'string'; }"

What does "Record<K, V>" represent?

What is the effect of declaring a class constructor parameter as "private readonly name: string"?

What does the "satisfies" operator (introduced in TS 4.9) do?

What is the purpose of "declare" in a .d.ts file?

How does TypeScript handle excess property checks for object literals?

What does "Partial<Required<T>>" effectively do for an interface T with optional and required properties?

What is the result of widening for "let x = 'hello';" versus "const y = 'hello';"?

What does the conditional type "T extends U ? X : Y" do?

What is the purpose of the "infer" keyword in conditional types?

What does "ReturnType<typeof myFunc>" give you?

How do generic constraints work, e.g. "function logLength<T extends { length: number }>(arg: T)"?

What is the difference between "unknown" and "any"?

What does declaration merging allow for namespaces and interfaces with the same name?

What is an abstract class used for in TypeScript?

What does the "in" operator do as a type guard, e.g. "if ('swim' in animal)"?

What is the purpose of generics default type parameters, e.g. "interface Box<T = string>"?

How does TypeScript's structural typing differ from nominal typing?

What does "Exclude<T, U>" do?

What is "module augmentation" used for?

What is the effect of "noImplicitAny" compiler option?

What does the spread operator do when used with TypeScript tuples, e.g. "type T = [number, ...string[]]"?

What is the purpose of function overloads in TypeScript?

How does TypeScript treat enums with string values, e.g. "enum Color { Red = 'RED', Blue = 'BLUE' }"?

What does "this" parameter typing, e.g. "function fn(this: HTMLElement, event: Event)", accomplish?

What does the "Awaited<T>" utility type do?

When using "import type { Foo } from './module'", what is the effect?

What does "Array.isArray(value)" help with when narrowing a union type like "string | string[]"?

What is the difference between "interface A extends B" and "type A = B & C"?

What does the "as const" assertion do when applied to an array literal, e.g. "const arr = [1, 2, 3] as const"?

What is the benefit of using "unknown" as the type for a caught error in a try/catch block, e.g. "catch (err: unknown)"?

What is the difference between covariance and contravariance in TypeScript function parameter typing?

What does the following recursive conditional type compute? "type Flatten<T> = T extends Array<infer Item> ? Flatten<Item> : T"

What is a "branded type" (or nominal typing emulation) pattern used for?

Given "type DeepReadonly<T> = { readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K] }", what does this mapped type achieve?

What is the purpose of template literal types, e.g. "type Greeting = `Hello, ${string}!`"?

What does "distributive conditional types" mean for "type ToArray<T> = T extends any ? T[] : never" when T is a union like "string | number"?

What is the role of "asserts" in a function signature like "function assertIsString(val: unknown): asserts val is string"?

How do variadic tuple types, e.g. "type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]", behave?

What does the TypeScript compiler do differently with "const enum" compared to a regular "enum"?

What does the "--isolatedModules" compiler flag warn against?

How does TypeScript resolve overload resolution order when multiple overload signatures could match a call?

What is the effect of "exactOptionalPropertyTypes" compiler option?

What does the "this" type (polymorphic this) returned from a method enable in a fluent/chainable API?

What is the purpose of "Function" overload combined with generic inference for a curried function, e.g. "function curry<A, B, C>(fn: (a: A, b: B) => C): (a: A) => (b: B) => C"?

How does TypeScript handle circular type references, e.g. "type Json = string | number | boolean | null | Json[] | { [key: string]: Json }"?

What does the "--strictPropertyInitialization" flag enforce for class properties?

What is the difference between "Function" type and a specific function signature like "(a: number) => void" for type safety?

What does the utility type combination "type Mutable<T> = { -readonly [K in keyof T]: T[K] }" do with the "-readonly" modifier?

In TypeScript's control flow analysis, what does "Object.freeze(obj)" do to the inferred type of obj's properties when obj is a literal?

What is "type narrowing via assignment" and how does control flow analysis use it, e.g. "let x: string | number = getValue(); x = 5;"?