PHP Functions: Defining, calling functions, scope, and function arguments.

In PHP, functions are blocks of code designed to perform specific tasks. They are an essential part of any program, allowing you to break down code into reusable sections.

1. Defining Functions

Functions in PHP are defined using the function keyword, followed by a name, parentheses, and a code block. The syntax is as follows:

function functionName() {
    // code to execute
}

Example:

function greet() {
    echo "Hello, World!";
}

Here, greet() is a function that, when called, will output "Hello, World!".

2. Calling Functions

To use a function, you simply call it by its name, followed by parentheses:

greet(); // Outputs: Hello, World!

Functions can be called multiple times, which helps avoid code duplication.

3. Function Arguments

Functions can take arguments, which are values passed into the function when it is called. You specify parameters in the parentheses during the function definition, and these parameters become variables within the function.

Example:

function greet($name) {
    echo "Hello, $name!";
}

greet("Amir"); // Outputs: Hello, Amir!

In this example, $name is a parameter that takes the value passed during the function call, allowing the function to be more dynamic.

Default Values: You can also set default values for parameters, making them optional.

function greet($name = "Guest") {
    echo "Hello, $name!";
}

greet(); // Outputs: Hello, Guest!

4. Return Values

Functions can return values using the return keyword. Once return is executed, the function stops running and returns the specified value.

Example:

function add($a, $b) {
    return $a + $b;
}

$result = add(5, 3); // $result is now 8

The add function returns the sum of $a and $b.

5. Variable Scope

Local Scope: Variables declared within a function are local to that function and cannot be accessed outside of it.

function test() {
    $x = 5; // Local to test()
}

echo $x; // Error: Undefined variable $x

Global Scope: Variables declared outside any function have a global scope. They cannot be directly accessed within a function unless specified with the global keyword.

$y = 10;

function testGlobal() {
    global $y;
    echo $y;
}

testGlobal(); // Outputs: 10

Static Variables: Use the static keyword to maintain a variable's value across multiple function calls.

function counter() {
    static $count = 0;
    $count++;
    echo $count;
}

counter(); // Outputs: 1
counter(); // Outputs: 2

6. Passing Arguments by Reference

By default, function arguments are passed by value, meaning the function gets a copy of the argument. However, you can pass by reference using the & symbol, which allows the function to modify the original variable.

Example:

function addOne(&$number) {
    $number++;
}

$value = 5;
addOne($value);
echo $value; // Outputs: 6

Summary

Define functions with function.
Pass arguments for flexibility.
Return values with return.
Understand local, global, and static scopes.
Pass arguments by reference to modify them directly.

Using functions effectively can greatly enhance your PHP code by making it modular, reusable, and easier to maintain.

PHP Control Structures: Conditionals (if, else, switch) and loops (for, while, foreach).

PHP Arrays: Types of arrays (indexed, associative, multidimensional), array functions.