PHP Functions

PHP Built-in Functions

PHP has over 1000 built-in functions that can be called directly, from within a script, to perform a specific task. Please check out our PHP reference for a complete overview.

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 is not executed automatically when a page loads.
• A function is executed only when it is called.

Create a Function

A user-defined function declaration starts with the keyword function, followed by the name of the function.

The opening curly brace { indicates the beginning of the function code, and the closing curly brace } indicates the end of the function.

Note: A function name is not case-sensitive, and it must start with a letter or an underscore.

Syntax

function functionName($parameter1, $parameter2) {
  // code to be executed
  return $value; // optional
}

The following example creates a function named myMessage():

function myMessage() {
  echo "Hello world!";
}

Tip: Give the function a name that reflects what the function does!

Call a Function

To call a function, just write its name followed by parentheses ().

The function below outputs "Hello world!":

function myMessage() {
  echo "Hello world!";
}

myMessage();

PHP Function Parameters

Information can be passed to functions through parameters. A parameter is just like a variable.

Parameters are specified after the function name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma.

The following example has a function with one parameter ($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:

function familyName($fname) {
  echo "$fname Refsnes.<br>";
}

familyName("Jani");
familyName("Hege");
familyName("Stale");
familyName("Kai Jim");
familyName("Borge");

The following example has a function with two parameters ($fname, $year):

function familyName($fname, $year) {
  echo "$fname Refsnes. Born in $year.<br>";
}

familyName("Hege", "1975");
familyName("Stale", "1978");
familyName("Kai Jim", "1983");

PHP Default Parameter Value

The following example shows how to use a default parameter.

If we call the function setHeight() without a parameter, it will take the default value:

function setHeight($height = 50) {
  echo "The height is : $height <br>";
}

setHeight(350);
setHeight(); // will take the default value of 50

PHP Functions - Returning values

The return statement immediately ends the execution of a function, and returns a value back to the line of code that called it:

function sum($x, $y) {
  $z = $x + $y;
  return $z;
}

echo "5 + 10 = " . sum(5, 10) . "<br>";
echo "7 + 13 = " . sum(7, 13) . "<br>";
echo "2 + 4 = " . sum(2, 4);

Passing Arguments by Reference

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, use the & operator in front of the argument/parameter:

function add_five(&$value) {
  $value += 5;
}

$num = 2;
add_five($num);
echo $num;

Variable Number of Parameters

By using the ... operator in front of the function parameter, the function accepts an unknown number of parameters. This is also called a variadic function.

The variadic function argument becomes an array.

function sumMyNumbers(...$x) {
  $n = 0;
  $len = count($x);
  for($i = 0; $i < $len; $i++) {
    $n += $x[$i];
  }
  return $n;
}

$a = sumMyNumbers(5, 2, 6, 2, 7, 7);
echo $a;

You can only have one argument with variable length, and it has to be the last argument.

function myFamily($lastname, ...$firstname) {
  $txt = "";
  $len = count($firstname);
  for($i = 0; $i < $len; $i++) {
    $txt = $txt."Hi, $firstname[$i] $lastname.<br>";
  }
  return $txt;
}

$a = myFamily("Doe", "Jane", "John", "Joey");
echo $a;

If the variadic argument is not the last argument, you will get an error.

function myFamily(...$firstname, $lastname) {
  $txt = "";
  $len = count($firstname);
  for($i = 0; $i < $len; $i++) {
    $txt = $txt."Hi, $firstname[$i] $lastname.<br>";
  }
  return $txt;
}

$a = myFamily("Doe", "Jane", "John", "Joey");
echo $a;

PHP is a Loosely Typed Language

In the examples 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, you can do things like adding a string to an integer without causing an error.

From 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.

To specify strict mode, 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 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 "5 days" is not an integer, an error will be thrown
?>

PHP Return Type Declarations

PHP also supports Type Declarations for the return statement.

To declare a data type for the function return, add a colon ( : ) and the data type right before the opening curly ( { ) bracket when declaring the function.

In the following example we specify the return type (float) for the function:

<?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 also specify a different return type, than the argument types, but make sure the return is the correct type:

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

function addNumbers(float $a, float $b) : int {
  return (int)($a + $b);
}
echo addNumbers(1.2, 5.2);