PHP Operators — Why Loose Equality Exposes User Accounts

<?php

// Imagine you're building a simple invoice calculator
$itemPrice   = 49.99;   // price of one item in dollars
$quantity    = 3;        // how many the customer ordered
$discountPct = 10;       // 10% discount
$taxRate     = 0.08;     // 8% sales tax as a decimal

// --- Addition ---
$shippingFee = 5.99;
$subtotalWithShipping = $itemPrice + $shippingFee; // adds two values
echo "Item + Shipping: $" . $subtotalWithShipping . "\n"; // 55.98

// --- Subtraction ---
$refundAmount = 10.00;
$amountAfterRefund = $itemPrice - $refundAmount;  // removes the refund
echo "After Refund: $" . $amountAfterRefund . "\n"; // 39.99

// --- Multiplication ---
$lineTotal = $itemPrice * $quantity; // price times quantity = line total
echo "Line Total: $" . $lineTotal . "\n"; // 149.97

// --- Division ---
$discountAmount = ($discountPct / 100) * $lineTotal; // calculate discount value
echo "Discount Amount: $" . $discountAmount . "\n"; // 14.997

// --- Modulus (remainder after division) ---
$totalItems = 10;
$itemsPerBox = 3;
$leftoverItems = $totalItems % $itemsPerBox; // 10 divided by 3 = 3 remainder 1
echo "Items that won't fit in a full box: " . $leftoverItems . "\n"; // 1

// A classic use: check if a number is even or odd
$orderNumber = 4582;
if ($orderNumber % 2 === 0) {
    echo "Order #" . $orderNumber . " is an even-numbered order.\n";
} else {
    echo "Order #" . $orderNumber . " is an odd-numbered order.\n";
}

// --- Exponentiation ---
$base = 2;
$power = 10;
$result = $base ** $power; // 2 to the power of 10
echo "2 to the power of 10 is: " . $result . "\n"; // 1024

// --- Order of operations matters! ---
$wrongTotal  = $itemPrice * $quantity + $discountPct / 100; // PHP does * and / first
$correctTotal = ($itemPrice * $quantity) + ($discountPct / 100); // parentheses = intention is clear
echo "Wrong-looking (but technically same here): $" . $wrongTotal . "\n";
echo "With parentheses (explicit intention): $" . $correctTotal . "\n";

<?php

// --- Basic Assignment ---
$playerName  = "Alex";    // store the string "Alex" in $playerName
$playerScore = 0;          // player starts with zero points
$playerLevel = 1;          // player starts at level 1

echo "Starting state — Player: $playerName, Score: $playerScore, Level: $playerLevel\n";

// --- += (add and assign) ---
// Player picks up a coin worth 50 points
$playerScore += 50; // same as: $playerScore = $playerScore + 50
echo "After coin pickup — Score: $playerScore\n"; // 50

// Player gets a time bonus of 30 points
$playerScore += 30;
echo "After time bonus — Score: $playerScore\n"; // 80

// --- -= (subtract and assign) ---
// Player takes damage and loses 15 points
$playerScore -= 15; // same as: $playerScore = $playerScore - 15
echo "After taking damage — Score: $playerScore\n"; // 65

// --- *= (multiply and assign) ---
// Player activates a double-score power-up!
$playerScore *= 2; // same as: $playerScore = $playerScore * 2
echo "After double-score power-up — Score: $playerScore\n"; // 130

// --- /= (divide and assign) ---
// Score gets halved for using a hint
$playerScore /= 2; // same as: $playerScore = $playerScore / 2
echo "After hint penalty — Score: $playerScore\n"; // 65

// --- %= (modulus and assign) ---
// Rarely used, but here's a real example:
// "Wrap" the level number to stay within 1-5 cycle
$currentLevel = 7;
$currentLevel %= 5; // 7 % 5 = 2, wraps back into range 0-4
echo "Wrapped level (0-indexed): $currentLevel\n"; // 2

// --- .= (concatenate and assign) — extremely useful for building strings ---
$gameLog  = "[LOG] Game started. ";
$gameLog .= "Player $playerName joined. ";  // appends to existing string
$gameLog .= "Final score: $playerScore.";   // appends again
echo $gameLog . "\n";

<?php

// ===========================
// COMPARISON OPERATORS
// ===========================

$userAge        = 20;
$minimumAge     = 18;
$membershipTier = "gold";

// == (loose equality — compares VALUE only, converts types)
$numericString = "20";  // this is a STRING, not an integer
var_dump($userAge == $numericString);   // true — PHP converts "20" to 20 before comparing

// === (strict equality — compares VALUE and TYPE)
var_dump($userAge === $numericString);  // false — 20 (int) is not identical to "20" (string)

// != (not equal, loose)
var_dump($userAge != 18);  // true — 20 is not equal to 18

// !== (not identical, strict)
var_dump($userAge !== $numericString); // true — different types

// > < >= <=
var_dump($userAge > $minimumAge);   // true — 20 is greater than 18
var_dump($userAge >= $minimumAge);  // true — 20 is greater than or equal to 18
var_dump($userAge < 25);            // true — 20 is less than 25
var_dump($userAge <= 20);           // true — 20 is less than or equal to 20

echo "\n";

// Spaceship operator <=> (returns -1, 0, or 1)
// Great for custom sort functions
$priceA = 29.99;
$priceB = 49.99;
$comparison = $priceA <=> $priceB; // -1 means left is LESS THAN right
echo "Spaceship result: " . $comparison . "\n"; // -1

// ===========================
// LOGICAL OPERATORS
// ===========================

$isLoggedIn      = true;
$hasVerifiedEmail = true;
$isAdminUser     = false;
$isBannedUser    = false;

// && (AND) — both must be true
if ($isLoggedIn && $hasVerifiedEmail) {
    echo "Access granted: user is logged in AND has verified email.\n";
}

// || (OR) — at least one must be true
if ($isAdminUser || $hasVerifiedEmail) {
    echo "Can post content: user is admin OR has verified email.\n";
}

// ! (NOT) — flips the boolean
if (!$isBannedUser) {
    echo "User is not banned — showing dashboard.\n";
}

// Combining conditions
$canPublishPost = $isLoggedIn && $hasVerifiedEmail && !$isBannedUser;
echo "Can publish post: " . ($canPublishPost ? 'Yes' : 'No') . "\n"; // Yes

// Null coalescing operator ?? (PHP 7+)
// Returns the LEFT side if it's set and not null, otherwise returns the RIGHT side
$username = null;
$displayName = $username ?? "Guest"; // $username is null, so use "Guest"
echo "Welcome, " . $displayName . "!\n"; // Welcome, Guest!

$loggedInUsername = "sarah_dev";
$displayName2 = $loggedInUsername ?? "Guest"; // $loggedInUsername is set, so use it
echo "Welcome, " . $displayName2 . "!\n"; // Welcome, sarah_dev!

<?php

// --- Basic Concatenation ---
$firstName = "John";
$lastName  = "Doe";
$fullName  = $firstName . " " . $lastName;
echo "Full name: " . $fullName . "\n"; // John Doe

// Building a sentence
$noun = "fox";
$verb = "jumps";
$sentence = "The quick brown " . $noun . " " . $verb . " over the lazy dog.";
echo $sentence . "\n";

// Number to string conversion
$count = 5;
echo "You have " . $count . " new messages.\n"; // You have 5 new messages.

// ----- Compound assignment .= -----
$logMessage = "[START] ";
$logMessage .= "User logged in. ";
$logMessage .= "IP 192.168.1.1. ";
$logMessage .= "[END]";
echo $logMessage . "\n"; // [START] User logged in. IP 192.168.1.1. [END]

// ----- Precedence Gotcha -----
$price = 10;
$tax = 2;
// Intent: "Total: 12"
$result1 = "Total: " . $price + $tax;  // Warning: + has higher precedence than .
echo "Without parentheses: " . $result1 . "\n"; // 12 (but produces a warning in PHP 8)
$result2 = "Total: " . ($price + $tax); // Correct
echo "With parentheses: " . $result2 . "\n"; // Total: 12

<?php

// ===========================
// INCREMENT / DECREMENT
// ===========================

$pageViews = 100;

// Post-increment: RETURNS current value, THEN increments
$viewsBeforeIncrement = $pageViews++;  // $viewsBeforeIncrement gets 100, THEN $pageViews becomes 101
echo "Returned value (post-increment): " . $viewsBeforeIncrement . "\n"; // 100
echo "pageViews after post-increment:  " . $pageViews . "\n";             // 101

// Pre-increment: INCREMENTS first, THEN returns new value
$newPageViews = ++$pageViews;  // $pageViews becomes 102, THEN $newPageViews gets 102
echo "Returned value (pre-increment):  " . $newPageViews . "\n"; // 102
echo "pageViews after pre-increment:   " . $pageViews . "\n";    // 102

// Decrement works the same way
$stockCount = 5;
$stockCount--; // post-decrement — one item sold
echo "Stock remaining: " . $stockCount . "\n"; // 4

echo "\n";

// ===========================
// TERNARY OPERATOR (?:)
// ===========================

$cartItemCount = 3;

// Long way:
if ($cartItemCount > 0) {
    $cartStatus = "Items in cart";
} else {
    $cartStatus = "Cart is empty";
}

// Ternary — same logic, one line:
$cartStatus = ($cartItemCount > 0) ? "Items in cart" : "Cart is empty";
echo "Cart status: " . $cartStatus . "\n"; // Items in cart

// Real use — displaying user role label
$isAdmin   = false;
$roleLabel = $isAdmin ? "Administrator" : "Standard User";
echo "Role: " . $roleLabel . "\n"; // Standard User

echo "\n";

// ===========================
// NULL-SAFE OPERATOR (?->) — PHP 8.0+
// ===========================

class UserProfile {
    public string $bio;
    public function __construct(string $bio) {
        $this->bio = $bio;
    }
    public function getBio(): string {
        return $this->bio;
    }
}

// Simulate a user that exists and one that doesn't
$activeUser  = new UserProfile("Full-stack developer from Toronto.");
$deletedUser = null; // this user no longer exists

// Without null-safe operator, you'd need:
// if ($deletedUser !== null) { $bio = $deletedUser->getBio(); } else { $bio = null; }

// With null-safe operator (?->) — clean and safe:
$activeBio  = $activeUser?->getBio();  // works fine, returns the bio
$deletedBio = $deletedUser?->getBio(); // $deletedUser is null — returns null safely, no error

echo "Active user bio: " . ($activeBio ?? 'No bio available') . "\n";
echo "Deleted user bio: " . ($deletedBio ?? 'No bio available') . "\n";

<?php

// ===========================
// BITWISE OPERATORS
// ===========================

// Define permission flags as powers of 2
$PERMISSION_READ   = 1;   // 001
$PERMISSION_WRITE  = 2;   // 010
$PERMISSION_EXECUTE = 4;  // 100

// Assign user permissions using bitwise OR
$userPermissions = $PERMISSION_READ | $PERMISSION_EXECUTE; // 101 = 5

// Check permissions using bitwise AND
if ($userPermissions & $PERMISSION_READ) {
    echo "User has READ permission.\n";
}
if ($userPermissions & $PERMISSION_WRITE) {
    echo "User has WRITE permission.\n";
} else {
    echo "User does NOT have WRITE permission.\n";
}

// Bitwise shift
$value = 4; // 100 in binary
$shiftedLeft = $value << 1;  // 1000 = 8
$shiftedRight = $value >> 1; // 10   = 2
echo "4 << 1 = " . $shiftedLeft . "\n";
echo "4 >> 1 = " . $shiftedRight . "\n";

// ===========================
// TYPE OPERATORS
// ===========================

class User {};
class Admin extends User {};

$user = new Admin();
echo "Is user an instance of User? " . ($user instanceof User ? "Yes" : "No") . "\n"; // Yes
echo "Is user an instance of Admin? " . ($user instanceof Admin ? "Yes" : "No") . "\n"; // Yes

// Error control operator @ — suppress warnings (use sparingly)
$result = @file_get_contents("nonexistent.txt"); // Suppresses warning, $result = false
if ($result === false) {
    echo "File not found (error suppressed).\n";
}

// io.thecodeforge — php tutorial

$defaults = [
    'host' => 'localhost',
    'port' => 5432,
    'timeout' => 30,
];

$user_config = [
    'host' => 'prod-db.internal',
    'port' => 5432,
    'dbname' => 'orders',
];

// Union keeps first-match keys — user config wins
$merged = $user_config + $defaults;

var_dump($merged);
/*
array(4) {
  ["host"]=> string(19) "prod-db.internal"
  ["port"]=> int(5432)
  ["dbname"]=> string(6) "orders"
  ["timeout"]=> int(30)
}
*/

// io.thecodeforge — php tutorial

$target = $_GET['host'] ?? '';
// NEVER DO THIS — direct user input into backticks
$result = `ping -c 2 $target`;
echo $result;

// Safer but still not great — no timeout, no stderr
$escaped = escapeshellarg($target);
$result = `ping -c 2 $escaped`;
echo $result;

// The right way: use symfony/process or proc_open
// proc_open gives you pipes for stdin/stdout/stderr + exit codes