Why patterns matter for safety in Typescript - See It in Action

Why patterns matter for safety

📖 Scenario: Imagine you are building a small program to check if certain actions are safe to perform based on a list of safety patterns. These patterns help prevent mistakes and keep things secure, like wearing a helmet when riding a bike or checking if a door is locked before leaving.

🎯 Goal: You will create a TypeScript program that stores safety patterns, sets a threshold for safety importance, filters the patterns based on that threshold, and then shows which patterns are important for safety.

📋 What You'll Learn

Create a dictionary called safetyPatterns with exact keys and numeric values representing importance.

Create a variable called importanceThreshold with the exact value 5.

Use a dictionary comprehension (object comprehension) to create a new dictionary called importantPatterns that only includes patterns with importance greater than or equal to importanceThreshold.

Print the importantPatterns dictionary.

💡 Why This Matters

🌍 Real World

Safety patterns help prevent accidents and mistakes in many areas like driving, working with machines, or software security.

💼 Career

Understanding how to filter and manage data based on conditions is a key skill in programming jobs, especially when working with safety-critical systems.

1

Create the safety patterns dictionary

Create a dictionary called safetyPatterns with these exact entries: 'WearHelmet': 7, 'CheckBrakes': 6, 'LockDoor': 4, 'UseReflectors': 5, 'AvoidDistractions': 8.

Typescript

// Create the safetyPatterns dictionary with exact entries
// Your code here

Hint

Use an object literal with keys and values exactly as shown.

2

Set the importance threshold

Create a variable called importanceThreshold and set it to the number 5.

Typescript

const safetyPatterns: { [key: string]: number } = {
  'WearHelmet': 7,
  'CheckBrakes': 6,
  'LockDoor': 4,
  'UseReflectors': 5,
  'AvoidDistractions': 8
};

// Create importanceThreshold variable and set it to 5
// Your code here

Hint

Use const importanceThreshold = 5; to create the variable.

3

Filter important safety patterns

Create a new dictionary called importantPatterns that includes only the entries from safetyPatterns where the value is greater than or equal to importanceThreshold. Use Object.entries, filter, and reduce to build importantPatterns.

Typescript

const safetyPatterns: { [key: string]: number } = {
  'WearHelmet': 7,
  'CheckBrakes': 6,
  'LockDoor': 4,
  'UseReflectors': 5,
  'AvoidDistractions': 8
};

const importanceThreshold = 5;

// Create importantPatterns dictionary filtering safetyPatterns by importanceThreshold
// Your code here

Hint

Use Object.entries to get pairs, then filter by importance, then reduce to build the new object.

4

Display the important safety patterns

Write a console.log statement to print the importantPatterns dictionary.

Typescript

const safetyPatterns: { [key: string]: number } = {
  'WearHelmet': 7,
  'CheckBrakes': 6,
  'LockDoor': 4,
  'UseReflectors': 5,
  'AvoidDistractions': 8
};

const importanceThreshold = 5;

const importantPatterns = Object.entries(safetyPatterns)
  .filter(([pattern, importance]) => importance >= importanceThreshold)
  .reduce((obj, [pattern, importance]) => {
    obj[pattern] = importance;
    return obj;
  }, {} as { [key: string]: number });

// Print the importantPatterns dictionary
// Your code here

Hint

Use console.log(importantPatterns); to show the filtered dictionary.

Practice

1. Why is it important to use patterns in TypeScript for safety?

easy

A. They allow skipping type checks

B. They make the code run faster

C. They reduce the file size of the program

D. They help catch errors before running the code

Solution

1. Step 1: Understand the role of patterns in TypeScript

   Patterns guide how to write code that avoids common mistakes and bugs.

2. Step 2: Identify the benefit of safety patterns

   They help detect errors early, before the program runs, improving reliability.

3. Final Answer:

   They help catch errors before running the code -> Option D

4. Quick Check:

   Patterns catch errors early = A [OK]

Hint: Patterns catch bugs early, before runtime [OK]

Common Mistakes:

• Thinking patterns only improve speed
• Believing patterns reduce file size
• Assuming patterns skip type checks

2. Which of the following is the correct TypeScript syntax to safely check if a variable value is a string before using it?

easy

A. if (typeof value === 'string') { /* use value */ }

B. if (value.type === 'string') { /* use value */ }

C. if (value instanceof 'string') { /* use value */ }

D. if (value === string) { /* use value */ }

Solution

1. Step 1: Recall correct type checking syntax in TypeScript

   Use typeof variable === 'string' to check if a variable is a string.

2. Step 2: Evaluate each option

   Only if (typeof value === 'string') { /* use value */ } uses the correct typeof operator and string comparison.

3. Final Answer:

   if (typeof value === 'string') { /* use value */ } -> Option A

4. Quick Check:

   Use typeof for type checks = D [OK]

Hint: Use typeof to check primitive types safely [OK]

Common Mistakes:

• Using .type property which doesn't exist
• Using instanceof with string literal
• Comparing variable directly to string keyword

3. What will be the output of this TypeScript code?

function safeDivide(a: number, b: number): number | null {
  if (b === 0) return null;
  return a / b;
}

console.log(safeDivide(10, 2));
console.log(safeDivide(10, 0));

medium

A. 5 and null

B. 5 and Infinity

C. 5 and 0

D. Error at runtime

Solution

1. Step 1: Analyze the function safeDivide

   If divisor b is zero, function returns null, else returns division result.

2. Step 2: Evaluate console.log outputs

   First call: 10 / 2 = 5; second call: divisor is 0, returns null.

3. Final Answer:

   5 and null -> Option A

4. Quick Check:

   Division by zero returns null = C [OK]

Hint: Check for zero divisor to avoid runtime errors [OK]

Common Mistakes:

• Expecting division by zero to return 0
• Assuming runtime error instead of null
• Confusing null with Infinity

4. Identify the error in this TypeScript code that tries to safely access a property:

interface User {
  name: string;
  age?: number;
}

function getUserAge(user: User): number {
  return user.age;
}

medium

A. Incorrect interface declaration syntax

B. Missing check for optional property before returning

C. Function should return string instead of number

D. No error, code is correct

Solution

1. Step 1: Understand optional property in interface

   Property age is optional, so it may be undefined.

2. Step 2: Check function return type vs possible undefined

   Function returns number but user.age can be undefined, causing a type error.

3. Final Answer:

   Missing check for optional property before returning -> Option B

4. Quick Check:

   Optional properties need checks = A [OK]

Hint: Check optional properties before use to avoid errors [OK]

Common Mistakes:

• Ignoring optional property may be undefined
• Thinking interface syntax is wrong
• Confusing return type with property type

5. You want to create a safe pattern to transform an array of mixed values into an object mapping only string keys to their lengths. Which TypeScript pattern ensures safety and correctness?

const items = ["apple", 42, "banana", null, "cherry"];

// Which pattern is safest to create { [key: string]: number } mapping?

hard

A. Map all items to their length without checks

B. Use a for loop without type checks

C. Use a filter to keep only strings, then map to lengths

D. Assign items directly to object keys

Solution

1. Step 1: Identify the need to filter only strings

   Since array has mixed types, filter out non-string values to avoid errors.

2. Step 2: Map filtered strings to their lengths safely

   After filtering, create object entries mapping strings to their length, ensuring type safety.

3. Final Answer:

   Use a filter to keep only strings, then map to lengths -> Option C

4. Quick Check:

   Filter then map for safe transformation = B [OK]

Hint: Filter first, then map to avoid unsafe types [OK]

Common Mistakes:

• Mapping without filtering causes runtime errors
• Using loops without type checks
• Assigning mixed types directly to object keys