الوظائف المتقدمة

<?php
function sum(...$numbers): int {
    return array_sum($numbers);
}

echo sum(1, 2);           // 3
echo sum(1, 2, 3, 4, 5);  // 15
echo sum();               // 0

// You can also have fixed parameters before the variadic ones
function sendMessage(string $to, string ...$messages): void {
    foreach ($messages as $msg) {
        echo "Sent to {$to}: {$msg}<br>";
    }
}

sendMessage("John", "Good morning", "How's lunch?", "Good night");
// Sent to John: Good morning
// Sent to John: How's lunch?
// Sent to John: Good night
?>

<?php
function add(int $a, int $b, int $c): int {
    return $a + $b + $c;
}

$nums = [1, 2, 3];
echo add(...$nums);  // 6 (the array is spread into 3 separate arguments)

// Commonly used with array_push and similar functions
$stack = ["a", "b"];
array_push($stack, ...["c", "d", "e"]);
print_r($stack);  // ["a", "b", "c", "d", "e"]
?>

<?php
function createUser(
    string $name,
    int $age,
    string $email = "",
    bool $isAdmin = false
): array {
    return compact('name', 'age', 'email', 'isAdmin');
}

// Traditional: must follow parameter order
$u1 = createUser("John", 25, "john@example.com", true);

// Named arguments: order doesn't matter — skip parameters with defaults
$u2 = createUser(
    name: "Jane",
    age: 22,
    isAdmin: true
    // email uses the default
);

// When a function has many parameters, named arguments dramatically improve readability
setcookie(
    name: "theme",
    value: "dark",
    expires_or_options: time() + 3600,
    httponly: true
);
?>

<?php
// Pass by value (default): internal modification doesn't affect the outside
function addTen(int $n): void {
    $n += 10;
}
$x = 5;
addTen($x);
echo $x;  // 5 (unchanged)

// Pass by reference: internal modification directly affects the outer variable
function addTenRef(int &$n): void {
    $n += 10;
}
addTenRef($x);
echo $x;  // 15 (changed!)
?>

<?php
$globalVar = "I'm outside";

function test(): void {
    // echo $globalVar;  // Warning: Undefined variable
    // Functions can't directly access outer variables

    $localVar = "I'm inside";
    echo $localVar;  // OK
}

test();
// echo $localVar;  // Warning: can't access the function's inner variable either
?>

<?php
$counter = 0;

function increment(): void {
    global $counter;  // Declare: I want to use the global variable
    $counter++;
}

increment();
increment();
echo $counter;  // 2
?>

<?php
$name = "John";

function showName(): void {
    echo $GLOBALS['name'];  // John
}
showName();
?>

<?php
function getNextId(): int {
    static $id = 0;
    $id++;
    return $id;
}

echo getNextId();  // 1
echo getNextId();  // 2
echo getNextId();  // 3

// A static variable is only initialized once — on the first call
// Subsequent calls preserve the previous value
?>

<?php
// Anonymous function assigned to a variable
$greet = function(string $name): string {
    return "Hello, {$name}!";
};

echo $greet("John");  // Hello, John!

// Passed as an argument to another function (callback)
$numbers = [1, 2, 3, 4, 5];
$doubled = array_map(function($n) {
    return $n * 2;
}, $numbers);
print_r($doubled);  // [2, 4, 6, 8, 10]
?>

<?php
$prefix = "User";

// ❌ Wrong: $prefix is not visible inside the anonymous function
// $greet = function($name) {
//     return "{$prefix}: {$name}";
// };

// ✅ Correct: import the outer variable with use
$greet = function($name) use ($prefix): string {
    return "{$prefix}: {$name}";
};

echo $greet("John");  // User: John

// Import by reference (allows modifying the outer variable)
$count = 0;
$inc = function() use (&$count): void {
    $count++;
};
$inc(); $inc();
echo $count;  // 2
?>

<?php
$factor = 3;

// Anonymous function syntax
$anon = function($n) use ($factor) {
    return $n * $factor;
};

// Arrow function syntax (automatically captures $factor)
$arrow = fn($n) => $n * $factor;

echo $anon(5);   // 15
echo $arrow(5);  // 15

// The golden pair with array_map
$nums = [1, 2, 3, 4, 5];
$tripled = array_map(fn($n) => $n * $factor, $nums);
print_r($tripled);  // [3, 6, 9, 12, 15]
?>

<?php
// Method 1: function name as a string
function double(int $n): int {
    return $n * 2;
}
$result = array_map('double', [1, 2, 3]);
// 'double' (with quotes) — the function name string is passed to array_map

// Method 2: anonymous function
$result = array_map(fn($n) => $n * 3, [1, 2, 3]);

// Method 3: callable type declaration
function apply(callable $fn, array $data): array {
    return array_map($fn, $data);
}

$result = apply('double', [1, 2, 3]);          // ✅
$result = apply(fn($n) => $n * 2, [1, 2, 3]);  // ✅
// apply(123, [1, 2, 3]);  // TypeError!
?>