Typescript Essentials Practice Exam

Question 1 Typescript Essentials

What is the 'unknown' type?

Constructors initialize instances: constructor(private name: string) { }. Parameters can be auto-promoted to properties with access modifiers. Interfaces describe object shapes: interface Person { name: string; age: number; }. They are used for type checking objects without runtime overhead. unknown is a top type like any but safer, requiring type checks or narrowing before use. It ensures type safety by preventing direct operations on unknown values. Mapped types transform keys: type Readonly<T> = { readonly [P in keyof T]: T[P]; };. Utility types like Partial, Pick are built on this.

Question 2 Typescript Essentials

How do you type an array?

The in keyword iterates keys in mapped types: { [P in keyof T]: T[P] }. Essential for transforming all or subset of properties. Use extends: interface Employee extends Person { role: string; }. It inherits all members from the base interface. Use array syntax like let numbers: number[] = [1, 2, 3]; or generic Array<number>. Arrays can hold homogeneous or heterogeneous types with tuples. Template literals create string literal unions: type Event = `on${'click' | 'hover'}`; // "onclick" | "onhover". Useful for string manipulation at type level.

Question 3 Typescript Essentials

How does TypeScript relate to JavaScript?

Use array syntax like let numbers: number[] = [1, 2, 3]; or generic Array<number>. Arrays can hold homogeneous or heterogeneous types with tuples. Default parameters provide fallback values: function greet(name: string, greeting: string = "Hi"): string. They are optional and don't require ?. Install TypeScript globally using npm install -g typescript or locally as a dev dependency with npm install typescript --save-dev. Verify installation with tsc --version. TypeScript is a superset of JavaScript, meaning all valid JavaScript code is also valid TypeScript. TypeScript code is transpiled to JavaScript, allowing it to run in any JavaScript environment.

Question 4 Typescript Essentials

What are namespaces?

TypeScript is a statically typed superset of JavaScript developed by Microsoft that compiles to plain JavaScript code. It adds optional static typing, interfaces, classes, and modules to enhance code scalability, maintainability, and developer productivity. unknown is a top type like any but safer, requiring type checks or narrowing before use. It ensures type safety by preventing direct operations on unknown values. Namespaces group related code: namespace Utils { export function helper() { } }. Used for avoiding global pollution pre-modules, now less common. Set "target": "ES2020" in tsconfig.json to specify output JavaScript version. Common options: ES5, ES2015, ESNext.

Question 5 Typescript Essentials

What are getters and setters?

Getters/setters control property access: get name(): string { return this._name; } set name(value: string) { this._name = value; }. They act like properties but add logic. readonly prevents assignment after initialization: interface Point { readonly x: number; y: number; }. Ideal for immutable data. Mapped types transform keys: type Readonly<T> = { readonly [P in keyof T]: T[P]; };. Utility types like Partial, Pick are built on this. Discriminated unions use a common literal discriminant: type Shape = { kind: 'circle'; r: number } | { kind: 'square'; side: number };. Switch on discriminant for exhaustive checks.

Question 6 Typescript Essentials

What are generic interfaces?

Interfaces describe object shapes: interface Person { name: string; age: number; }. They are used for type checking objects without runtime overhead. Discriminated unions use a common literal discriminant: type Shape = { kind: 'circle'; r: number } | { kind: 'square'; side: number };. Switch on discriminant for exhaustive checks. interface Box<T> { contents: T; }. Allows interfaces to work with any type while preserving type information. Use extends: function longest<T extends { length: number }>(a: T, b: T): T. Ensures type parameters have required properties.

Question 7 Typescript Essentials

What are access modifiers?

Built-in utilities include Partial<T> (all optional), Required<T> (all required), Pick<T, K> (select keys), Omit<T, K> (exclude keys). They simplify common transformations. public (default) allows access everywhere, private only within class, protected within class and subclasses. They enforce encapsulation at compile-time. Conditional types use ternary: type NonNullable<T> = T extends null | undefined ? never : T;. Infer types based on conditions for advanced utilities. interface Box<T> { contents: T; }. Allows interfaces to work with any type while preserving type information.

Question 8 Typescript Essentials

What are enums?

Enums define named constants: enum Color { Red, Green, Blue }. They can be numeric (default) or string-based, improving code readability for related values. public (default) allows access everywhere, private only within class, protected within class and subclasses. They enforce encapsulation at compile-time. Type guards narrow types in conditionals: function isString(value: any): value is string { return typeof value === 'string'; }. Enables safe access to narrowed properties. Index signatures allow dynamic keys: interface StringDict { [key: string]: string; }. Useful for objects with string keys of unknown names.

Question 9 Typescript Essentials

What are generics?

Interfaces are for object shapes and support declaration merging; type aliases handle unions, intersections, and primitives. Use interfaces for OOP-style contracts, types for complex utilities. Conditional types use ternary: type NonNullable<T> = T extends null | undefined ? never : T;. Infer types based on conditions for advanced utilities. Generics parameterize types: function identity<T>(arg: T): T { return arg; }. They enable reusable, type-safe components like Array<T>. Use export function func() { } for named or export default class Class { } for default. Re-export with export { something } from './other';.

Question 10 Typescript Essentials

What are tuples in TypeScript?

Use extends: interface Employee extends Person { role: string; }. It inherits all members from the base interface. Conditional types use ternary: type NonNullable<T> = T extends null | undefined ? never : T;. Infer types based on conditions for advanced utilities. class Stack<T> { push(item: T): void { } pop(): T | undefined { } }. Classes can be generic for type-safe data structures. Tuples are fixed-length arrays with specific types per position: let tuple: [string, number] = ["age", 30];. They enforce length and type order unlike regular arrays.

Question 11 Typescript Essentials

What is type inference in TypeScript?

Template literals create string literal unions: type Event = `on${'click' | 'hover'}`; // "onclick" | "onhover". Useful for string manipulation at type level. TypeScript automatically infers the type of a variable from its initializer. For example, let count = 5; infers number, reducing boilerplate while maintaining type safety. The never type represents values that never occur, such as exhaustive switch statements or impossible code paths. It is useful for function return types that always throw errors. Abstract classes can't be instantiated and may have abstract methods: abstract class Shape { abstract area(): number; }. Used as base for concrete subclasses.

Question 12 Typescript Essentials

What is the 'never' type?

Use array syntax like let numbers: number[] = [1, 2, 3]; or generic Array<number>. Arrays can hold homogeneous or heterogeneous types with tuples. The never type represents values that never occur, such as exhaustive switch statements or impossible code paths. It is useful for function return types that always throw errors. Primitive types include number, string, boolean, null, undefined, symbol, and bigint. They are the basic building blocks for typing variables. Union types allow multiple types: let id: string | number;. Values must be compatible with at least one type in the union.

Question 13 Typescript Essentials

What does 'in' do in mapped types?

Set "target": "ES2020" in tsconfig.json to specify output JavaScript version. Common options: ES5, ES2015, ESNext. class Stack<T> { push(item: T): void { } pop(): T | undefined { } }. Classes can be generic for type-safe data structures. Install TypeScript globally using npm install -g typescript or locally as a dev dependency with npm install typescript --save-dev. Verify installation with tsc --version. The in keyword iterates keys in mapped types: { [P in keyof T]: T[P] }. Essential for transforming all or subset of properties.

Question 14 Typescript Essentials

How do you export from a module?

Namespaces group related code: namespace Utils { export function helper() { } }. Used for avoiding global pollution pre-modules, now less common. Getters/setters control property access: get name(): string { return this._name; } set name(value: string) { this._name = value; }. They act like properties but add logic. Use export function func() { } for named or export default class Class { } for default. Re-export with export { something } from './other';. Specify types after parameters and before function body: function add(a: number, b: number): number { return a + b; }. Arrow functions use similar syntax.

Question 15 Typescript Essentials

What is the TypeScript compiler command?

Specify types after parameters and before function body: function add(a: number, b: number): number { return a + b; }. Arrow functions use similar syntax. The TypeScript compiler is invoked with tsc. Use tsc file.ts to compile a single file or tsc to compile based on tsconfig.json. .d.ts files provide type definitions for JavaScript libraries: declare function jQuery(): void;. Installed via @types packages like npm install @types/node. Index signatures allow dynamic keys: interface StringDict { [key: string]: string; }. Useful for objects with string keys of unknown names.

Question 16 Typescript Essentials

What are default parameters?

TypeScript is a superset of JavaScript, meaning all valid JavaScript code is also valid TypeScript. TypeScript code is transpiled to JavaScript, allowing it to run in any JavaScript environment. Built-in utilities include Partial<T> (all optional), Required<T> (all required), Pick<T, K> (select keys), Omit<T, K> (exclude keys). They simplify common transformations. Type assertion tells the compiler to treat a value as a specific type using as: let value = "5" as number; or angle-bracket syntax. Use cautiously to avoid runtime errors. Default parameters provide fallback values: function greet(name: string, greeting: string = "Hi"): string. They are optional and don't require ?.

Question 17 Typescript Essentials

What is 'keyof' operator?

public (default) allows access everywhere, private only within class, protected within class and subclasses. They enforce encapsulation at compile-time. The keyof operator yields union of property keys: keyof Person // "name" | "age". Used in mapped and conditional types. Default parameters provide fallback values: function greet(name: string, greeting: string = "Hi"): string. They are optional and don't require ?. Index signatures allow dynamic keys: interface StringDict { [key: string]: string; }. Useful for objects with string keys of unknown names.

Question 18 Typescript Essentials

What are conditional types?

Conditional types use ternary: type NonNullable<T> = T extends null | undefined ? never : T;. Infer types based on conditions for advanced utilities. class Stack<T> { push(item: T): void { } pop(): T | undefined { } }. Classes can be generic for type-safe data structures. The TypeScript compiler is invoked with tsc. Use tsc file.ts to compile a single file or tsc to compile based on tsconfig.json. Index signatures allow dynamic keys: interface StringDict { [key: string]: string; }. Useful for objects with string keys of unknown names.

Question 19 Typescript Essentials

What are readonly properties?

.d.ts files provide type definitions for JavaScript libraries: declare function jQuery(): void;. Installed via @types packages like npm install @types/node. Use export function func() { } for named or export default class Class { } for default. Re-export with export { something } from './other';. readonly prevents assignment after initialization: interface Point { readonly x: number; y: number; }. Ideal for immutable data. Use import { ModuleName } from './module'; for named exports or import * as Module from './module'; for namespace imports. Supports ES6 and CommonJS.

Question 20 Typescript Essentials

How do you define an interface?

Getters/setters control property access: get name(): string { return this._name; } set name(value: string) { this._name = value; }. They act like properties but add logic. Interfaces describe object shapes: interface Person { name: string; age: number; }. They are used for type checking objects without runtime overhead. Namespaces group related code: namespace Utils { export function helper() { } }. Used for avoiding global pollution pre-modules, now less common. The any type disables type checking, allowing a value to be treated as any type. It should be used sparingly as it bypasses TypeScript's benefits; prefer unknown for safer alternatives.

Question 21 Typescript Essentials

What is 'noImplicitAny'?

Constructors initialize instances: constructor(private name: string) { }. Parameters can be auto-promoted to properties with access modifiers. Generics parameterize types: function identity<T>(arg: T): T { return arg; }. They enable reusable, type-safe components like Array<T>. The never type represents values that never occur, such as exhaustive switch statements or impossible code paths. It is useful for function return types that always throw errors. "noImplicitAny": true errors on inferred any types, forcing explicit annotations. Promotes type safety by avoiding implicit type escapes.

Question 22 Typescript Essentials

What are generic classes?

Template literals create string literal unions: type Event = `on${'click' | 'hover'}`; // "onclick" | "onhover". Useful for string manipulation at type level. class Stack<T> { push(item: T): void { } pop(): T | undefined { } }. Classes can be generic for type-safe data structures. Intersection types combine types: type Admin = User & { permissions: string[]; };. The resulting type requires all properties from intersected types. Enums define named constants: enum Color { Red, Green, Blue }. They can be numeric (default) or string-based, improving code readability for related values.

Question 23 Typescript Essentials

What are abstract classes?

Abstract classes can't be instantiated and may have abstract methods: abstract class Shape { abstract area(): number; }. Used as base for concrete subclasses. The TypeScript compiler is invoked with tsc. Use tsc file.ts to compile a single file or tsc to compile based on tsconfig.json. Union types allow multiple types: let id: string | number;. Values must be compatible with at least one type in the union. public (default) allows access everywhere, private only within class, protected within class and subclasses. They enforce encapsulation at compile-time.

Question 24 Typescript Essentials

What is an index signature?

TypeScript is a statically typed superset of JavaScript developed by Microsoft that compiles to plain JavaScript code. It adds optional static typing, interfaces, classes, and modules to enhance code scalability, maintainability, and developer productivity. Install TypeScript globally using npm install -g typescript or locally as a dev dependency with npm install typescript --save-dev. Verify installation with tsc --version. The any type disables type checking, allowing a value to be treated as any type. It should be used sparingly as it bypasses TypeScript's benefits; prefer unknown for safer alternatives. Index signatures allow dynamic keys: interface StringDict { [key: string]: string; }. Useful for objects with string keys of unknown names.

Question 25 Typescript Essentials

What are type guards?

The keyof operator yields union of property keys: keyof Person // "name" | "age". Used in mapped and conditional types. TypeScript automatically infers the type of a variable from its initializer. For example, let count = 5; infers number, reducing boilerplate while maintaining type safety. The "strict": true option enables all strict type-checking options like strictNullChecks. Recommended for new projects to catch more errors. Type guards narrow types in conditionals: function isString(value: any): value is string { return typeof value === 'string'; }. Enables safe access to narrowed properties.

Question 26 Typescript Essentials

What are utility types?

Union types allow multiple types: let id: string | number;. Values must be compatible with at least one type in the union. The in keyword iterates keys in mapped types: { [P in keyof T]: T[P] }. Essential for transforming all or subset of properties. The keyof operator yields union of property keys: keyof Person // "name" | "age". Used in mapped and conditional types. Built-in utilities include Partial<T> (all optional), Required<T> (all required), Pick<T, K> (select keys), Omit<T, K> (exclude keys). They simplify common transformations.

Question 27 Typescript Essentials

What are intersection types?

Intersection types combine types: type Admin = User & { permissions: string[]; };. The resulting type requires all properties from intersected types. Primitive types include number, string, boolean, null, undefined, symbol, and bigint. They are the basic building blocks for typing variables. Type assertion tells the compiler to treat a value as a specific type using as: let value = "5" as number; or angle-bracket syntax. Use cautiously to avoid runtime errors. Interfaces are for object shapes and support declaration merging; type aliases handle unions, intersections, and primitives. Use interfaces for OOP-style contracts, types for complex utilities.

Question 28 Typescript Essentials

What is the difference between interfaces and types?

Use array syntax like let numbers: number[] = [1, 2, 3]; or generic Array<number>. Arrays can hold homogeneous or heterogeneous types with tuples. Interfaces are for object shapes and support declaration merging; type aliases handle unions, intersections, and primitives. Use interfaces for OOP-style contracts, types for complex utilities. Primitive types include number, string, boolean, null, undefined, symbol, and bigint. They are the basic building blocks for typing variables. Use a type annotation after the variable name with a colon: let name: string = "Alice";. TypeScript infers types when possible but explicit annotations improve clarity.

Question 29 Typescript Essentials

How do you import modules in TypeScript?

Mapped types transform keys: type Readonly<T> = { readonly [P in keyof T]: T[P]; };. Utility types like Partial, Pick are built on this. tsconfig.json is the TypeScript configuration file that specifies compiler options like target JavaScript version, module system, and strictness mode. It controls how TypeScript projects are compiled. The in keyword iterates keys in mapped types: { [P in keyof T]: T[P] }. Essential for transforming all or subset of properties. Use import { ModuleName } from './module'; for named exports or import * as Module from './module'; for namespace imports. Supports ES6 and CommonJS.

Question 30 Typescript Essentials

How do you define a class in TypeScript?

Mapped types transform keys: type Readonly<T> = { readonly [P in keyof T]: T[P]; };. Utility types like Partial, Pick are built on this. TypeScript is a statically typed superset of JavaScript developed by Microsoft that compiles to plain JavaScript code. It adds optional static typing, interfaces, classes, and modules to enhance code scalability, maintainability, and developer productivity. Classes use standard syntax with type annotations: class Animal { name: string; constructor(name: string) { this.name = name; } }. Supports access modifiers like public, private, protected. Use extends and super: class Dog extends Animal { bark() { super.bark(); } }. Subclasses inherit and can override members.

Question 31 Typescript Essentials

How do you extend interfaces?

Index signatures allow dynamic keys: interface StringDict { [key: string]: string; }. Useful for objects with string keys of unknown names. Generics parameterize types: function identity<T>(arg: T): T { return arg; }. They enable reusable, type-safe components like Array<T>. Use extends: interface Employee extends Person { role: string; }. It inherits all members from the base interface. public (default) allows access everywhere, private only within class, protected within class and subclasses. They enforce encapsulation at compile-time.

Question 32 Typescript Essentials

How does class inheritance work?

The keyof operator yields union of property keys: keyof Person // "name" | "age". Used in mapped and conditional types. Use extends and super: class Dog extends Animal { bark() { super.bark(); } }. Subclasses inherit and can override members. Classes use standard syntax with type annotations: class Animal { name: string; constructor(name: string) { this.name = name; } }. Supports access modifiers like public, private, protected. Use array syntax like let numbers: number[] = [1, 2, 3]; or generic Array<number>. Arrays can hold homogeneous or heterogeneous types with tuples.

Question 33 Typescript Essentials

What are optional parameters?

Index signatures allow dynamic keys: interface StringDict { [key: string]: string; }. Useful for objects with string keys of unknown names. Conditional types use ternary: type NonNullable<T> = T extends null | undefined ? never : T;. Infer types based on conditions for advanced utilities. Specify types after parameters and before function body: function add(a: number, b: number): number { return a + b; }. Arrow functions use similar syntax. Optional parameters use ?: function greet(name: string, greeting?: string): string. They can be omitted, defaulting to undefined.

Question 34 Typescript Essentials

How do you type a function parameter and return?

Use extends and super: class Dog extends Animal { bark() { super.bark(); } }. Subclasses inherit and can override members. Discriminated unions use a common literal discriminant: type Shape = { kind: 'circle'; r: number } | { kind: 'square'; side: number };. Switch on discriminant for exhaustive checks. Specify types after parameters and before function body: function add(a: number, b: number): number { return a + b; }. Arrow functions use similar syntax. Intersection types combine types: type Admin = User & { permissions: string[]; };. The resulting type requires all properties from intersected types.

Question 35 Typescript Essentials

What is the 'any' type?

Set "target": "ES2020" in tsconfig.json to specify output JavaScript version. Common options: ES5, ES2015, ESNext. Constructors initialize instances: constructor(private name: string) { }. Parameters can be auto-promoted to properties with access modifiers. Install TypeScript globally using npm install -g typescript or locally as a dev dependency with npm install typescript --save-dev. Verify installation with tsc --version. The any type disables type checking, allowing a value to be treated as any type. It should be used sparingly as it bypasses TypeScript's benefits; prefer unknown for safer alternatives.

Question 36 Typescript Essentials

How do you constrain generics?

Install TypeScript globally using npm install -g typescript or locally as a dev dependency with npm install typescript --save-dev. Verify installation with tsc --version. Union types allow multiple types: let id: string | number;. Values must be compatible with at least one type in the union. Use extends: function longest<T extends { length: number }>(a: T, b: T): T. Ensures type parameters have required properties. interface Box<T> { contents: T; }. Allows interfaces to work with any type while preserving type information.

Question 37 Typescript Essentials

What is strict mode in tsconfig?

Install TypeScript globally using npm install -g typescript or locally as a dev dependency with npm install typescript --save-dev. Verify installation with tsc --version. TypeScript automatically infers the type of a variable from its initializer. For example, let count = 5; infers number, reducing boilerplate while maintaining type safety. The "strict": true option enables all strict type-checking options like strictNullChecks. Recommended for new projects to catch more errors. Generics parameterize types: function identity<T>(arg: T): T { return arg; }. They enable reusable, type-safe components like Array<T>.

Question 38 Typescript Essentials

What is TypeScript?

TypeScript is a statically typed superset of JavaScript developed by Microsoft that compiles to plain JavaScript code. It adds optional static typing, interfaces, classes, and modules to enhance code scalability, maintainability, and developer productivity. Set "target": "ES2020" in tsconfig.json to specify output JavaScript version. Common options: ES5, ES2015, ESNext. Built-in utilities include Partial<T> (all optional), Required<T> (all required), Pick<T, K> (select keys), Omit<T, K> (exclude keys). They simplify common transformations. Mapped types transform keys: type Readonly<T> = { readonly [P in keyof T]: T[P]; };. Utility types like Partial, Pick are built on this.

Question 39 Typescript Essentials

What are template literal types?

TypeScript is a superset of JavaScript, meaning all valid JavaScript code is also valid TypeScript. TypeScript code is transpiled to JavaScript, allowing it to run in any JavaScript environment. Template literals create string literal unions: type Event = `on${'click' | 'hover'}`; // "onclick" | "onhover". Useful for string manipulation at type level. class Stack<T> { push(item: T): void { } pop(): T | undefined { } }. Classes can be generic for type-safe data structures. The "strict": true option enables all strict type-checking options like strictNullChecks. Recommended for new projects to catch more errors.

Question 40 Typescript Essentials

What are declaration files (.d.ts)?

Primitive types include number, string, boolean, null, undefined, symbol, and bigint. They are the basic building blocks for typing variables. .d.ts files provide type definitions for JavaScript libraries: declare function jQuery(): void;. Installed via @types packages like npm install @types/node. Set "target": "ES2020" in tsconfig.json to specify output JavaScript version. Common options: ES5, ES2015, ESNext. Use extends and super: class Dog extends Animal { bark() { super.bark(); } }. Subclasses inherit and can override members.

Question 41 Typescript Essentials

How do you install TypeScript?

readonly prevents assignment after initialization: interface Point { readonly x: number; y: number; }. Ideal for immutable data. Classes use standard syntax with type annotations: class Animal { name: string; constructor(name: string) { this.name = name; } }. Supports access modifiers like public, private, protected. Namespaces group related code: namespace Utils { export function helper() { } }. Used for avoiding global pollution pre-modules, now less common. Install TypeScript globally using npm install -g typescript or locally as a dev dependency with npm install typescript --save-dev. Verify installation with tsc --version.

Question 42 Typescript Essentials

How do you type rest parameters?

Classes use standard syntax with type annotations: class Animal { name: string; constructor(name: string) { this.name = name; } }. Supports access modifiers like public, private, protected. Constructors initialize instances: constructor(private name: string) { }. Parameters can be auto-promoted to properties with access modifiers. Rest parameters use ... with array type: function sum(...numbers: number[]): number. They collect remaining arguments into an array. Type guards narrow types in conditionals: function isString(value: any): value is string { return typeof value === 'string'; }. Enables safe access to narrowed properties.

Question 43 Typescript Essentials

What are mapped types?

Intersection types combine types: type Admin = User & { permissions: string[]; };. The resulting type requires all properties from intersected types. Conditional types use ternary: type NonNullable<T> = T extends null | undefined ? never : T;. Infer types based on conditions for advanced utilities. Mapped types transform keys: type Readonly<T> = { readonly [P in keyof T]: T[P]; };. Utility types like Partial, Pick are built on this. Constructors initialize instances: constructor(private name: string) { }. Parameters can be auto-promoted to properties with access modifiers.

Question 44 Typescript Essentials

What is tsconfig.json?

tsconfig.json is the TypeScript configuration file that specifies compiler options like target JavaScript version, module system, and strictness mode. It controls how TypeScript projects are compiled. Generics parameterize types: function identity<T>(arg: T): T { return arg; }. They enable reusable, type-safe components like Array<T>. Rest parameters use ... with array type: function sum(...numbers: number[]): number. They collect remaining arguments into an array. Type assertion tells the compiler to treat a value as a specific type using as: let value = "5" as number; or angle-bracket syntax. Use cautiously to avoid runtime errors.

Question 45 Typescript Essentials

How do you target different JS versions?

Set "target": "ES2020" in tsconfig.json to specify output JavaScript version. Common options: ES5, ES2015, ESNext. Use array syntax like let numbers: number[] = [1, 2, 3]; or generic Array<number>. Arrays can hold homogeneous or heterogeneous types with tuples. Discriminated unions use a common literal discriminant: type Shape = { kind: 'circle'; r: number } | { kind: 'square'; side: number };. Switch on discriminant for exhaustive checks. Type guards narrow types in conditionals: function isString(value: any): value is string { return typeof value === 'string'; }. Enables safe access to narrowed properties.

Question 46 Typescript Essentials

What is a constructor in TypeScript classes?

Use array syntax like let numbers: number[] = [1, 2, 3]; or generic Array<number>. Arrays can hold homogeneous or heterogeneous types with tuples. Use import { ModuleName } from './module'; for named exports or import * as Module from './module'; for namespace imports. Supports ES6 and CommonJS. Use export function func() { } for named or export default class Class { } for default. Re-export with export { something } from './other';. Constructors initialize instances: constructor(private name: string) { }. Parameters can be auto-promoted to properties with access modifiers.

Question 47 Typescript Essentials

What are union types?

The never type represents values that never occur, such as exhaustive switch statements or impossible code paths. It is useful for function return types that always throw errors. TypeScript automatically infers the type of a variable from its initializer. For example, let count = 5; infers number, reducing boilerplate while maintaining type safety. Union types allow multiple types: let id: string | number;. Values must be compatible with at least one type in the union. Interfaces describe object shapes: interface Person { name: string; age: number; }. They are used for type checking objects without runtime overhead.

Question 48 Typescript Essentials

How do you declare a typed variable?

Union types allow multiple types: let id: string | number;. Values must be compatible with at least one type in the union. Tuples are fixed-length arrays with specific types per position: let tuple: [string, number] = ["age", 30];. They enforce length and type order unlike regular arrays. Use a type annotation after the variable name with a colon: let name: string = "Alice";. TypeScript infers types when possible but explicit annotations improve clarity. Use import { ModuleName } from './module'; for named exports or import * as Module from './module'; for namespace imports. Supports ES6 and CommonJS.

Question 49 Typescript Essentials

What are primitive types in TypeScript?

public (default) allows access everywhere, private only within class, protected within class and subclasses. They enforce encapsulation at compile-time. Intersection types combine types: type Admin = User & { permissions: string[]; };. The resulting type requires all properties from intersected types. Primitive types include number, string, boolean, null, undefined, symbol, and bigint. They are the basic building blocks for typing variables. TypeScript automatically infers the type of a variable from its initializer. For example, let count = 5; infers number, reducing boilerplate while maintaining type safety.

Question 50 Typescript Essentials

What are discriminated unions?

Intersection types combine types: type Admin = User & { permissions: string[]; };. The resulting type requires all properties from intersected types. Discriminated unions use a common literal discriminant: type Shape = { kind: 'circle'; r: number } | { kind: 'square'; side: number };. Switch on discriminant for exhaustive checks. Use export function func() { } for named or export default class Class { } for default. Re-export with export { something } from './other';. TypeScript automatically infers the type of a variable from its initializer. For example, let count = 5; infers number, reducing boilerplate while maintaining type safety.