Variables And Constants

Programs become useful when values have names. A variable names a value that belongs to the current execution and may change as the program performs work. A constant names a value that should remain stable after it is defined.

Good names make code explain its data. $priceCents communicates more than $price, and MAX_ITEMS_PER_ORDER communicates more than LIMIT.

Assign A Value To A Variable

PHP variable names begin with $:

<?php

$productName = 'PHP Workbook';
$priceCents = 2499;

echo $productName, PHP_EOL;
echo $priceCents, PHP_EOL;

The assignment operator = stores the value on its right under the variable name on its left. Read $productName = 'PHP Workbook'; as "assign the string PHP Workbook to $productName," not as a mathematical equality claim.

After assignment, later statements can read the value by using the same variable name:

<?php

$courseName = 'PHP From Zero';

echo $courseName, PHP_EOL;
echo $courseName, PHP_EOL;

Both echo statements read the current value of $courseName. Reuse is one reason to name data instead of repeating a literal throughout the program.

Choose Names That Carry Meaning

A variable name can contain letters, digits, and underscores, but it cannot begin with a digit after $. These are conventional camelCase names:

<?php

$customerName = 'Grace';
$orderCount = 3;
$isReady = true;

Names should answer questions about the value:

• $customerName identifies whose name it is;
• $orderCount says the number represents orders;
• $priceCents includes the monetary unit;
• $createdAt suggests a creation timestamp;
• $isReady reads like a yes-or-no state.

Avoid vague names such as $data, $value, $thing, or $x when a domain name is available. Very short names are reasonable in a tiny mathematical expression or a familiar loop, but application state deserves descriptive names.

Do not encode a type into a name mechanically. $customerNames usefully indicates a collection because the plural changes meaning; $stringCustomerName usually adds noise and becomes misleading if the representation changes.

Variable Names Are Case-Sensitive

These are different variables:

<?php

$customerName = 'Grace';
$customername = 'Ada';

echo $customerName, PHP_EOL;
echo $customername, PHP_EOL;

The output is:

Grace
Ada

A case mismatch is therefore not cosmetic. If you assign $customerName and later read $customername, PHP treats the second spelling as another name. In modern PHP, reading an undefined variable produces a warning and the expression commonly continues with null, which can cause misleading output after the warning.

Use one naming convention consistently and let an editor, static analyser, and tests help catch misspellings.

Print Variables With Interpolation

Double-quoted strings can interpolate variables:

<?php

$productName = 'PHP Workbook';
$priceCents = 2499;

echo "$productName costs $priceCents cents\n";

Output:

PHP Workbook costs 2499 cents

PHP replaces each recognised variable reference with its current value.

Use braces when adjacent characters could be mistaken as part of the variable name:

<?php

$quantity = 3;

echo "Ordered: {$quantity}x\n";

Without braces, $quantityx would be read as a different variable name. Braces make the intended boundary explicit.

Single-quoted strings do not interpolate variables:

<?php

$name = 'Ada';

echo '$name', PHP_EOL;

This prints the literal characters $name. Choose double quotes when interpolation or escape sequences are intentional. Choose single quotes for literal text where interpolation is not wanted.

Concatenate Values Explicitly

The dot operator joins strings and printable values:

<?php

$name = 'Ada';
$role = 'developer';

echo $name . ' works as a ' . $role . '.' . PHP_EOL;

Output:

Ada works as a developer.

Concatenation is useful when a value sits outside a string or when single-quoted literal pieces make boundaries clearer.

Do not use + to join text. In PHP, + is an arithmetic operator. The operators lesson covers those rules in detail; for string joining, use . or a clearly interpolated double-quoted string.

Reassignment Changes Current State

A variable can receive a new value:

<?php

$orderStatus = 'pending';
echo "Status: $orderStatus\n";

$orderStatus = 'paid';
echo "Status: $orderStatus\n";

Output:

Status: pending
Status: paid

The second assignment does not create a history automatically. It replaces the current value associated with $orderStatus. If the program needs both values, give them separate names:

<?php

$previousStatus = 'pending';
$currentStatus = 'paid';

Reassignment should represent a real state transition, not uncertainty about naming. Reusing one variable for unrelated meanings makes code difficult to follow:

$result = 'Ada';
$result = 42;
$result = true;

Even though PHP can store different kinds of values in a variable, one name should keep one coherent meaning during a section of code.

Copy Simple Values Deliberately

Assigning one simple value variable to another gives the second variable that current value:

<?php

$originalStatus = 'pending';
$currentStatus = $originalStatus;
$currentStatus = 'paid';

echo "Original: $originalStatus\n";
echo "Current: $currentStatus\n";

Output:

Original: pending
Current: paid

Changing $currentStatus did not rename or overwrite $originalStatus. PHP references and object behavior add other rules later, but ordinary beginner code should not assume that two different variable names are secretly linked.

Initialise Before Reading

Assign a variable before using it:

<?php

$message = 'No orders found';
echo $message, PHP_EOL;

Do not rely on an undefined variable becoming an empty-looking value after a warning. Warnings are evidence of a broken assumption, and production error display settings can hide them while the bad behavior remains.

When a value is optional, model that choice explicitly in later code with a default, null, a condition, or validated input. Do not create optional behavior by misspelling or skipping an assignment.

Use Constants For Stable Program Rules

A constant is referenced without $:

<?php

const CURRENCY = 'GBP';
const MAX_ITEMS_PER_ORDER = 20;

echo CURRENCY, PHP_EOL;
echo MAX_ITEMS_PER_ORDER, PHP_EOL;

By convention, application constant names use uppercase words separated by underscores. The style makes a stable rule visually distinct from a variable.

A constant cannot be reassigned during the request:

const CURRENCY = 'GBP';
CURRENCY = 'USD';

The second line is not valid assignment syntax. If a value genuinely needs to change while the program runs, it should be a variable instead.

Good beginner constant candidates include a fixed application identifier, a deliberate batch limit, or a stable unit used by that code. Do not turn every literal into a constant. A value used once, such as a single output label, may be clearer inline.

const And define()

PHP also provides define():

<?php

define('APPLICATION_NAME', 'PHP From Zero');

echo APPLICATION_NAME, PHP_EOL;

For straightforward declarations known while writing the file, const is usually clearer and easier for tools to analyse:

<?php

const APPLICATION_NAME = 'PHP From Zero';

define() is a runtime function and can be useful when the constant name or declaration decision is produced dynamically, though dynamically named global constants are uncommon in well-structured application code.

Do not define the same constant twice. PHP warns because the first definition has already established the name for that process.

Do Not Confuse Constants With Configuration

A database host, API endpoint, feature flag, or deployment environment may stay unchanged during one request but differ between machines or deployments. That does not automatically make it a source-code constant.

Configuration normally comes from a controlled configuration file, environment mechanism, or dependency container and is validated at application startup. Hard-coding deployment-specific values as global constants makes testing and deployment changes harder.

Use a constant for a rule that belongs to the code. Use configuration for a value supplied by the environment. Use a variable for state held by the current execution.

Avoid Variable Variables In Beginner Code

PHP can interpret the value of one variable as another variable's name, but that feature obscures which data a script uses. Prefer an array or explicit mapping when selecting values by a dynamic key.

This direct code is easy to trace:

<?php

$customerName = 'Grace';
echo $customerName, PHP_EOL;

A naming feature is not automatically a good design choice. Predictable, statically visible variable names work better with readers, editors, analysers, and refactoring tools.

Common Variable And Constant Mistakes

What You Should Be Able To Do

After this lesson, you should be able to assign and read variables, choose descriptive case-consistent names, interpolate or concatenate values, explain reassignment, avoid undefined-variable behavior, declare constants with const, recognise define(), and choose among a variable, code constant, and deployment configuration based on the value's role.