PHP Functions — Parameters, Scope & Reusable Code Guide

PHP functions are reusable blocks of code that accept input, perform operations, and return results — they prevent repetition and make your code organized, testable, and maintainable.

What You’ll Learn

By the end of this tutorial, you’ll write reusable, type-safe functions with parameters and return values, understand variable scope, use closures and arrow functions, and handle callbacks.

Why Functions Matter

Functions are the building blocks of every real application. Durga Antivirus Pro uses functions to scan files, check signatures, and generate reports — each function does one thing well. Doda Browser uses functions for bookmark management, history search, and sync. Without functions, you’d copy-paste the same code everywhere, making bugs inevitable and maintenance a nightmare.

Functions Learning Path

    flowchart LR
  A[PHP Basics] --> B[Control Flow]
  B --> C[Functions]
  C --> D[Arrays]
  D --> E[Forms]
  C --> F{You Are Here}
  style F fill:#f90,color:#fff
  

What Is a Function? (The “Why” First)

Think of a function like a vending machine. You put in coins (parameters), press a button (call the function), and get a snack (return value). The vending machine’s internal workings are hidden — you just need to know what goes in and what comes out.

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

echo add(3, 4);  // 7
?>

Line by line:

• function add(...) — declares a function named add
• int $a, int $b — requires two integers as input
• : int — promises to return an integer
• return $a + $b — does the math and sends back the result
• add(3, 4) — calls the function with values 3 and 4

Parameters — What Goes In

Required Parameters

<?php
function fullName(string $first, string $last): string {
    return "$first $last";
}
echo fullName("John", "Doe");  // John Doe
// fullName("John");  ← Error: missing argument
?>

All parameters are required by default. If you call the function without all arguments, PHP throws a fatal error.

Default Parameters

<?php
function greet(string $name = "Guest"): string {
    return "Hello, $name!";
}
echo greet();        // Hello, Guest!
echo greet("Alice"); // Hello, Alice!
?>

Default parameters let you make arguments optional. They must come after required parameters.

Type Declarations — Why They Matter

<?php
declare(strict_types=1);

function process(
    string $name,
    int $age,
    float $score,
    bool $active
): string {
    return "$name ($age) - $score - " . ($active ? "Active" : "Inactive");
}
?>

Type declarations act like bouncers at a club. They check each argument’s type before letting it into the function. declare(strict_types=1) makes the bouncer strict — no type coercion allowed.

Union & Nullable Types (PHP 8+)

<?php
function format(int|string $value): string {
    return "Value: $value";
}

function findUser(?int $id): ?string {
    if ($id === null) return null;
    return "User #$id";
}
?>

Union types (int|string) say “this can be either type.” Nullable types (?int) say “this can be the type or null.”

Return Values — What Comes Out

<?php
function log(string $message): void {
    file_put_contents("log.txt", "$message\n", FILE_APPEND);
}

function parse(mixed $input): int|false {
    return is_numeric($input) ? (int)$input : false;
}
?>

• : void — returns nothing, just does work
• : int — promises to return an integer
• : int|false — returns either an integer or false (union return)
• : never (PHP 8.1+) — never returns (always throws or exits)

Variable Scope — The Invisible Walls

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

function testScope() {
    $localVar = "I'm local";
    global $globalVar;
    echo $globalVar;  // I'm global
}

testScope();
// echo $localVar;  ← undefined! Outside the function
?>

Functions create a closed room. Variables outside can’t see in, and variables inside can’t see out — unless you use global to break down the wall.

Anonymous Functions & Closures

<?php
$greet = function(string $name): string {
    return "Hello, $name!";
};
echo $greet("Alice");  // Hello, Alice!

// Arrow function (PHP 7.4+)
$multiplier = 3;
$doubled = array_map(
    fn($n) => $n * $multiplier,
    [1, 2, 3, 4, 5]
);
// [3, 6, 9, 12, 15]
?>

Arrow functions automatically “remember” variables from the parent scope. Regular closures need use ($variable) to do the same.

Common Mistakes

1. Not Declaring strict_types

Without it, PHP silently converts “5” to 5. With it, mismatched types throw errors. Always use declare(strict_types=1) for new code.

2. Forgetting to Return

A function without return returns null. If you declared a return type, PHP throws TypeError.

3. Modifying Globals Accidentally

$count = 0;
function increment() {
    global $count;  // Without this, $count++ creates a local variable!
    $count++;
}

4. Variable Shadowing in Closures

$name = "Alice";
$greet = function() use ($name) {
    $name = "Bob";  // Only changes the copy, not the original
};

5. Too Many Arguments

A non-variadic function rejects extra arguments with a fatal error.

Practice Questions

1. What does declare(strict_types=1) do?

Enables strict type checking in the current file. Without it, PHP coerces types (e.g., "5" becomes 5). With it, mismatched types throw TypeError.

2. What’s the difference between fn($x) => $x * 2 and function($x) { return $x * 2; }?

Arrow functions (PHP 7.4+) are shorter, automatically inherit parent scope, and are limited to a single expression. Anonymous functions use function keyword, need use for scope, and support multiple statements.

3. Can PHP functions return multiple values?

PHP doesn’t support multiple returns, but you can return an array and use destructuring: [$min, $max] = minMax([3, 1, 4]);.

4. What happens if a typed function forgets to return a value?

PHP throws a TypeError: Return value must be of type X, null returned.

5. Challenge: Write a recursive function to calculate the Fibonacci sequence up to N terms.

<?php
function fibonacci(int $n): array {
    if ($n <= 0) return [];
    if ($n === 1) return [0];
    $seq = [0, 1];
    for ($i = 2; $i < $n; $i++) {
        $seq[] = $seq[$i - 1] + $seq[$i - 2];
    }
    return $seq;
}
print_r(fibonacci(10));
?>

FAQ

Try It Yourself

Create math.php:

<?php
declare(strict_types=1);

function factorial(int $n): int {
    if ($n < 0) throw new InvalidArgumentException("Negative not allowed");
    if ($n <= 1) return 1;
    return $n * factorial($n - 1);
}

function isPrime(int $n): bool {
    if ($n < 2) return false;
    for ($i = 2; $i * $i <= $n; $i++) {
        if ($n % $i === 0) return false;
    }
    return true;
}

echo "Factorial of 6: " . factorial(6) . "\n";  // 720
echo "Is 17 prime? " . (isPrime(17) ? "Yes" : "No") . "\n";  // Yes
?>

Run with php math.php.

What’s Next

What’s Next

Congratulations on completing this Php Functions tutorial! Here’s where to go from here:

• Practice daily — Consistency is more important than long study sessions
• Build a project — Apply what you learned by building something real
• Explore related topics — Check out other tutorials in the same category
• Join the community — Discuss with other learners and share your progress

Remember: every expert was once a beginner. Keep coding!