../courses.php

Procedural PHP

PHP

90

Variables That Remember Things

Why the same variable can hold a number on one line and text on the next.

A variable is set straight from a web form, where every value always arrives as text: $age = "20";. The very next line runs $age = $age + 1; and prints the result. A string holding digits is being added to a plain number. Most beginners expect this to either fail outright or print something glued together like "201". What actually happens, and why?

PHP automatically converts, or juggles, $age into the integer 20 the moment a math operator such as + is used on it, producing the integer 21, not text stuck together. PHP variables are not locked to one type for their whole life. The very same variable can hold a string in one line and a number in the next. It is the operator used on a value, not the variable's history, that decides what kind of conversion, if any, happens.

A variable in PHP is created the moment a value is assigned to it, using a name that starts with a $ sign, such as $name or $age. There is no separate step to declare a variable's type ahead of time, the way some other languages require.

PHP recognizes several basic kinds of value a variable can hold: text (called a string), whole numbers (integers), numbers with a decimal point (floats), true or false (booleans), lists of values (arrays), and a special value meaning nothing at all, null. A single variable can hold any of these, one at a time.

Quotes around a value, such as "20", always create a string, even when every character inside the quotes happens to be a digit. The presence of quotes, not the characters themselves, is what tells PHP this value is text rather than a number.

Two different operators look similar but do very different jobs: + performs real math, converting text into numbers first if needed, while . joins, or concatenates, values together as text, converting numbers into text first if needed. Choosing the wrong one produces a value that still looks plausible, not an error.

Variables created in the main body of a PHP file can be read and changed by any later line in that same file, in the order the lines actually run from top to bottom. A variable's current value, at any point in the program, is always whatever its most recent assignment set it to.

A short page using variables, value types, and a boolean check together

$age + 1 reads $age, the string "20", as numeric content, and performs real integer addition, producing 21, a true integer, not the text "201". This is different from joining $age onto another string with ., further down in the same file.

The . operator in $bio joins values together as text, regardless of their original type. Using . where + was meant, or the reverse, is a specific, common source of bugs, because both operators run without any error either way.

$has_signed_up holds one of PHP's two boolean values, true or false. A variable holding a boolean can be used directly inside an if ( ... ) with no comparison operator at all, because PHP treats the boolean value itself as the condition's answer.

$status is created only inside the if block, and only runs at all when $has_signed_up is true. By the time echo $status runs further down, $status exists because this particular run took that branch, not because it always exists no matter what.

$next_age was deliberately given a new name, rather than overwriting $age directly. This keeps $age's original string value available for the rest of the program. Reusing $age for the new value would have erased the original the moment the new assignment ran.

+ and . do different jobs, and mixing them up is silent

"20" + 5 produces the integer 25. "20" . 5 produces the text "205", two pieces glued together with nothing miscalculated. PHP does not stop the program for either operator. Choosing the wrong one for the situation produces a value that still looks plausible, not an error, which is exactly why this particular mix-up is easy to miss while testing.

Some text cannot become a number at all

A string such as "twenty", run through "twenty" + 5, does not raise a fatal error in modern PHP. It produces a warning and treats the non-numeric text as 0, so the result becomes 5, a number that is wrong by exactly the amount that should have been there, while the program keeps running as if nothing went wrong.

A variable can hold a different type a moment later

Nothing locks $age to "always a string" once it is declared. The very next line of a program can assign $age = 20.5;, a floating-point number, to the exact same name, and PHP allows it without complaint. A variable's type can only be known by reading its most recent assignment, never by its name or its first use.

Comparing with == treats several different-looking values as equal

Under PHP's default comparison, 0 == false, "" == false, "0" == false, and null == false are all true, even though each value is written differently and holds a different type. The fix, when an exact match is actually needed, is ===, which also checks type, and treats none of those pairs as the same value.

A variable that was never assigned does not quietly become empty

Reading a variable that was never set produces a specific warning, undefined variable, in modern PHP, and the value used in its place is null, not an empty string and not zero. Printing null directly produces no visible text at all, which is why a blank spot on a page is sometimes a sign of a missing assignment rather than a value that is genuinely empty.

Comparing with ==, which can match unrelated values

Comparing with ===, which also requires the same type

When an AI tool writes code that checks a value, three things are worth confirming. First, does it use === where an exact value and type match is actually intended, rather than ==, given how many different values compare loosely equal to false. Second, does it convert form-submitted text to a real number, using something like (int) or intval(), before doing math on it, rather than relying on automatic juggling in a spot where the input might not be numeric at all. Third, does it check whether a variable was actually assigned before using it, rather than assuming a default value that nothing in the code ever set.

Predict what $age + 1 produces if $age is set to the string "20.5" instead of "20", then run it to check.

Change if ( $has_signed_up ) to compare with === true instead of using the boolean directly, and confirm the program still behaves the same way.

Set $age to the non-numeric string "twenty", run the addition, and read the resulting warning message carefully.

Add a new variable that is never assigned a value, then try to echo it directly, and read what actually appears versus what you expected.

Replace the . in $bio with + instead, run the page, and explain in your own words why the output is wrong, rather than just noticing that it looks different.

Using a variable name that starts with a number, such as $1st_place, which PHP does not allow at all, and produces a parse error before the program runs even once.

Forgetting the $ in front of a variable name partway through a line of code, so PHP reads a bare word like age instead of $age, and treats it as an undefined constant rather than the variable that was intended.

Assuming that quotes alone change a value's type permanently. Writing $count = "5"; creates an actual string, not a number that merely looks like text. Only a later math operation converts it temporarily, for that one calculation alone.

Reassigning a counter or working variable to a brand-new, unrelated value partway through a long page, then continuing to use the same name later, expecting the original value, which is already gone.

Believing that two variables holding the same value, such as $a = 5; and $b = 5;, are somehow connected to each other. Changing $b afterward has no effect on $a at all, because each variable holds its own independent copy of a simple value like a number or a string.

You can now explain what type a variable is holding by looking at how it was last assigned, rather than by its name. You can predict whether a plus sign or a dot is the right operator for two values, and you can tell the difference between a variable that holds 0 or an empty string and one that was never assigned at all.