Summary  
TypeScript uses truthiness and explicit null/undefined checks in conditional statements to narrow union types, ensuring safe property access on values that may be optional or missing.

General domain of usage  
Form validation

function printLength(str: string | null | undefined) {
  if (str) {
    // TypeScript knows 'str' is a string here
    console.log("Length:", str.length);
  } else {
    console.log("No string provided");
  }
}

TypeScript uses **truthiness checks** and explicit **null** or **undefined** checks to narrow types within your code. When you use a value in a condition—such as an `if` statement—TypeScript analyzes the possible types and removes `null` and `undefined` if the value is checked for truthiness. This means that inside the block where a value is confirmed to be truthy, TypeScript treats it as a non-null, non-undefined type, allowing you to safely access its properties or methods. This narrowing is essential for writing safe code that avoids runtime errors, especially when dealing with values that may be optional or missing. By leveraging these checks, you can prevent issues like trying to read properties from `null` or `undefined`, which would otherwise cause your program to crash.

Which statement best describes how TypeScript narrows types using truthiness or null/undefined checks?

Strengthen your TypeScript skills by mastering advanced type safety and robust error handling. Learn how type guards, discriminated unions, and exhaustive checks work together to eliminate uncertain runtime behavior. Apply safe narrowing patterns to both synchronous and asynchronous code to create cleaner, more reliable applications.

Build a clear understanding of how TypeScript narrows types at runtime using built-in and custom guards. Work with typeof, instanceof, truthiness checks, and predicate functions to write safer, more predictable logic. Strengthen your ability to prevent invalid states before they happen.

Use discriminated unions to model variant data structures and guide the compiler toward safe branching logic. Apply pattern-matching approaches that simplify decision making and reduce errors. Ensure full coverage of every possible case through exhaustive handling techniques.

Improve the safety of asynchronous code by propagating and narrowing errors with clarity and precision. Explore advanced narrowing strategies for complex unions and learn how to avoid unsafe assumptions. Apply structured patterns that detect unreachable cases, prevent subtle bugs, and keep code resilient.

Truthiness and Null/Undefined Narrowing