Variable scope

Because variables are not global, they will also not be available inside of functions by default, and it is considered a bad practice to make them global. Functions have their own local scope that is inaccessible from the calling location. Instead we can pass the variables on to the function through function arguments when calling it; you already saw a basic example of this in the beginning of the article.

Nevertheless, you may access an outside variable from within a function if you first declare it as global; this is done by using the global keyword inside the function:

$praise = 'Praise be the almighty function, you will praise it, you will.';

function my_praise_func() {
  // Declare the outside variable as global so we can use it inside the function
  global $praise;

  // Output the message
  echo $praise;
  
  // Exit and stop executing
  exit();
}

This is generally a bad practice, so you should instead consider passing the variable in the function by injection technique; injection something into a function is done via the arguments that you define in the function. The below function only has one argument, called $the_message defined:

$the_message = 'Welcome to the website. Please behave yourself.';

welcome_message();

function welcome_message($the_message) {
  echo $the_message;
  exit();
}

If you need to have multiple function arguments, you may add additional ones by separating them with comma:

function welcome_message($the_message, $name_of_user, $age_of_user) {
  $html =  '<p>' . $the_message . '</p>';
  $html .= '<p>Your name is: ' . $name_of_user . '</p>';
  $html .= '<p>And your age is: ' . $age_of_user;
  return $html;
}

There is a couple of things going on in this example that you should know about.

1. Note how the $html = ... variable is first declared, and then more data added to it with the .= operator. If you leave out the dot, you will instead re-declare the variable, which will overwrite the existent content.
2. Strings are combined using dots . between strings and variables; this is also known as concatenation.

You can also double quotes around your text strings instead of single quotes and include your variables directly in the string:

$html = "<p>{$the_message}</p>";

When including variables in a string directly, it is a good idea to wrap it in curly brackets to avoid problems with parts of your string getting mixed with your variable name. Finally, you will need to use double quotes, since variables do not work inside of single quotes.

Arguments

Function arguments are also known as function parameters; they can help you "inject" data from a calling location into your function, and, as already discussed earlier in the article, injecting data is better than relying on the global scope.

Functions that are declared in the global scope are going to be available throughout your scripts, even from inside classes, but relying on such global functions is discouraged, because it creates a hidden dependency for the class. If someone was to instantiate the class without knowing about your dependency of an outside-declared function, they might be unable to use the class, typically triggering fetal errors.

function say_something(string $message) {
}

PHP Fatal error:  Uncaught TypeError: say_hallo(): Argument #1 ($message) must be of type string, array given, called in ...

function my_beautiful(string &$input) {
  $input = 'My beautiful ' . $input;
}

$person = 'Wife';
my_beautiful($person);

echo $person; // Output: "My beautiful wife"

$my_new_object = new my_class_name();

When should you create a function?

This is often a subjective decision, but in general, you can create a function whenever you asses that a piece of code is going to be reused elsewhere in your code. If you are just learning PHP, then it is fine to play around with basic functions, but if you have been using PHP for a while, you might want to slowly move over in object orientated territory.

To give you an example from the real world of some code that you would often use from different locations; if you have a chunk of code that you use to connects to a database, then it is going to be easier if you create a function containing the code that you can call whenever needed. Thereby:

1. You avoid code repetition — this relates to the Don't Repeat Yourself (DRY) principle in programming.
2. If you need to change the code, you can now update it in one place.

Should you learn Object Orientated PHP?

Once you know how to make functions, you are actually not far away from being able to create your first PHP class and learning object orientated programming. It probably makes it easier to wrap your head around the idea if you just think of a class as being a collection of user made PHP functions that can be called in a similar way to normal functions.

A class is a blue-print of an object. You can instantiate an object in order to use the functions inside (now called methods, because we are in an OOP context).

Modern PHP code often relies heavily on OOP; you do not necessarily need to know everything there is to know, but you should at least learn how to work with code that are distributed in class-form.

Object orientated PHP may seem frighting at first, but it is not really much harder to use than plain old procedural PHP with functions. The main reason why you may find it harder to learn than vanilla PHP is that tutorials and discussions about OOP tend to be very abstract. There are also many tutorials that try to be easier to understand for beginners, some of which you can find in other articles on this website.

Links

1. User-defined functions - php.net

Tell us what you think: