The first new feature I want to cover is type declarations.

This simply means specifying which type of variable is being set,

instead of allowing PHP to set this automatically.

PHP is considered a weak typed language.

In essence, this means that PHP does not require that you declare the data types.

Variables still have data types associated with them, but you can do radical things,

like adding a string to an integer without resulting in an error.

Type declarations can help you define what should occur, so

that you get the expected results.

This can also make your code easier to read.

We'll look at some specific examples shortly.

Since PHP5, you can use type hinting to specify the expected data types

of an argument in a function declaration, but only in the declaration.

When you call the function, PHP will check whether or

not the arguments are of the specified type.

If not, the runtime will raise an error and the execution will be halted.

Besides only being used in function declarations,

we are also limited to basically two types, a class name or an array.

Here's an example.

If we were to create a function for enrolling students,

we would require that the first argument be an object of the class, Student, and

the second argument to be an array of classes.

If we tried to pass just the name of the student instead of an object,

we would get a fatal error.

If we were to pass a single class instead of an array of classes,

we would also get an error.

We are required to pass a student object and an array.

If we were to try to check for a scalar variable, such as a string, PHP5 expects

it to be an object of the class, string, not the variable type, string.

With PHP7, we now have added scalar types.

Specifically, int, float, string, and bool.

By adding scalar type hints and enabling strict requirements, it is hoped

that more correct and self-documenting PHP programs can be written.

It also gives you more control over your code and can make the code easier to read.

By default, scalar type declarations are non-strict, which means they attempt

to change the original type to match the type specified in the type declaration.

In other words, if you pass a string that starts with a number into a function that

requires a float, it will grab the number from the beginning and

remove everything else.

Passing a float into a function that requires an int will become simply an int.

Let's look at an example of a non-strict type.

The getTotal function receives two floats and adds them together,

while it returns the sum.

Without strict types turned on, PHP attempts to cast or

to change these arguments to match the type specified in the function.

So when we call getTotal with non-strict types using an int of two and

a string of one week, PHP converts these to floats, the first argument

would be changed to 2.0, and the second argument would be changed to 1.0.

However, you will get a notice because this is not a well formed numeric value.

The function will then return a value of three,

which would be completely wrong if we were trying to add days.

When we call getTotal with the float 2.8 and the string of 3.2,

PHP converts the string to the float 3.2 with no notice,

because it was a smooth conversion.

It then returns a value of six.

When we call getTotal with non-strict types using the float 2.5,

and the integer 1, the integer gets converted to the float 1.0 and

the function returns 3.5.

Additionally, PHP7 gives us the opportunity to enable strict mode

on a file-by-file basis.

We do this by declaring strict types at the top of any given file.

This must be the very first line, even before name spaces.

Declaring strict typing will ensure that any function call made in that file

strictly adheres to the type specified.

Strict is determined by the file in which the call to the function is made,

not the file in which the function is defined.

If a type declaration mismatch occurs, a fatal error is thrown, and

we know that something is not functioning as desired.

Instead of allowing PHP to simply guess at what we want to happen,

allowing PHP to guess can cause seemingly random and hard to diagnose issues.

We'll look at catching and handling errors in the next section.

But for now, let's take a look at examples using strict types turned on.

When declare strict type has been turned on,

the first two calls that pass a string will produce a fatal error.

The exception to strict typing is shown in the third call.

If you pass an int as an argument that is looking for

a float, PHP will perform what is called widening,

by adding a dot zero to the end, and the function returns 3.5.

PHP7 also supports return type declarations,

which support all the same types as arguments.

To specify the return type, we add a colon, and then the type,

right before the opening curly bracket.

If we specify the return type of float, it will work exactly like it has been working

in the previous two examples, since the type being returned was already a float.

Adding the return types allows you to be sure that your function returns what

you expected to return,

as well as make int easy to see up front how the function works.

If we specify the return type as int without strict type set,

everything will work the same as it did without a return type.

The only difference is that it will force the return to be an int.

In the third call, the return value will truncate to three

because the floating point will be dropped.

If we turn strict types on, we'll get a fatal type error.

In this case, we'll need to specifically cast our return value as an int.

This will then return the truncated value.

The new type declarations can make code easier to read and

forces things to be used the way they were intended.

Some people prefer to use unit testing to check for intended use instead.

Having automated tests for your code is highly recommended, but

you can use both unit tests and type declarations working in harmony together.

Either way, PHP does not require that you declare types, but

it can definitely make code easier to read.

You can see right at the start of a function what is required and

what is returned.

When you are working with declared types with strict types turned on,

here are a few things to remember.

Strict types are enabled or disabled per file, not a php.ini setting.

Strict applies to the file in which the call to the function is made,

not the file in which the function is defined.

If strict is defined in test.php,

all function calls made from test.php have strict typing.

Integers will be widened into floats by adding dot zero.

All other type conversions will error.