Scribd
Upload
8 views

Function

- PHP allows users to create their own functions to organize and reuse code. Functions are defined once but can be called many times. - Functions can accept arguments to allow information to be passed in and can return values. Arguments are specified in parentheses after the function name. - PHP is loosely typed so variables do not require data type declarations. The strict type declaration forces variables to be used as intended and throws errors on mismatches. - Functions provide code reusability and less code by writing logic once and reusing it with function calls.

Uploaded by

Janhavi rajeshwar Nalbalwar
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
8 views

Function

- PHP allows users to create their own functions to organize and reuse code. Functions are defined once but can be called many times. - Functions can accept arguments to allow information to be passed in and can return values. Arguments are specified in parentheses after the function name. - PHP is loosely typed so variables do not require data type declarations. The strict type declaration forces variables to be used as intended and throws errors on mismatches. - Functions provide code reusability and less code by writing logic once and reusing it with function calls.

Uploaded by

Janhavi rajeshwar Nalbalwar
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 18

Function

• PHP User Defined Functions


• Besides the built-in PHP functions, it is possible to create your own functions.
• A function is a block of statements that can be used repeatedly in a program.
• A function will not execute automatically when a page loads.
• A function will be executed by a call to the function.
• Advantage of PHP Functions
• Code Reusability: PHP functions are defined only once and can be invoked many
times, like in other programming languages.
• Less Code: It saves a lot of code because you don't need to write the logic many
times. By the use of function, you can write the logic only once and reuse it.
• Create a User Defined Function in PHP
• A user-defined function declaration starts with the word function:
• Syntax
function functionName() {
code to be executed;
}
Note: A function name must start with a letter or an underscore. Function names are
NOT case-sensitive.
<!DOCTYPE html>
<html>
<body>
<?php
function writeMsg() {
echo "Hello world!";
}
writeMsg();
?>
</body>
</html>
PHP Function Arguments
• Information can be passed to functions through arguments. An argument is
just like a variable.
• Arguments are specified after the function name, inside the parentheses. You
can add as many arguments as you want, just separate them with a comma.
• The following example has a function with one argument ($fname). When the
familyName() function is called, we also pass along a name (e.g. Jani), and the
name is used inside the function, which outputs several different first names,
but an equal last name:
<!DOCTYPE html>
<html>
<body>
<?php
function familyName($fname) {
echo "$fname Refsnes.<br>";
}
familyName("Jani");
familyName("Hege");
familyName("Stale");
familyName(78);
familyName(4.67);
?>
</body>
</html>
<!DOCTYPE html>
<html>
<body>
<?php
function familyName($fname, $year) {
echo "$fname Refsnes. Born in $year <br>";
}
familyName("Hege","1975");
familyName("Stale","1978");
familyName("Kai Jim","1983");
?>
</body>
</html>
• PHP is a Loosely Typed Language
• In the example above, notice that we did not have to tell PHP which data type
the variable is.

• PHP automatically associates a data type to the variable, depending on its


value. Since the data types are not set in a strict sense, you can do things like
adding a string to an integer without causing an error.

• In PHP 7, type declarations were added. This gives us an option to specify the
expected data type when declaring a function, and by adding the strict
declaration, it will throw a "Fatal Error" if the data type mismatches.

• In the following example we try to send both a number and a string to the
function without using strict:
• <?php
function addNumbers(int $a, int $b) {
return $a + $b;
}
echo addNumbers(5, "5 days");
// since strict is NOT enabled "5 days" is changed to int(5),
and it will return 10
?>
• To specify strict we need to set declare(strict_types=1);. This must be on the very first
line of the PHP file.
• In the following example we try to send both a number and a string to the function,
but here we have added the strict declaration:
<?php declare(strict_types=1); // strict requirement
function addNumbers(int $a, int $b) {
return $a + $b;
}
echo addNumbers(5, "5 days");
// since strict is enabled and "5 days" is not an integer, an error will be thrown
?>
• The strict declaration forces things to be used in the intended way.
• PHP Default Argument Value
• The following example shows how to use a default parameter. If we call the function
setHeight() without arguments it takes the default value as argument:
• Example

<?php declare(strict_types=1); // strict requirement


function setHeight(int $minheight = 50) {
echo "The height is : $minheight <br>";
}
setHeight(350);
setHeight(); // will use the default value of 50
setHeight(135);
setHeight(80);
?>
• PHP Functions - Returning values
• To let a function return a value, use the return statement:
• Example
<?php declare(strict_types=1); // strict requirement
function sum(int $x, int $y) {
$z = $x + $y;
return $z;
}
$ans = sum(15, 110);
echo "5 + 10 = " . sum(5, 10) . "<br>";
echo "7 + 13 = " . sum(7, 13) . "<br>";
echo "2 + 4 = " . sum(2.66, 4.99);//error
Echo $ans;
?>
• PHP Return Type Declarations
• PHP 7 also supports Type Declarations for the return statement. Like with the
type declaration for function arguments, by enabling the strict requirement,
it will throw a "Fatal Error" on a type mismatch.
• To declare a type for the function return, add a colon ( : ) and the type right
before the opening curly ( { )bracket when declaring the function.
• In the following example we specify the return type for the function:
• Example
• <?php declare(strict_types=1); // strict requirement
function addNumbers(float $a, float $b) : float {
return $a + $b;
}
echo addNumbers(1.2, 5.2);
?>
• You can specify a different return type, than the argument types, but make
sure the return is the correct type:
• Example
• <?php declare(strict_types=1); // strict requirement
function addNumbers(float $a, float $b) : int {
return (int)($a + $b);
}
echo addNumbers(1.2, 5.2);
?>
• Passing Arguments by Reference
• In PHP, arguments are usually passed by value, which means that a copy of the value
is used in the function and the variable that was passed into the function cannot be
changed.
• When a function argument is passed by reference, changes to the argument also
change the variable that was passed in. To turn a function argument into a
reference, the & operator is used:
• Use a pass-by-reference argument to update a variable:
• <?php
function add_five(&$value) {
$value += 5;
}
$num = 2;
add_five($num);
echo $num;
?>
• PHP Anonymous functions
• Anonymous function is a function without any user defined name. Such a function is
also called closure or lambda function. Sometimes, you may want a function for one-
time use. Closure is an anonymous function which closes over the environment in
which it is defined. You need to specify use keyword in it. Most common use of
anonymous function to create an inline callback function.
Syntax
$var=function ($arg1, $arg2) { return $val; };
• There is no function name between the function keyword and the opening
parenthesis.
• There is a semicolon after the function definition because anonymous function
definitions are expressions
• Function is assigned to a variable, and called later using the variable’s name.
• When passed to another function that can then call it later, it is known as a
callback.
• Return it from within an outer function so that it can access the outer function’s
variables. This is known as a closure.
Anonymous function example
Example
<?php $var = function ($x) {return pow($x,3);};
echo "cube of 3 = " . $var(3);?>
Output
following result. −
cube of 3 = 27
Include() and Require() Function in PHP
• Introduction
In PHP, there are two functions that are used to put the contents of a file
containing PHP source code into another PHP file. These function are Include()
and Require(). These functions are the same if but they have one difference. The
difference is that the include() function produces a warning, but the script will
continue execution, while the require() function produces a warning and a fatal
error i.e. the script will not continue execution. These two functions are used to
put the data of a file into another PHP file before it is executed by the server.
• The basic syntax of the include() and require() statement can be given with:
include("path/to/filename"); -Or- include "path/to/filename";
require("path/to/filename"); -Or- require "path/to/filename";
include() require()

The include() function does not stop the execution of the script The require() function will stop the execution of the script
even if any error occurs. when an error occurs.

The include() function does not give a fatal error. The require() function gives a fatal error

The include() function is mostly used when the file is not


The require() function is mostly used when the file is
required and the application should continue to execute its
mandatory for the application.
process when the file is not found.

The include() function will only produce a The require() will produce a fatal error (E_COMPILE_ERROR)
warning (E_WARNING) and the script will continue to execute. along with the warning and the script will stop its execution.

The require() function is more in recommendation and


The include() function generate various functions and elements
considered better whenever we need to stop the execution
that are reused across many pages taking a longer time for the
incase of availability of file, it also saves time avoiding
process completion.
unnecessary inclusions and generations.
• The include_once and require_once Statements
It is possible that conflicts will arise if you include the same file (usually
function or class files) more than once within your code using include or require
commands. PHP includes include_once and require_once statements to avoid
this issue. With one exception, these statements function similarly to include
and require statements.
require_once "path/to/filename";
include_once "path/to/filename";

You might also like