../courses.php

Procedural PHP

PHP

90

Making Decisions In PHP

How if, elseif, and the logical operators choose exactly one path through a program.

A line of code reads if ( $user_is_admin && delete_record() ). On one visit, $user_is_admin holds false, and delete_record() never runs at all, not just untrue, never even called. Why would PHP skip running part of a condition entirely, instead of checking every part of it every time?

&& short-circuits. The moment the left side, $user_is_admin, is false, PHP already knows the whole combined condition must be false, no matter what the right side would have produced, so it never bothers to run the right side at all. This matters specifically when the right side is a function call with its own side effects, such as deleting something, because that function's own code, not just its true-or-false answer, may never execute on some visits.

An if statement runs the block that follows it only when its condition evaluates to true. Pairing it with else gives a program a second block to run instead, for every other case, with no condition of its own needed on the else branch.

elseif lets a program check several conditions in a strict order, top to bottom, stopping at the very first one that turns out true. Every later elseif and the final else, if there is one, are skipped completely once an earlier branch has already matched.

The comparison operators, such as ==, ===, <, and >=, each produce a boolean, true or false. A condition is, underneath everything else, always just one boolean value that PHP checks at the moment the if line runs.

The logical operators && (and), || (or), and ! (not) combine or flip boolean values to build a more complex condition out of simpler ones, the same way arithmetic operators combine numbers.

A condition does not require a comparison operator at all. Writing if ( $is_member ), with no == anywhere, is a complete, valid condition on its own, because $is_member already holds a true-or-false-like value PHP can check directly.

A function that picks one price using if, elseif, and else

PHP checks these elseif branches top to bottom, stopping at the first one whose condition is true. Rearranging the order of these specific branches would change which price some ages receive, even though each individual condition's text stays exactly the same.

$age >= 65 && $is_member requires both sides to be true for this branch to run. If $age is 70 but $is_member is false, this whole elseif is skipped, and PHP moves on to check the next elseif, $is_member, which is also false here, so it falls through to else.

The values 70 and true passed into the call never get compared to anything by name. Inside the function, they are simply whatever $age and $is_member happen to equal for this one call. A different call elsewhere, with different values, runs the exact same function logic completely independently.

return ends ticket_price() the instant any one branch's return line runs. Even though four return statements exist in this one function, exactly one of them ever executes per call.

No semicolon follows the closing brace of the if, elseif, or else blocks themselves, only the lines inside them, such as return 0;, end with one. A block inside { } is a compound statement, not the kind of single line a semicolon is needed for.

Branch order can silently change which result a value gets

Swapping the order of the $age >= 65 && $is_member branch and the $is_member branch in this exact function means every 70-year-old member receives 6, the ordinary member price, instead of 4, the senior member price, even though neither condition's text changed at all.

&& and || skip code on the side that was never needed

In a condition such as $is_logged_in && load_user_profile(), the function load_user_profile() is never called at all when $is_logged_in is false, because && already knows the overall result without checking further. Relying on that function running as a side effect, rather than only for its true-or-false answer, is a common source of bugs that only appear for logged-out visitors.

A missing elseif turns one decision into two

Writing two separate if statements back to back, instead of if and elseif, means PHP evaluates both conditions independently, and can run both blocks on the same request if both happen to be true together, instead of running at most one block the way a single if/elseif/else chain guarantees.

A condition does not need to compare anything at all

PHP treats values such as 0, "", "0", null, an empty array, and false itself as false-like inside a condition, and every other value, including the actual text "false", as true-like. This is why if ( "false" ) runs its block.

A ! flips the result it is placed directly in front of, nothing further

Writing ! ($age >= 65 && $is_member) flips the truth of the whole combined expression at once, because of the parentheses. Writing ! $age >= 65 && $is_member instead only negates $age by itself, turning it into a boolean before comparing that to 65 at all, producing a result that is almost never what was intended.

Relying on a function call inside &&, that may never run

Keeping the side effect outside the condition

When an AI tool writes a decision chain, three things are worth checking. First, does it use elseif, not separate stacked if statements, whenever only one branch is meant to run. Second, does it ever place a function call purely for its side effect inside && or ||, where that call might silently never run. Third, does it use === rather than == when checking against specific values such as 0 or an empty string, given how many things compare loosely equal to false.

Swap the two elseif branches in ticket_price() and run it again with age 70 and membership true, to see the price change even though neither condition's text changed.

Write a function is_open( $hour ) that returns true only when $hour is 9 or later and earlier than 17, using a single && inside one if.

Change the body of one elseif branch to call a function that prints something, then call ticket_price() with values that should skip that branch, and confirm the function never runs at all.

Predict what if ( "false" ) does, as a stand-in condition, before running it, then check the prediction.

Rewrite ticket_price() checking the regular price first and the cheapest price last instead, and confirm a 70-year-old member still receives 4, noting that getting this right requires changing the comparisons themselves, not just their order.

Writing if ( $age = 70 ) (assignment) instead of if ( $age == 70 ) (comparison) inside a decision chain, silently overwriting $age with 70 for every visitor regardless of their real age, then comparing the freshly assigned value to itself.

Forgetting elseif and writing if, if, if instead, allowing two unrelated branches to run on the very same request when both of their conditions happen to be true together.

Comparing a price or count with a loose == 0 check, then being surprised when an empty string or null also satisfies that same check.

Nesting if statements many levels deep instead of combining conditions with && in one line, making it hard to tell, several screens later, which closing brace belongs to which opening condition.

Assuming else always pairs with the nearest if written above it, no matter what, when careless brace placement, or a skipped pair of braces on a single-line if, can attach an else to the wrong if entirely.

You can now trace, branch by branch, which single block of code will run for a given set of values, and explain why the order of elseif branches can change the outcome even when no condition's text changes. You can also predict when PHP will skip evaluating part of a condition entirely, rather than assuming every part of every condition always runs.