Các Cách Thay Thế 'If' Trong Câu Điều Kiện

You have a collection of `Logger` objects (e.g., `FileLogger`, `ConsoleLogger`, `DatabaseLogger`), all implementing a common `ILogger` interface. When you call `logMessage()` on an `ILogger` instance, the correct logging mechanism is used without explicit checks. This demonstrates:

What is the output of `const message = (age >= 18) ? 'Adult' : 'Minor';` if `age` is 16?

You are building a GUI application where various menu items (e.g., 'Save', 'Open', 'Copy') need to perform different actions when clicked. Instead of using a large `if-else if` block to check which item was clicked and then execute its logic, you encapsulate each action into a separate object. Which design pattern does this describe?

Consider a scenario where you need to access a property of an object, but the object itself or an intermediate property might be null or undefined. Which operator provides a safe way to access nested properties without explicit null checks?

You are refactoring a system where many components communicate directly with each other, leading to tight coupling and complex `if-else` logic for message dispatch. Which design pattern would you use to centralize communication between components, replacing direct calls and conditional logic with a single intermediary?

When is it generally preferable to use a `switch` statement over a long `if-else if` ladder?

You have a system that processes different types of orders (e.g., 'OnlineOrder', 'PhoneOrder', 'RetailOrder'). Each order type has a unique way of calculating its total. Instead of using `if-else if` to check the order type and call the specific calculation logic, you define a common `calculateTotal()` method in a base `Order` class, and each specific order type overrides it. This is an example of:

A business application has complex rules for applying discounts based on customer type, purchase history, and current promotions. These rules are frequently updated. Instead of embedding these rules in nested `if-else` statements, a developer implements a system where each rule is an independent object that can be added or removed dynamically. This approach is characteristic of what kind of system?

When refactoring a series of `if-else if` statements that check for different types of objects and perform type-specific actions, which design principle or pattern is often a superior alternative?

You are refactoring a system where a complex `if-else if` structure is used to determine the behavior of an object based on its components (e.g., a `Graphic` object can be a `Circle`, `Square`, or a `Group` of graphics). Which design pattern would allow you to treat individual objects and compositions of objects uniformly, thus avoiding conditional logic for handling different types?