PHP Fundamentals: Syntax, Variables, Data Types, and Operators

What Is PHP?

PHP (PHP: Hypertext Preprocessor) is a widely used, open-source, server-side scripting language designed primarily for web development. Unlike HTML, which a browser renders directly, PHP code runs on the web server and sends finished HTML to the client. PHP files use the `.php` extension. Every PHP block opens with `<?php` and, when mixed with HTML, closes with `?>`.

PHP Syntax Basics

A PHP statement ends with a semicolon (`;`). Missing semicolons are one of the most common beginner errors and will halt script execution with a parse error. Comments follow the same conventions as many C-style languages:

• Single-line: `// comment` or `# comment`
• Multi-line: `/ comment /`

PHP is case-sensitive for variable names but case-insensitive for built-in function names and keywords.

Variables and Naming Rules

In PHP every variable name starts with a dollar sign (`$`). Variable names must begin with a letter or underscore, followed by letters, digits, or underscores. They may not contain spaces or start with a digit.

```php

$billAmount = 45.00; // valid

$_taxRate = 0.08; // valid

$2fast = 10; // INVALID — starts with a digit

```

PHP is a loosely typed (dynamically typed) language: you do not declare a type when you create a variable. The interpreter determines the type from the value you assign, and that type can change during execution.

Primitive Data Types

PHP has four scalar (primitive) data types:

| Type | Description | Example literal |

|------|-------------|----------------|

| `int` | Whole numbers, positive or negative | `42`, `-7` |

| `float` | Numbers with a decimal point (also called `double`) | `3.14`, `-0.5` |

| `string` | Text enclosed in single or double quotes | `'hello'`, `"world"` |

| `bool` | Logical true or false | `true`, `false` |

Two additional types you will encounter are `null` (no value) and arrays (covered in a later lesson).

Use `gettype($var)` or `var_dump($var)` to inspect a variable's current type and value — invaluable when debugging.

Type Juggling

Type juggling is PHP's automatic conversion of a value from one type to another based on context. This is a powerful feature but also a common source of bugs.

```php

$a = "5"; // string

$b = 3; // int

$c = $a + $b; // PHP converts "5" to int 5; $c === 8 (int)

```

When a string that begins with a non-numeric character is added to a number, PHP converts it to `0`.

```php

$x = "hello" + 10; // $x === 10

```

Because type juggling can produce surprising results, always use strict comparison operators (see below) when the type matters.

Arithmetic Operators

| Operator | Meaning | Example | Result |

|----------|---------|---------|--------|

| `+` | Addition | `5 + 3` | `8` |

| `-` | Subtraction | `5 - 3` | `2` |

| `` | Multiplication | `5 3` | `15` |

| `/` | Division | `7 / 2` | `3.5` |

| `%` | Modulus (remainder) | `7 % 2` | `1` |

| `` | Exponentiation | `2 3` | `8` |

Integer division that produces a non-whole result automatically returns a `float`.

Comparison Operators

Comparison operators return a `bool`.

• `==` — equal value (type juggling applies)
• `===` — identical: equal value and equal type (strict)
• `!=` or `<>` — not equal (loose)
• `!==` — not identical (strict)
• `<`, `>`, `<=`, `>=` — relational comparisons

Best practice: prefer `===` and `!==` unless you specifically need loose comparison. Loose equality between `0` and `"foo"` evaluated to `true` in older PHP versions, a notorious source of security bugs.

Logical Operators

| Operator | Meaning | Example |

|----------|---------|--------|

| `&&` or `and` | Both true | `$a && $b` |

| `\|\|` or `or` | At least one true | `$a \|\| $b` |

| `!` | Not | `!$a` |

Note that `&&` has higher precedence than `and`; prefer `&&` and `||` in most expressions to avoid precedence surprises.

Reading from the URL Query String

The superglobal `$_GET` array holds values passed through the URL query string. For example, a request to `calc.php?bill=50&tip=18` makes `$_GET['bill']` equal to the string `'50'` and `$_GET['tip']` equal to `'18'`. Always cast or validate these values before arithmetic:

```php

$bill = (float) $_GET['bill'];

$tip = (float) $_GET['tip'];

```

Safety and Best Practices

Web programming does not involve physical electrical hazards the way hardware work does, but it has its own safety concerns:

• Never trust user input. Values from `$_GET`, `$_POST`, and other superglobals are controlled by the user and must be validated and sanitized before use or display.
• Escape output. Use `htmlspecialchars()` when printing user-supplied data in HTML to prevent cross-site scripting (XSS).
• Keep credentials out of code. Database passwords and API keys should never appear as plain text in a PHP file committed to version control.
• Error reporting in development only. Enable `display_errors` in your local environment, but never on a production server, as error messages can reveal sensitive information.

These habits begin on day one — they are far easier to build than to retrofit.