Strict configuration objects in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean for a configuration object to be strict in TypeScript?

A strict configuration object means it must exactly match the expected shape with no extra or missing properties. TypeScript enforces this to catch errors early.

beginner

How does TypeScript behave when you pass an object with extra properties to a function expecting a strict configuration object?

TypeScript will give a type error because extra properties are not allowed in strict configuration objects. This helps prevent bugs from unexpected options.

intermediate

What TypeScript feature helps enforce strict configuration objects by disallowing extra properties?

TypeScript's excess property checks combined with object literal type checking enforces strict configuration objects by flagging extra properties as errors.

beginner

Why might you want to use strict configuration objects in your TypeScript code?

Using strict configuration objects helps catch mistakes early, ensures your code uses only expected options, and improves code clarity and maintainability.

intermediate

How can you allow optional properties in a strict configuration object without losing strictness?

You can mark properties as optional using ? in the type definition. This keeps strictness but allows those properties to be omitted.

What happens if you pass an object with an extra property to a function expecting a strict configuration object in TypeScript?

A TypeScript shows an error for the extra property.

B TypeScript ignores the extra property silently.

C The extra property overwrites existing ones.

D The function runs but with a warning.

TypeScript enforces strict configuration objects by showing an error when extra properties are present.

How do you mark a property as optional in a strict configuration object type?

A Use 'undefined' as the property type.

B Use a question mark (?) after the property name.

C Use the keyword 'optional' before the property.

D You cannot have optional properties in strict objects.

In TypeScript, adding '?' after a property name marks it as optional.

Which TypeScript feature helps catch extra properties in configuration objects?

A Type assertions

B Type inference

C Excess property checks

D Union types

Excess property checks flag extra properties not expected in the type.

Why is using strict configuration objects beneficial?

A It prevents bugs by ensuring only expected options are used.

B It makes the code run faster.

C It allows any properties without errors.

D It disables type checking.

Strict configuration objects help prevent bugs by enforcing expected properties only.

If you want to allow extra properties in a configuration object, what should you do?

A You cannot allow extra properties.

B Mark all properties as optional.

C Use a union type.

D Use an index signature like [key: string]: any.

An index signature allows extra properties by specifying a flexible key and value type.

Explain what a strict configuration object is in TypeScript and why it is useful.

Think about how TypeScript checks object shapes when passing them as arguments.

Describe how to define optional properties in a strict configuration object type and why you might want to do that.

Optional properties let you skip some settings but still keep type safety.

Practice

1.

What is the main benefit of using strict configuration objects in TypeScript?

easy

A. They allow any keys to be added without errors.

B. They make the code run faster at runtime.

C. They catch errors early by enforcing exact keys and types.

D. They automatically generate UI forms for settings.

Solution

1. Step 1: Understand strict configuration objects

   Strict configs define exactly which keys and types are allowed in an object.

2. Step 2: Identify the main benefit

   This strictness helps catch mistakes early, before running the code.

3. Final Answer:

   They catch errors early by enforcing exact keys and types. -> Option C

4. Quick Check:

   Strict config = early error detection [OK]

Hint: Strict configs prevent wrong keys and types early [OK]

Common Mistakes:

• Thinking strict configs improve runtime speed
• Believing strict configs allow any keys
• Confusing strict configs with UI generation

2.

Which of the following is the correct way to declare a strict configuration object type in TypeScript?

interface Config {
  host: string;
  port: number;
}

easy

A. const config: Config = { host: 'localhost', port: 8080 };

B. const config: Config = { host: 'localhost' };

C. const config: Config = { host: 'localhost', port: '8080' };

D. const config = { host: 'localhost', port: 8080 };

Solution

1. Step 1: Check interface requirements

   The Config interface requires both 'host' as string and 'port' as number.

2. Step 2: Match object to interface

   const config: Config = { host: 'localhost', port: 8080 }; has both keys with correct types, so it matches Config exactly.

3. Final Answer:

   const config: Config = { host: 'localhost', port: 8080 }; -> Option A

4. Quick Check:

   All required keys with correct types = const config: Config = { host: 'localhost', port: 8080 }; [OK]

Hint: Match all keys and types exactly to interface [OK]

Common Mistakes:

• Omitting required keys
• Using wrong types for keys
• Not specifying the type annotation

3.

What will be the output of this TypeScript code?

interface Settings {
  debug: boolean;
  version: string;
}

const config: Settings = { debug: true, version: '1.0' };
console.log(config.debug, config.version);

medium

A. true 1.0

B. true '1.0'

C. undefined undefined

D. Error: Missing properties

Solution

1. Step 1: Check object matches interface

   The object has 'debug' as true (boolean) and 'version' as '1.0' (string), matching Settings.

2. Step 2: Understand console.log output

   console.log prints the boolean true and string '1.0' without quotes, so output is: true 1.0

3. Final Answer:

   true 1.0 -> Option A

4. Quick Check:

   Matching keys print their values correctly [OK]

Hint: Check object keys match interface and print values directly [OK]

Common Mistakes:

• Expecting quotes around string in console output
• Thinking missing keys cause runtime error
• Confusing type errors with runtime output

4.

Identify the error in this TypeScript code using a strict configuration object:

interface Options {
  timeout: number;
  verbose: boolean;
}

const opts: Options = { timeout: 5000, verbose: 'yes' };

medium

A. Property 'timeout' is missing.

B. Property 'verbose' should be a boolean, not a string.

C. Extra property 'verbose' is not allowed.

D. No error, code is correct.

Solution

1. Step 1: Check property types against interface

   'timeout' is number 5000, correct. 'verbose' is string 'yes', but interface requires boolean.

2. Step 2: Identify type mismatch error

   Assigning string to boolean property causes a type error.

3. Final Answer:

   Property 'verbose' should be a boolean, not a string. -> Option B

4. Quick Check:

   Type mismatch on 'verbose' property [OK]

Hint: Check each property type matches interface exactly [OK]

Common Mistakes:

• Ignoring type mismatch errors
• Thinking missing properties cause this error
• Confusing extra properties with wrong types

5.

You want to create a strict configuration object that only allows keys mode (string), retry (number), and enabled (boolean). Which TypeScript type definition ensures no extra keys are allowed?

hard

A. interface Config { mode: string; retry: number; enabled: boolean; }

B. type Config = { mode: string; retry: number; enabled: boolean; [key: string]: any }

C. type Config = { mode?: string; retry?: number; enabled?: boolean }

D. interface Config { mode: string; retry: number; enabled: boolean; [key: string]: never }

Solution

1. Step 1: Understand how to forbid extra keys

   Using an index signature with [key: string]: never forbids any keys not explicitly declared.

2. Step 2: Compare options

   interface Config { mode: string; retry: number; enabled: boolean; } allows extra keys implicitly. type Config = { mode: string; retry: number; enabled: boolean; [key: string]: any } allows any extra keys. type Config = { mode?: string; retry?: number; enabled?: boolean } makes keys optional but doesn't forbid extras. Only interface Config { mode: string; retry: number; enabled: boolean; [key: string]: never } forbids extra keys.

3. Final Answer:

   interface Config { mode: string; retry: number; enabled: boolean; [key: string]: never } -> Option D

4. Quick Check:

   Index signature with never forbids extra keys [OK]

Hint: Use [key: string]: never to forbid extra keys [OK]

Common Mistakes:

• Thinking interface alone forbids extra keys
• Using any type index signature allowing extras
• Making keys optional but not forbidding extras