Why patterns matter for safety in Typescript - Quick Recap

Recall & Review

beginner

What does 'patterns' mean in programming?

Patterns are common ways to solve problems that help make code safer and easier to understand.

beginner

How do patterns improve safety in TypeScript code?

Patterns help catch errors early and make sure the code behaves as expected, reducing bugs and crashes.

intermediate

Why is consistency important when using patterns?

Consistency helps everyone read and maintain the code easily, which prevents mistakes and improves safety.

intermediate

Give an example of a pattern that helps with safety in TypeScript.

Using 'readonly' properties to prevent accidental changes to important data is a safety pattern.

beginner

What can happen if you ignore patterns in your code?

Ignoring patterns can lead to bugs, security issues, and code that is hard to fix or understand.

Why do patterns matter for safety in programming?

A They make the code run faster.

B They reduce the size of the code.

C They allow skipping tests.

D They help prevent errors and make code easier to maintain.

Patterns help prevent errors and improve code maintainability, which increases safety.

Which TypeScript feature is a pattern that improves safety?

A Ignoring type checks.

B Using 'any' type everywhere.

C Using 'readonly' properties.

D Using 'var' instead of 'let' or 'const'.

'readonly' properties prevent accidental changes, improving safety.

What is a risk of not following patterns?

A More bugs and security issues.

B Code is easier to read.

C Code becomes more secure.

D Faster development always.

Ignoring patterns can cause bugs and security problems.

How does consistency in patterns help safety?

A It helps everyone understand and avoid mistakes.

B It makes code harder to maintain.

C It slows down coding.

D It confuses developers.

Consistency helps developers understand code and avoid errors.

Which is NOT a benefit of using patterns for safety?

A Clear code structure.

B Skipping code reviews.

C Early error detection.

D Reduced bugs.

Patterns do not replace code reviews; skipping them is unsafe.

Explain why using patterns in TypeScript helps keep code safe.

Think about how patterns guide writing code that avoids mistakes.

Describe what can happen if a team ignores safety patterns in their code.

Consider the risks of inconsistent or careless coding.

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