UNIT II (Functions)

Prepared By: Ukesh Bhattarai

Functions

 Functions are reusable blocks of code designed to perform specific

tasks.
 They enhance code modularity and readability, allowing developers to
write cleaner and more efficient programs.
 Modularity

Functions break down code into smaller,

manageable parts.
 Reusability

Functions can be used multiple times in a script.

 Maintainability

Changes within a function, do not affect the entire

program.
Types of functions

 Built-In functions:
 These are pre-defined functions provided by PHP.
 They cover a wide range of tasks, including string manipulation, mathematical operations,
and file handling.
 Examples include:
 String Functions
 Functions like strlen(), strpos(), and substr() manipulate strings.
<?php
echo substr("Hello world",6);
?>
 Math Functions
 Functions such as abs(), round(), and rand() perform math.
 Array Functions
 Functions like array_push(), array_pop(), and count() manage arrays.
 User-defined function
 These are custom functions created by developers to perform specific tasks.
 They allow for tailored functionality that can be reused throughout the application.

<?php
function greet() {
echo "Hello, World!";
}
greet();
?>
Defining a function

 To create a function in PHP, use the following syntax:

function functionName($parameter1, $parameter2, ...)
{
// Function code here
}
 Function Name: Must start with a letter or underscore and can contain
letters, numbers, and underscores.
 Parameters: Values passed into the function when it is called. You can
define multiple parameters separated by commas.
Calling a function

 Calling a function involves invoking its name followed by parentheses,

optionally passing any required arguments within those parentheses.
 This action executes the block of code defined within the function.
<?php
// Function definition
function greet() {
echo "Hello, World!";
}

// Function call
greet();
?>
Variable Scope

 Variable scope determines the accessibility and lifespan of a variable

within different parts of a program.
 Understanding variable scope is crucial for writing predictable and error-
free code.
 Local Scope
 Variables declared inside a function are considered to have a local scope.
 These variables are accessible only within that function and do not exist
outside of it.
<?php
function myFunction() {
$localVar = "I'm local";
echo $localVar; // Outputs: I'm local
}

myFunction();
echo $localVar; // Error: Undefined variable $localVar
?>
 Global Scope
 Variables declared outside of any function have a global scope.
 These variables are accessible from any part of the script except inside
functions, unless explicitly specified.
<?php
$globalVar = "I'm global";

function myFunction() {
echo $globalVar; // Error: Undefined variable $globalVar
}

myFunction();
echo $globalVar; // Outputs: I'm global
?>
 To access a global variable within a function, use the global keyword or
the $GLOBALS array.
<?php
$globalVar = "I'm global";

function myFunction() {
global $globalVar;
echo $globalVar; // Outputs: I'm global
}

myFunction();
?>
Static Variables
 Variables declared as static inside a function retain their value between function calls.
 This is useful for keeping track of information across multiple invocations of a function
without using global variables.
<?php
function myCounter() {
static $count = 0;
$count++;
echo $count;
}

myCounter(); // Outputs: 1
myCounter(); // Outputs: 2
myCounter(); // Outputs: 3
?>
Function Parameters
 Function parameters are variables specified in a function's declaration
that accept values, known as arguments, when the function is called.
 These parameters enable functions to process dynamic inputs,
enhancing code flexibility and reusability.
 Defining Function Parameters:
 Parameters are declared within the parentheses following the function name.
Multiple parameters are separated by commas.
<?php
function multiply($a, $b)
{
echo “$a * $b”;
}
?>
 Calling Functions with Arguments:
 When invoking a function, provide arguments corresponding to the defined
parameters.
<?php
multiply(5, 10);
?>
 Default Parameter Values:
 PHP allows default values for parameters, making them optional during function calls.

<?php
function greet($name = "Guest") {
echo "Hello, $name!";
}
greet(); // Outputs: Hello, Guest!
greet("Alice"); // Outputs: Hello, Alice!
?>
If no argument is provided, $name defaults to "Guest".
 Named Arguments (PHP 8.0+):
PHP 8.0 introduced named arguments, allowing you to specify arguments by
parameter name, enhancing readability and flexibility.
function configure($width = 100, $height = 200, $color = 'blue') {
}
configure($height: 300, $color: 'red');
 Type Declarations:
PHP supports type declarations for parameters, enforcing the type of arguments
passed to functions.

function add(int $a, int $b): int {

echo $a + $b;
}
echo add(5, 10); // Outputs: 15
Return Values
 Returns a result to use later – Unlike echo, return sends a value back.
 Stops function execution – Anything after return is ignored.
 Stores function output in variables – So you can use it elsewhere.
<?php
function addNumbers($a, $b) {
return $a + $b; // Returns the sum
}
echo "The sum is: " . addNumbers(5,10);
?>
 What happens without return?
<?php
function addNumbers($a, $b) {
echo $a + $b; // Directly prints the result
}
addNumbers(5,3);
echo "The sum is: " . addNumbers(5,3);
?>

Output: 8
The sum is:
Variable Functions

 A variable function in PHP allows you to call a function using a

variable.
 Instead of calling a function by its actual name, you store the function's
name in a variable and call it dynamically.
 Why Use Variable Functions?
They allow dynamic function execution (you decide at runtime which function to
call).
Helps create flexible and reusable code.
 Basic example
<?php
function greet() {
echo "Hello, PHP!";
}
$func = "greet"; // Assigning function name to a variable
$func(); // Calling function using variable
?>

Here, $func = "greet"; stores the function name in a variable, and $func();
calls that function dynamically.
 Example with parameters
<?php
function greet($name) {
echo "Hello, $name!";
}
$func = "greet";
$func("John"); // Calls greet("John")
?>
Here, $func("John"); dynamically calls greet("John").
 Selecting a Function Dynamically
Imagine a simple calculator where you choose an operation at
runtime.
<?php
function add($a, $b) {
return $a + $b;
}
function multiply($a, $b) {
return $a * $b;
}
$operation = "add";
echo $operation(5, 3); // Calls add(5, 3) and outputs 8

$operation = "multiply";
echo "<br>" . $operation(5, 3); // Calls multiply(5, 3) and outputs 15
?>
 When to Use Variable Functions?
Dynamic Function Calls – When the function name needs to be decided at
runtime.
Switching Between Functions – As seen in the calculator example.
Event Handling – Deciding what function to execute based on user input.
Anonymous Functions

 Anonymous functions (also called closures or lambda functions) are

functions without a name.
 Instead of defining a function with a name like function myFunction(),
you can create a function inside a variable or pass it directly as an
argument.
 Why Use Anonymous Functions?
Useful when you need a temporary function (one-time use).
Makes code cleaner and more readable when passing functions as
arguments.
 Basic Example of an Anonymous Function
Instead of defining a named function, we store a function inside a
variable.

<?php
$greet = function($name) {
return "Hello, $name!";
};
echo $greet("John");
?>
Here, $greet acts like a function name, but it’s actually a variable storing a
function.
We call it using $greet("John"); like a normal function.
 Using use() to Access Outer Variables
Since an anonymous function doesn’t have access to outside variables by
default, we use use() to pass them.
<?php
$multiplier = 3;

$multiply = function($num) use ($multiplier) {

return $num * $multiplier;
};

echo $multiply(5);
?>
The use ($multiplier) allows the function to access $multiplier from outside
its scope.
Date and Time Functions

 PHP provides built-in functions to work with date and time, allowing
developers to format, manipulate, and display date and time information
dynamically.
 The date() function is used to format and display the current date and time.
<?php
echo date("Y-m-d"); // Output: 2025-02-05 (Year-Month-Day)
?>

<?php
echo date("H:i:s"); // Output: 14:30:45 (Hour:Minute:Second)
?>