php function default value
PHP variable «default value»
I want to get a value from the session, but use a default if it is not defined. And ofcourse I want to circumvent the PHP notice.
You can write a function that does this
Is there a way to do this without defining this function in every file?
6 Answers 6
You can define it in one script and then require_once that script in your other scripts
You could also just use the ternary operator:
From PHP 7, you can now use the null coalescing operator :
that does exactly like your function
Use this concise alternative:
The || operator is short circuit, it will not evaluate second operant if the first one be evaluated true.
Use less code to do what you need.
You don’t need to specify the variable again using the _?_:_ format.
Now as far as an empty check, you could use @ to mute notices, I’m not sure of the technical ramifications, but you’re already doing your own checking while using this format:
You could use my tiny library ValueResolver in this case, for example:
and don’t forget to use namespace use LapaLabs\ValueResolver\Resolver\ValueResolver;
Check the docs for more examples
The Null coalescing operator has been added to PHP version 7.0, what it does is replaces
with a shorter version:
Functions in PHP: Return Values and Parameters
Functions are an important part of programming languages. They help us avoid code duplication by allowing us to run the same set of instructions over and over again on different data.
In this tutorial, we will talk about functions in PHP. We will cover all the basic concepts of functions in PHP, and you’ll learn how to create your own user-defined functions in PHP. You will learn about returning values from a function and function parameters in PHP. You’ll also learn other concepts like setting default argument values or passing an argument by reference.
Internal Functions in PHP
PHP comes with a lot of built-in functions that you can use in your program. Some of these functions come as standard, while others become available to you through specific PHP extensions.
PHP comes with a lot of functions to work with strings. For example, you can use the str_contains() function to check if a string contains a substring and the wordwrap() function to wrap a string to a given number of characters. These functions are available for you to use as standard.
If you ever get a fatal undefined function error in PHP but you are certain that it is an internal function, make sure that you have installed the respective extensions to use that function.
User-Defined Functions in PHP
You can also define your own functions in PHP. Defining your own functions becomes a necessity in almost every non-trivial program you write. They are a great way to avoid code duplication and errors.
Here is some basic code to define a function that outputs a greeting when we call the function later.
In the above example, we just passed a name to the greet() function, and it echoed a different output based on the specified name.
Return From a Function in PHP
In the previous example, our user-defined greet() function did not return anything. It just echoed a couple of sentences based on the input. It is entirely up to us to return anything inside any function we define in PHP.
When you want to return something, you need to use the return statement. A function can return any type of value in PHP. This includes strings, integers, floats, arrays, or even objects.
In the above example, the palindrome() function turns any given string into a palindrome by appending it to its reversed version. Now, instead of echoing the output directly, we assign it to a variable. We can now further manipulate the variable, but we’ll just echo it in this example.
A function can have multiple return values, and the execution of the function stops immediately once it encounters a return statement. This means that you can only return one value from a function. However, you can work around this limitation by returning an array that consists of all the values that you want to return as its elements.
You should also note that the greet() function did not echo Bye Monty! in our program. This is because the function execution was stopped as soon as it encountered a return statement.
Function Parameters in PHP
Function parameters (also known as «function arguments») are used to pass an input to a function, upon which it can act to give us the desired output. We have only defined functions with a single parameter so far in this tutorial.
However, it is entirely up to us how many parameters we want to pass to a function. It can be zero for functions which don’t require any kind of input from us. It can also be two, three, five, or ten. You can also pass arrays as parameters.
Here is an example of PHP functions that accept zero and two parameters respectively.
We can rewrite the second function to pass an array as our only parameter. We will just extract different values from the array inside our function. This can be helpful in situations where you want to either manipulate arrays or pass a lot of values to a function.
Specifying Default Argument Values
This is actually quite common in built-in PHP functions. The strpos() function is used to find the location of a substring in a string. The function takes three arguments: the string, the substring, and the position where you want to start. The function returns the index of the substring in the string.
The position parameter is the point at which you want to start looking for the substring. Usually, we want to look inside the main string from its starting position. This means that the value of offset will usually be zero.
Instead of asking us to specify the offset as 0 each time we call the function, PHP sets its value to 0 by default. Now, we only need to specify the third parameter when we want to change the offset to something else.
We can also set a default value for different parameters in our own functions. Here is an example:
There are two things that you need to keep in mind about default parameters or arguments. First, they have to be a constant value, like morning in our case. Any arguments with default values should always be on the right side. For example, the following function definition will cause an error during the first call.
Passing Arguments by Value vs. Passing by Reference
By default, different arguments are passed to a PHP function by value. This way, we can avoid changing the value of the argument passed to a function. However, if you intend to change the value of arguments passed to a PHP function, you can pass those arguments by reference.
The following example should help you understand the difference between these two approaches.
Conclusion
In this tutorial, we have covered a lot of the basics related to functions in PHP. Hopefully, you can now write your own user-defined functions that take advantage of everything we learned here. Feel free to ask any questions you have about this topic in the comments.
Learn PHP With a Free Online Course
If you want to learn PHP, check out our free online course on PHP fundamentals!
In this course, you’ll learn the fundamentals of PHP programming. You’ll start with the basics, learning how PHP works and writing simple PHP loops and functions. Then you’ll build up to coding classes for simple object-oriented programming (OOP). Along the way, you’ll learn all the most important skills for writing apps for the web: you’ll get a chance to practice responding to GET and POST requests, parsing JSON, authenticating users, and using a MySQL database.
Default Function Parameters In PHP
When creating functions in PHP it is possible to provide default parameters so that when a parameter is not passed to the function it is still available within the function with a pre-defined value. These default values can also be called optional parameters because they don’t need to be passed to the function. I have seen this sort of code being used incorrectly quite often recently so I thought I would go over it in a post.
Creating a default parameter in a function is very simple and is quite like normal variable assignment. The following function has a single parameter that is set to 1 if it is not passed when calling the function.
This function doesn’t do very much, but can be used in the following way. If the parameter isn’t added to the function call then the default value is used, if it is added then this value is used instead.
It is possible to use as many default arguments as is needed in a function. The following function has four parameters, three of which are optional.
This function can be run in the following manner.
It is also possible to use arrays as default parameters as in the following function.
One important thing to remember when creating default parameters is that you should add them to the end of the required parameters that your function has. It is syntactically valid to write a function in which the default parameters are not at the end of function definition, but this will lead to problems. Take the following function.
Just in case some of you are thinking that it should be possible to simply add a null value as the parameter you should note that this will not work either. What you are essentially doing is passing a value (null in this case) and so the default parameter will not be used. Using the above function the following code will print 3. This is the result of the sum 1 + null + 1 + 1, the null value translates to 0 when used in a calculation.
Default parameters can be used to control the function in some way. Lets say that you wanted to create a function that will print out a variable if the function is told to do so. To do this you would create a second optional parameter that would print a given value if true is passed.
This function style can be seen in many CMS systems, usually within template functions, and can be run in the following way.
The mistake I have seen the most often is when programmers copy and paste the function definition and use this as the function call itself. The following (perfectly legal) code calls the testMultiFunction() example function above.
This has the same output as the previous code, but it is a much cleaner way to call the function. If you are worried about not being able to tell what parameter does what then add a comment before the function call that gives you more information.
Phil is the founder and administrator of #! code and is an IT professional working in the North West of the UK. Phil is currently a Developer at Code Enigma.
Comments
Just learning PHP (experienced with another programming language though) and this article really helped me grasp the way PHP handles params. Thanks!
Add new comment
Related Content
Debugging And Testing PHP With assert()
PHP has a built in debugging and testing tool called assertions, which is essentially the assert() function and a few configuration options.
With this feature you can add additional checks to your application whilst you are developing it so that when you deploy to production you can be sure that things will run correctly. It is simple to run and allows you to embed testing code within your production code without having an adverse effect on performance.
Installing SimpleSAMLphp Using Composer
Security Assertion Markup Language (SAML) is a standard that passes authentication credentials between hosts and essentially allows for a single sign on solution to be created. The standard uses XML files that get passed between the authentication system (known as the identity provider or IdP) and the service users want to sign into (known as the service provider or SP).
Create Checksums Using The Luhn Algorithm In PHP
The Luhn algorithm was created by Hans Peter Luhn and is a way of creating a simple checksum for a number. This algorithm, also known as the mod 10 algorithm, is used in a wide variety of applications but is commonly associated with credit card numbers.
If you look at the numbers on the front of your credit card the last digit on the right is the checksum. An algorithm is done on the other numbers and if the checksum is the same then the number is considered valid.
Swapping Between Different Composer Versions
Creating A Game With PHP Part 4: Side Scrolling Shooter
As another step up from the game of snake I created in my last post I decided to try my hand at creating a side scrolling shooter. Just like my other posts, this is an ASCII based game played on the command line.
A side scrolling shooter, if you didn’t already know, moves a scene from right to left across the screen with enemies moving with the scene towards the player’s ship, which is on the left hand side of the scene. The player can fire bullets towards the enemies so remove them from the scene.
Seeding Random Numbers in PHP
Computers are not that great at creating random numbers as the methods they use are deterministic. That is, they start from a number (called a seed) and apply maths to that number to generate pseudorandom numbers. Most random numbers generated by computers programs use a seed provided by the system, which is generally the current time. If you can guess the initial value then you can start to work out what the random sequence of numbers generated is. Most random numbers, are therefore not suitable for encryption.
PHP: Using optional default parameters in a function.
This is a guide on how to use optional / default function parameters in PHP. In other languages such as Java, you can use a feature called Method Overloading. However, in PHP, two functions cannot have the same name.
Optional parameters are useful because they allow us to control how a function is executed if a certain parameter has been omitted from the function call.
Example of a PHP function that has default arguments.
Let’s take a look at the following example:
The function above has one parameter called $sort. By default, $sort is set to a boolean FALSE value. As a result, our $sort parameter will default to FALSE if the getAnimals function is called without any arguments.
You can test this out by running the following PHP snippet:
In the first function call, we omitted the first parameter. This means that $sort will default to FALSE:
As you can see, the array above has not been sorted.
However, in the second function call, we did provide an argument. This means that our default parameter is overridden:
In the screenshot above, you can see that the array has been sorted in alphabetical order.
Multiple default parameters.
PHP functions can have multiple default parameters. Take the following example:
The PHP function above has three parameters, all of which have their own default values:
As a result, you can call the function above like so:
You can also provide only one of the three optional arguments:
The function call above will result in the first parameter $a being set to TRUE.
But what if we only wanted to change the last optional argument? Well, in that case, we need to provide all of the function’s arguments while making sure that the default values of the first two parameters aren’t changed:
In the example above, we used the default values of the first two parameters while changing the third.
PHP Functions
The real power of PHP comes from its functions.
PHP has more than 1000 built-in functions, and in addition you can create your own custom 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 of the PHP built-in functions.
PHP User Defined Functions
Besides the built-in PHP functions, it is possible to create your own functions.
Create a User Defined Function in PHP
A user-defined function declaration starts with the word function :
Syntax
Note: A function name must start with a letter or an underscore. Function names are NOT case-sensitive.
Tip: Give the function a name that reflects what the function does!
In the example below, we create a function named «writeMsg()». The opening curly brace ( < ) indicates the beginning of the function code, and the closing curly brace ( >) indicates the end of the function. The function outputs «Hello world!». To call the function, just write its name followed by brackets ():
Example
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:
Example
Example
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 :
Example
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:
Example
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
To let a function return a value, use the return statement:
Example
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
You can specify a different return type, than the argument types, but make sure the return is the correct type:
Example
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:
Example
Use a pass-by-reference argument to update a variable: