Compound Conditions — I can evaluate compound conditions using &&, ||, and ! and predict outcomes at my level.

Every time you use a search engine, unlock your phone, or play a video game, the software behind the scenes is making hundreds of decisions per second. Many of those decisions are not simple yes-or-no checks — they combine multiple conditions at once. For example, a login system might need to verify that a username is correct and that a password matches and that the account is not locked. This kind of multi-part logic is called a compound condition, and it sits at the heart of how programs make complex decisions.

The logical operators that power compound conditions — AND, OR, and NOT — were not invented by programmers. They trace back to formal logic and mathematics, long before the first computer was ever built. Understanding their origins helps you see that these operators follow precise, predictable rules rather than arbitrary syntax.

So the core question this lesson addresses is straightforward: when your program needs to check more than one thing before making a decision, how do you combine those checks correctly, and how do you predict what the combined result will be? Mastering &&, ||, and ! gives you that power.

Before diving into code, you need to understand three foundational ideas. Each of the logical operators takes Boolean values (true or false) as input and produces a single Boolean value as output. Think of them as decision-making tools that combine smaller yes/no questions into a bigger yes/no answer.

The best way to see how compound conditions work is through a truth table — a chart that lists every possible combination of true and false inputs and shows the resulting output. The diagram below displays truth tables for all three operators side by side, so you can compare their behavior at a glance.

Study the color coding carefully. Green results represent true outputs and red results represent false outputs. The dramatic difference between the AND and OR tables is the most important takeaway: AND is strict (mostly false), while OR is lenient (mostly true). The NOT table is the simplest — it always produces the opposite of whatever it receives.

Now let's translate the abstract logic into real JavaScript. A compound condition is simply two or more comparison expressions joined by && or ||, optionally with ! flipping individual parts. Each comparison expression (like age >= 16) evaluates to a Boolean, and then the logical operator combines those Booleans.

Real programs rarely use just one operator at a time. You will often see expressions that combine two or even three logical operators. The key to evaluating these correctly is to follow the order of operations: NOT first, then AND, then OR — unless parentheses override the order. The following diagram walks through a complex expression step by step.

The table above reinforces a critical skill: substitute the actual values, evaluate each comparison to true or false, then apply the logical operators in precedence order. Practice this mechanical process and you will be able to predict the outcome of any compound condition.

Imagine you are building a movie ticket pricing system. A customer gets a discount if they are a student AND the showing is before 5 PM, OR if they are a senior citizen. Let's write and evaluate the compound condition step by step.

Now that you have seen all three operators in action, it helps to compare them side by side. The table below highlights when to use each operator, common mistakes, and tips for keeping your code readable.

Compound conditions are your entry point into a broader world of logical reasoning in programming. As you progress, you will encounter these operators in increasingly sophisticated contexts, from loop conditions to data validation to software architecture patterns. The table below previews how what you learn now connects to more advanced topics.

One particularly useful connection is De Morgan's Laws, named after the 19th-century mathematician Augustus De Morgan. These laws state that !(A && B) is always equivalent to !A || !B, and !(A || B) is always equivalent to !A && !B. You don't need to memorize these now, but they are a natural extension of the skills you are building in this lesson.