Strict configuration objects in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a strict config object with excess property check

What is the output of this TypeScript code when compiled and run with strict mode enabled?

Typescript

interface Config {
  url: string;
  timeout: number;
}

const config: Config = {
  url: "https://example.com",
  timeout: 5000,
  debug: true
};

console.log(config.timeout);

A Compilation error due to excess property 'debug'

B 5000

C undefined

D Runtime error: Property 'debug' does not exist

💡 Hint

Think about how TypeScript's strict object literal checks work when assigning to a typed variable.

In strict mode, TypeScript does not allow extra properties that are not defined in the interface when assigning an object literal directly. The property 'debug' is not in Config, so this causes a compilation error.

🧠 Conceptual

intermediate

Understanding readonly properties in strict config objects

Given this TypeScript interface and object, which statement is true about modifying the config object?

interface Config {
  readonly apiKey: string;
  retries: number;
}

const config: Config = { apiKey: "abc123", retries: 3 };
config.retries = 5;
config.apiKey = "xyz789";

A Both assignments cause errors

B Assignment to 'retries' is allowed; assignment to 'apiKey' causes an error

C Assignment to 'apiKey' is allowed; assignment to 'retries' causes an error

D Both assignments are allowed without error

💡 Hint

Consider what the readonly keyword means in TypeScript.

The readonly modifier means the property cannot be changed after initialization. So apiKey cannot be reassigned, but retries can.

🔧 Debug

advanced

Why does this strict config object cause a type error?

Identify the cause of the TypeScript error in this code snippet:

interface Config {
  host: string;
  port: number;
  secure?: boolean;
}

const config: Config = {
  host: "localhost",
  port: 8080,
  secure: "true"
};

A Optional properties cannot be assigned any value

B The property 'port' should be a string, not a number

C The property 'host' is missing

D The property 'secure' is optional but assigned a string instead of boolean

💡 Hint

Check the type of the optional property and the assigned value.

The 'secure' property is optional and expects a boolean if provided. Assigning a string '"true"' causes a type mismatch error.

📝 Syntax

advanced

Which option correctly defines a strict config object with nested readonly properties?

Choose the option that correctly defines a TypeScript interface with a nested readonly config object and an instance that respects strict typing.

A

interface Config { readonly server: { readonly host: string; readonly port: number } }
const config: Config = { server: { host: "127.0.0.1", port: 80 } };
config.server.port = 8080;

B

interface Config { server: { readonly host: string; readonly port: number } }
const config: Config = { server: { host: "127.0.0.1", port: 80 } };
config.server.port = 8080;

C

interface Config { readonly server: { host: string; port: number } }
const config: Config = { server: { host: "127.0.0.1", port: 80 } };
config.server.port = 8080;

D

interface Config { server: { host: string; port: number } }
const config: Config = { server: { host: "127.0.0.1", port: 80 } };
config.server.port = 8080;

💡 Hint

Consider where the readonly modifier applies and what it protects.

Option A correctly marks the nested properties as readonly, so attempts to modify them cause errors. The outer object is readonly, and nested properties are also readonly, enforcing strict immutability.

🚀 Application

expert

How many keys are in the resulting strict config object?

Given this TypeScript code, how many keys does the finalConfig object have at runtime?

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

interface ExtendedConfig extends BaseConfig {
  secure: boolean;
  timeout?: number;
}

const base: BaseConfig = { host: "localhost", port: 3000 };
const extra = { secure: true, timeout: 1000 };

const finalConfig: ExtendedConfig = { ...base, ...extra };

console.log(Object.keys(finalConfig).length);

A 2

B 3

C 4

D 5

💡 Hint

Think about how spreading objects merges keys and which keys exist in the final object.

The finalConfig object has keys: 'host', 'port', 'secure', and 'timeout'. So the length of keys is 4.