Functions and User-Defined Functions

Functions are self-contained blocks of code designed to perform a specific task. They are fundamental building blocks in almost all programming languages, including PHP. The primary purpose of functions is to encapsulate a set of operations that can be reused multiple times throughout a program, leading to cleaner, more organized, and more maintainable code.

Why Use Functions?

1. Reusability (DRY - Don't Repeat Yourself): Instead of writing the same code multiple times, you can define it once in a function and call that function whenever needed. This reduces redundancy and makes the code more efficient.
2. Modularity: Functions break down a large program into smaller, manageable, and independent modules. Each function can be developed, tested, and debugged separately.
3. Readability: Well-named functions make the code easier to understand by describing the purpose of a block of code.
4. Maintainability: If a piece of logic needs to be changed, you only need to modify it in one place (the function definition) rather than searching and updating multiple occurrences.
5. Abstraction: Functions allow you to focus on *what* a piece of code does, rather than *how* it does it, by hiding the implementation details.

User-Defined Functions in PHP

PHP allows you to define your own functions. A user-defined function is created using the `function` keyword, followed by a function name, parentheses `()`, and curly braces `{}` containing the function's code.

Syntax:
```php
function functionName(parameter1, parameter2, ...) {
// Code to be executed
return value; // Optional: return a value
}
```

Key Components:

* `function` keyword: Declares a function.
* `functionName`: A unique name for the function. Function names are case-insensitive in PHP, but it's good practice to use consistent casing (e.g., `camelCase`).
* `(` and `)`: These can contain parameters (inputs) for the function. If there are no parameters, they remain empty.
* `{` and `}`: These define the function body, containing the code that will be executed when the function is called.
* `return` statement (optional): Used to send a value back from the function to the part of the code that called it. If `return` is not used, the function implicitly returns `NULL`.

Calling a Function:
To execute the code inside a function, you simply call it by its name followed by parentheses:
```php
functionName(argument1, argument2, ...);
```

Parameters and Arguments:
* Parameters: Variables listed inside the parentheses in the function definition. They act as placeholders for values that the function will receive.
* Arguments: The actual values passed to the function when it is called. These values are assigned to the parameters.

Default Parameter Values:
You can specify default values for parameters. If an argument is not provided for a parameter with a default value, the default value will be used.

Return Types (PHP 7+):
PHP 7 introduced scalar type declarations for parameters and return types. This allows you to specify the expected data type of a function's return value, improving code clarity and enabling better error detection.

<?php

// 1. Simple function without parameters or return value
function greetUser() {
    echo "Merhaba, hoş geldiniz!\n";
}

// Calling the simple function
greetUser(); // Output: Merhaba, hoş geldiniz!

// 2. Function with parameters
function sayHelloTo($name) {
    echo "Merhaba, $name!\n";
}

// Calling the function with an argument
sayHelloTo("Alice"); // Output: Merhaba, Alice!
sayHelloTo("Bob");   // Output: Merhaba, Bob!

// 3. Function with multiple parameters and a return value
function addNumbers($num1, $num2) {
    $sum = $num1 + $num2;
    return $sum;
}

// Calling the function and storing the returned value
$result1 = addNumbers(5, 3);
echo "5 + 3 = " . $result1 . "\n"; // Output: 5 + 3 = 8

$result2 = addNumbers(10, -4);
echo "10 + (-4) = " . $result2 . "\n"; // Output: 10 + (-4) = 6

// 4. Function with default parameter values
function getGreeting($name = "Misafir", $language = "Türkçe") {
    if ($language === "Türkçe") {
        return "Merhaba, $name!";
    } elseif ($language === "English") {
        return "Hello, $name!";
    } else {
        return "Greetings, $name!";
    }
}

// Calling the function with no arguments (uses defaults)
echo getGreeting() . "\n"; // Output: Merhaba, Misafir!

// Calling with only the first argument
echo getGreeting("Ayşe") . "\n"; // Output: Merhaba, Ayşe!

// Calling with both arguments
echo getGreeting("John", "English") . "\n"; // Output: Hello, John!
echo getGreeting("Maria", "Français") . "\n"; // Output: Greetings, Maria!

// 5. Function with type declarations (PHP 7+)
// This function expects an integer for $a and $b, and will return an integer.
function multiply(int $a, int $b): int {
    return $a * $b;
}

// Calling with correct types
$product1 = multiply(7, 6);
echo "7 * 6 = " . $product1 . "\n"; // Output: 7 * 6 = 42

// If you try to pass incorrect types without strict_types, PHP might try to coerce them.
// To enforce strict typing, add `declare(strict_types=1);` at the top of the file.
// $product2 = multiply(7.5, 2); // This would cause a TypeError with strict_types=1

?>