Functions ⚡

<?php
declare(strict_types=1); // turns type mismatches into errors — see Common Errors

// Define once, call as many times as you like.
// 'function' starts a definition; the name follows the same rules as a variable.
function sayHello(): void {        // ': void' means "returns nothing"
    echo "Hello, World!\n";
}

sayHello();                        // call it — runs the body
sayHello();                        // call again — that's the whole point of a function

// A PARAMETER is an input. ': string' after the ) is the RETURN TYPE.
function greet(string $name): string {
    return "Hello, $name!";        // 'return' hands a value back to the caller
}

echo greet("Alice") . "\n";        // prints what greet() returned
echo greet("Bob") . "\n";

// A function that returns a number you can keep using.
function square(int $n): int {
    return $n * $n;
}

$result = square(5);               // store the returned value
echo "5 squared is $result\n";
?>

Hello, World!
Hello, World!
Hello, Alice!
Hello, Bob!
5 squared is 25

<?php
declare(strict_types=1);

// DEFAULT VALUE: $role is "Student" unless the caller supplies one.
// Parameters with defaults must come AFTER ones without.
function introduce(string $name, string $role = "Student"): string {
    return "$name is a $role";
}

echo introduce("Alice", "Developer") . "\n"; // both arguments given
echo introduce("Bob") . "\n";                 // $role falls back to "Student"

// NULLABLE TYPE: '?string' means "a string OR null".
// UNION TYPE (PHP 8): 'int|string' means "an int OR a string".
function label(int|string $id, ?string $note = null): string {
    $text = "ID: $id";
    if ($note !== null) {          // only add the note when one was passed
        $text .= " ($note)";
    }
    return $text;
}

echo label(42) . "\n";                    // note is null, so it's left off
echo label("A7", "priority") . "\n";      // id is a string here — both types allowed

// NAMED ARGUMENTS (PHP 8): name the parameter, so order no longer matters
// and you can skip optional ones in the middle.
echo introduce(role: "Mentor", name: "Carol") . "\n";
?>

Alice is a Developer
Bob is a Student
ID: 42
ID: A7 (priority)
Carol is a Mentor

<?php
declare(strict_types=1);

// VARIADIC parameter: '...$numbers' collects every extra argument into an array.
function sum(int ...$numbers): int {
    return array_sum($numbers);    // $numbers is a normal array here
}

echo "sum(1, 2, 3) = " . sum(1, 2, 3) . "\n";
echo "sum(10, 20, 30, 40) = " . sum(10, 20, 30, 40) . "\n";
echo "sum() = " . sum() . "\n";    // zero arguments is fine too

// PASS BY REFERENCE: '&$total' lets the function change the caller's variable.
// Without the &, PHP passes a COPY and the original is untouched.
function addTip(float &$total, float $tip): void {
    $total += $tip;                // this edits the caller's $bill directly
}

$bill = 40.0;
addTip($bill, 6.0);                // no '=' needed — $bill is modified in place
echo "Bill after tip: $bill\n";    // 46

// Compare: pass by VALUE (no &) leaves the original alone.
function tryToReset(float $n): void {
    $n = 0;                        // only the local copy changes
}
$score = 99.0;
tryToReset($score);
echo "Score is still: $score\n";   // still 99
?>

sum(1, 2, 3) = 6
sum(10, 20, 30, 40) = 100
sum() = 0
Bill after tip: 46
Score is still: 99

<?php
declare(strict_types=1);

// ARROW FUNCTION (PHP 7.4+): 'fn(args) => expression'.
// It AUTOMATICALLY captures variables from the surrounding scope.
$factor = 3;
$scale = fn(int $x): int => $x * $factor;   // $factor is captured automatically
echo "scale(5) = " . $scale(5) . "\n";       // 15

// Arrow functions shine as callbacks for array_map / array_filter.
$numbers = [1, 2, 3, 4, 5];
$squares = array_map(fn($n) => $n * $n, $numbers);
echo "squares: [" . implode(", ", $squares) . "]\n";

// CLOSURE (anonymous function): use 'function' and 'use' to capture variables.
// Unlike fn(), a closure does NOT capture automatically — you list what it needs.
$prefix = "Item";
$makeLabel = function (int $i) use ($prefix): string {
    return "$prefix #$i";          // $prefix came from 'use ($prefix)'
};
echo $makeLabel(1) . "\n";
echo $makeLabel(2) . "\n";

// SCOPE & global: a function can't see outer variables unless told to.
$siteName = "LearnCodingFast";
function showSite(): void {
    global $siteName;              // pull the global variable into the function
    echo "Welcome to $siteName\n";
}
showSite();
?>

scale(5) = 15
squares: [1, 4, 9, 16, 25]
Item #1
Item #2
Welcome to LearnCodingFast

<?php
declare(strict_types=1);
// 🎯 YOUR TURN — fill in each blank marked ___ , then run it.

// 1) Add the RETURN TYPE so this function promises to return an int.
function area(int $w, int $h): ___ {   // 👉 the type is  int
    return $w * $h;
}

// 2) Give $tax a DEFAULT VALUE of 0.2 so it can be left out.
function priceWithTax(float $price, float $tax = ___): float {  // 👉 0.2
    return $price * (1 + $tax);
}

echo "area(4, 5) = " . area(4, 5) . "\n";
echo "priceWithTax(100) = " . priceWithTax(100) . "\n"; // uses the default 0.2

// ✅ Expected output:
//    area(4, 5) = 20
//    priceWithTax(100) = 120
?>

area(4, 5) = 20
priceWithTax(100) = 120

<?php
declare(strict_types=1);
// 🎯 YOUR TURN — finish the arrow function and the closure.

$numbers = [1, 2, 3, 4];

// 1) Write an ARROW FUNCTION that doubles its argument.
$double = ___ => $n * 2;          // 👉 fn($n)
$doubled = array_map($double, $numbers);
echo "[" . implode(", ", $doubled) . "]\n";

// 2) This closure needs the $unit variable. Capture it with 'use'.
$unit = "kg";
$weigh = function (int $w) ___ : string {   // 👉 use ($unit)
    return "$w$unit";
};
echo $weigh(70) . "\n";

// ✅ Expected output:
//    [2, 4, 6, 8]
//    70kg
?>

[2, 4, 6, 8]
70kg