TypeScript MCQ

Explanation

TypeScript is a strict syntactical superset of JavaScript that adds optional static types, compiled down to plain JavaScript.

Explanation

TypeScript source files use the .ts extension; .tsx is used for files containing JSX syntax.

Explanation

The TypeScript compiler command "tsc" compiles .ts files into .js files.

Explanation

TypeScript uses a colon followed by the type after the variable name to annotate types.

Explanation

The "any" type opts out of type checking, allowing a value to be of any type without errors.

Explanation

void is used for functions that do not return a value, meaning their return value should not be used.

Explanation

TypeScript supports both string[] and the generic Array<string> syntax to describe arrays of strings.

Explanation

The "type" keyword creates a type alias, e.g. "type ID = number | string;".

Explanation

Appending "?" after a property name, like "name?: string", makes that property optional.

Explanation

Interfaces describe the structure (shape) that an object must conform to, purely for compile-time type checking.

Explanation

The pipe symbol "|" is used to declare a union type, meaning the variable can hold either type.

Explanation

readonly prevents a property from being reassigned after its initial assignment, enforced at compile time.

Explanation

enum defines a set of named constants, e.g. "enum Direction { Up, Down, Left, Right }".

Explanation

By default, numeric enums start numbering their members from 0 unless a different value is specified.

Explanation

Parameter type annotations use a colon followed by the type, placed after the parameter name.

Explanation

tsconfig.json specifies the root files and compiler options required to compile a TypeScript project.

Explanation

never represents values that never occur, commonly used as the return type of functions that always throw or never finish.

Explanation

A "?" placed after the parameter name marks it as optional, allowing the argument to be omitted.

Explanation

The "implements" keyword is used by a class to guarantee it conforms to a given interface.

Explanation

Tuples in TypeScript are written using square brackets with each element type in order, e.g. [string, number].

Explanation

Type assertions like "value as string" tell the compiler to treat a value as a specified type without changing runtime behavior.

Explanation

Partial<T> constructs a type with all properties of T set to optional.

Explanation

In a type context, typeof extracts the static type of a value, useful for deriving types from variables.

Explanation

The "!" postfix operator asserts that a value is not null or undefined, e.g. "value!.length".

Explanation

TypeScript uses JavaScript's "const" keyword to declare block-scoped constants that cannot be reassigned.

Explanation

"strict": true enables a wide range of stricter type-checking options, such as strictNullChecks and noImplicitAny.

Explanation

Function types are written as parameter list followed by "=>" and the return type, e.g. (a: number, b: number) => number.

Explanation

Type inference allows TypeScript to automatically deduce types from assigned values without explicit annotations.

Explanation

private restricts access to the declaring class only; it is not accessible from subclasses or outside code.

Explanation

If no access modifier is written, TypeScript class members default to public.

Explanation

A union type "string | null" allows the variable to hold either a string value or null.

Explanation

"tsc --init" creates a tsconfig.json file with default compiler options in the current directory.

Explanation

boolean, along with string, number, null, undefined, symbol, and bigint, are TypeScript primitive types.

Explanation

Named exports are imported using curly braces, e.g. "import { add } from './math';".

Explanation

export makes declarations accessible from other files via import statements.

Explanation

An interface can use "extends" to inherit members from one or more other interfaces.

Explanation

TypeScript inherits JavaScript equality operators: === is strict (no coercion), while == coerces operands before comparing.

Explanation

Class properties can have type annotations and default values assigned directly with "=".

Explanation

"for...of" iterates over the values of an iterable like an array, while "for...in" iterates over keys/indices.

Explanation

Using "as const" narrows the type to the literal value 5 instead of the broader "number" type.

Explanation

Generics, e.g. "function identity<T>(arg: T): T", allow functions to operate on multiple types while keeping type safety.

Explanation

keyof T produces a union type of all the property names (string literal types) of T.

Explanation

keyof Point evaluates to the union of the property name string literals: "x" | "y".

Explanation

Mapped types iterate over the keys of an existing type to produce a new type with transformed property types.

Explanation

Pick<T, K> selects a subset of properties K from type T to form a new type.

Explanation

Omit<T, K> constructs a type by taking all properties of T and removing those listed in K.

Explanation

Discriminated unions use a shared literal "tag" property (e.g. kind: "circle" | "square") that lets TypeScript narrow the union in conditionals.

Explanation

With strictNullChecks, null and undefined have their own types and must be explicitly included in a type's union to be valid.

Explanation

Interfaces support declaration merging (multiple declarations combine), whereas a type alias with the same name causes a duplicate identifier error.

Explanation

The "val is string" return type is a user-defined type guard, narrowing the type of val within branches where the function returns true.

Explanation

Record<K, V> constructs an object type with keys of type K and values of type V, e.g. Record<string, number>.

Explanation

Parameter properties combine declaration and assignment: the modifier automatically creates and initializes a class member of the same name.

Explanation

satisfies checks that a value conforms to a type while preserving the more specific inferred type, unlike a type annotation which widens it.

Explanation

declare is used in ambient declaration files to describe types for code that exists elsewhere (e.g. a JS library) without generating output.

Explanation

When an object literal is assigned directly to a typed variable or parameter, TypeScript errors on properties not present in the target type.

Explanation

Utility types compose: Required<T> makes everything required, then Partial<> wraps that result to make all properties optional.

Explanation

Mutable bindings (let/var) widen literal types to their general primitive type, while const preserves the literal type since it cannot change.

Explanation

Conditional types let you choose between two types based on a type-level assignability check, similar to a ternary at the type level.

Explanation

infer introduces a placeholder type variable that TypeScript fills in by inferring it from the matched type, commonly used to extract return types or array element types.

Explanation

ReturnType<T> is a utility type that extracts the return type of a function type T.

Explanation

The "extends" clause in a generic constraint limits which types can be passed in, ensuring they have the required shape.

Explanation

unknown is a type-safe counterpart to any: you must narrow or assert its type before using it, preventing accidental unsafe operations.

Explanation

TypeScript merges multiple declarations of the same interface (or compatible namespace/interface pairs) into one combined definition.

Explanation

Abstract classes serve as base classes that cannot be instantiated; abstract methods declared in them must be implemented by derived classes.

Explanation

The "in" operator type guard narrows a union type by checking whether a specific property exists on the object at runtime.

Explanation

Default type parameters provide a fallback type used when the generic is referenced without an explicit type argument.

Explanation

TypeScript uses structural typing: two types are compatible if their members match, even if their declared names differ.

Explanation

Exclude<T, U> filters out members of union T that are assignable to U, leaving the remaining union members.

Explanation

Module augmentation lets you declare additional members for an existing module, often used to extend types from external libraries.

Explanation

noImplicitAny forces explicit typing wherever TypeScript would otherwise fall back to the implicit "any" type, improving type safety.

Explanation

Rest elements in tuple types allow a fixed prefix followed by a variable number of elements of a specified type.

Explanation

Overload signatures let a single function be called in multiple type-safe ways; the implementation signature is not visible to callers.

Explanation

Unlike numeric enums, string enum members must each have a literal string value explicitly assigned; there is no auto-incrementing.

Explanation

A "this" parameter is a fake parameter used only by the type checker to ensure the function is called with the correct context; it is erased in compiled output.

Explanation

Awaited<T> models the type returned by awaiting a Promise, recursively unwrapping nested Promises.

Explanation

"import type" ensures the import is purely for types and is completely removed during compilation, avoiding unnecessary runtime imports.

Explanation

Array.isArray is recognized by TypeScript as a type guard, narrowing the checked value to an array type inside the conditional branch.

Explanation

Interface inheritance via extends and type intersection via & both combine multiple shapes into one, though they have different merging semantics for conflicting members.

Explanation

"as const" on an array literal produces a readonly tuple type with literal element types (readonly [1, 2, 3]) rather than the wider number[].

Explanation

Since TypeScript 4.4, catch clause variables can be typed as unknown, which is safer than any because it requires explicit narrowing (e.g. checking "instanceof Error") before use.

Explanation

TypeScript normally checks function parameters bivariantly for methods, but the strictFunctionTypes flag enforces sound contravariant checking for function type variables (not methods).

Explanation

This recursive conditional type repeatedly applies itself to the inferred array element type, effectively flattening nested array types down to the base element type.

Explanation

Branded types add an unused "tag" property (e.g. "& { __brand: 'UserId' }") so that otherwise structurally identical types like UserId and number are not assignable to each other.

Explanation

This recursive mapped type applies readonly to every property and recurses into nested object types, producing a deeply immutable type.

Explanation

Template literal types build new string literal types by combining literals with other types (often unions), useful for things like CSS property names or event names.

Explanation

Conditional types with a naked type parameter distribute over union types, applying the conditional to each constituent separately and unioning the results.

Explanation

Assertion functions use "asserts" to tell the type checker that if the function returns normally (doesn't throw), the asserted condition holds for the rest of the scope.

Explanation

Variadic tuple types support spread elements with generic tuple types, allowing type-level operations like concatenating or manipulating tuples generically.

Explanation

const enums are completely erased during compilation; their member values are inlined directly at usage sites, avoiding the runtime object generated for regular enums.

Explanation

isolatedModules ensures every file can be safely transpiled in isolation (as tools like Babel or esbuild do), flagging things like non-type re-exports of types that require whole-program type information.

Explanation

TypeScript checks overload signatures in the order they are written and uses the first one that matches, so specific overloads must precede more general ones.

Explanation

With exactOptionalPropertyTypes, "prop?: string" means the property can be omitted entirely but cannot be explicitly assigned the value undefined unless "| undefined" is included in the type.

Explanation

The polymorphic "this" type lets methods like "set()" in a builder pattern return the specific subclass type, preserving type information through chained calls on subclasses.

Explanation

Generic higher-order function types like this preserve the relationships between argument and return types across the curried chain, so each returned function remains fully typed.

Explanation

TypeScript allows recursive type aliases as long as the recursive reference occurs within an object or array type (not directly in a union at the top level in a way that creates infinite expansion), enabling structures like JSON types.

Explanation

strictPropertyInitialization ensures that every declared instance property is either assigned in the constructor, given a default, marked with "!" (definite assignment assertion), or its type explicitly allows undefined.

Explanation

The generic "Function" type accepts any callable but provides no information about parameters or return values, making it far less type-safe than a precise function type.

Explanation

Mapped type modifiers can be prefixed with "-" to remove them; "-readonly" strips the readonly modifier from every property, yielding a fully mutable version of T.

Explanation

The standard lib typing for Object.freeze returns "Readonly<T>", so TypeScript treats the frozen object's properties as readonly going forward.

Explanation

TypeScript's control flow analysis tracks the type of a variable through assignments, narrowing it to the type of the most recently assigned value within the reachable code path.