Variables

Course 1 · Ch 2

Variables, Data Types, and Type Juggling

Storing values, the core PHP types, and the automatic type conversion that makes PHP genuinely different from strictly-typed languages

Variables are how a script holds onto a value to use later. PHP variables are refreshingly simple to declare — no separate type declaration step required — but understanding exactly what's happening underneath that simplicity, especially around type juggling, avoids a class of subtle bug that trips up many PHP beginners.

Declaring Variables

<?php
  $name = "Philip";
  $age = 35;
  $isLearning = true;

  echo "$name is $age years old.";
?>

Every PHP variable name starts with a dollar sign ($) — that's not optional punctuation, it's a required part of the variable's name. No separate "declare this as a string/integer" step exists; PHP figures out the type automatically from the assigned value.

Variable names are case-sensitive

$name and $Name are two genuinely different variables — a frequent source of confusing "undefined variable" warnings when a typo accidentally changes the case partway through a script.

The Core PHP Data Types

string

Text — "Philip", 'PHP'

int

Whole numbers — 42, -7

float

Decimal numbers — 3.14, -0.5

bool

true or false

array

Ordered collections — covered fully in Chapter 6

null

Represents "no value at all"

Checking a Variable's Type

<?php
  $value = 42;
  echo gettype($value);   // "integer"

  var_dump($value);      // shows type AND value together, very useful for debugging
?>

var_dump() is genuinely one of the most-used debugging tools in everyday PHP — it shows both the type and the exact value of whatever's passed to it, which becomes especially useful once type juggling (below) makes a value's actual type less obvious from reading the code alone.

Type Juggling — PHP's Automatic Type Conversion

PHP is "loosely typed" — it automatically converts between types as needed in many contexts, rather than requiring an explicit conversion every time. This is convenient, and also the source of some of PHP's most commonly mocked quirks.

"5" + 3 produces the integer 8 — PHP converted the numeric string automatically for the arithmetic operation

<?php
  echo "5" + 3;        // 8 — the string "5" is converted to int for the addition
  echo "5" . 3;        // "53" — the . operator concatenates, treating 3 as a string instead
  echo true + 1;        // 2 — true becomes 1, false becomes 0 in numeric contexts
  var_dump(0 == "0");    // true — loosely compared, juggled to match
  var_dump(0 === "0");   // false — strictly compared, different types, no juggling
?>

== vs === is the single most important type-juggling distinction to internalise early

== ("loose equality") allows type juggling before comparing — 0 == "abc" historically even evaluated to true in older PHP versions, a famously confusing quirk. === ("strict equality") requires both the value AND the type to match exactly, with zero juggling involved. As a strong default habit, prefer === unless you have a specific, deliberate reason to allow type juggling in a comparison.

Explicit Type Casting — When You Want Control

<?php
  $str = "42";
  $num = (int)$str;    // explicitly cast to integer, rather than relying on automatic juggling

  $num2 = 3.7;
  $asInt = (int)$num2;  // 3 — casting float to int truncates, doesn't round
?>

Casting (float)3.7 to int truncates, it doesn't round

(int)3.7 gives 3, not 4 — a genuinely easy assumption to get wrong if you expect mathematical rounding. Use round() explicitly first if rounding (rather than truncation) is actually what's needed.

Constants

<?php
  define('SITE_NAME', 'osztromok.com');
  echo SITE_NAME; // no $ prefix for constants, and the value can never change after definition
?>

A constant, once defined, cannot be reassigned later in the script — genuinely useful for values that should never change, like a site name or a fixed configuration value.

Coding Challenges

Challenge 1

Create three variables: $firstName (string), $age (int), and $heightInMeters (float). Use var_dump() on each one to confirm PHP correctly identified each type, then echo a sentence combining all three using string interpolation.

📄 View solution

Challenge 2

Predict, then verify with var_dump, the result of each: "10" + 5, "10" . 5, "3.5" + "1.5", and (int)"7 apples". Write a one-sentence explanation for each result.

📄 View solution

Challenge 3

Write code comparing the integer 1 and the string "1" using both == and ===, echoing a clear message explaining what each comparison returned and why they differ.

📄 View solution

Chapter 2 Quick Reference

$variableName — the $ prefix is required; no separate type declaration needed
Variable names are case-sensitive — $name and $Name are different variables
Core types: string, int, float, bool, array, null
gettype() / var_dump() — check a variable's actual type; var_dump shows type and value together
Type juggling — PHP automatically converts types as needed in many contexts (arithmetic, comparisons)
== (loose) vs === (strict) — prefer === as a default habit to avoid juggling surprises
(int)/(float)/(string) — explicit casting; casting float to int truncates, doesn't round
define('NAME', value) — constants, no $ prefix, value never changes once set
Next chapter: operators and control structures — if/else, switch