1
00:00:00,540 --> 00:00:03,790
The first new feature I want
to cover is type declarations.

2
00:00:03,790 --> 00:00:07,850
This simply means specifying which
type of variable is being set,

3
00:00:07,850 --> 00:00:10,700
instead of allowing PHP to
set this automatically.

4
00:00:10,700 --> 00:00:14,450
PHP is considered a weak typed language.

5
00:00:14,450 --> 00:00:19,980
In essence, this means that PHP does not
require that you declare the data types.

6
00:00:19,980 --> 00:00:25,420
Variables still have data types associated
with them, but you can do radical things,

7
00:00:25,420 --> 00:00:28,450
like adding a string to an integer
without resulting in an error.

8
00:00:29,480 --> 00:00:33,040
Type declarations can help you
define what should occur, so

9
00:00:33,040 --> 00:00:35,270
that you get the expected results.

10
00:00:35,270 --> 00:00:37,810
This can also make your
code easier to read.

11
00:00:37,810 --> 00:00:39,750
We'll look at some
specific examples shortly.

12
00:00:40,920 --> 00:00:46,310
Since PHP5, you can use type hinting
to specify the expected data types

13
00:00:46,310 --> 00:00:51,680
of an argument in a function declaration,
but only in the declaration.

14
00:00:51,680 --> 00:00:54,390
When you call the function,
PHP will check whether or

15
00:00:54,390 --> 00:00:57,640
not the arguments are of
the specified type.

16
00:00:57,640 --> 00:01:02,570
If not, the runtime will raise an error
and the execution will be halted.

17
00:01:02,570 --> 00:01:06,250
Besides only being used
in function declarations,

18
00:01:06,250 --> 00:01:11,260
we are also limited to basically two
types, a class name or an array.

19
00:01:12,290 --> 00:01:12,980
Here's an example.

20
00:01:14,410 --> 00:01:17,550
If we were to create a function for
enrolling students,

21
00:01:17,550 --> 00:01:22,490
we would require that the first argument
be an object of the class, Student, and

22
00:01:22,490 --> 00:01:25,920
the second argument to
be an array of classes.

23
00:01:25,920 --> 00:01:29,900
If we tried to pass just the name of
the student instead of an object,

24
00:01:29,900 --> 00:01:31,740
we would get a fatal error.

25
00:01:31,740 --> 00:01:35,950
If we were to pass a single class
instead of an array of classes,

26
00:01:35,950 --> 00:01:38,180
we would also get an error.

27
00:01:38,180 --> 00:01:42,370
We are required to pass
a student object and an array.

28
00:01:43,490 --> 00:01:49,466
If we were to try to check for a scalar
variable, such as a string, PHP5 expects

29
00:01:49,466 --> 00:01:54,340
it to be an object of the class,
string, not the variable type, string.

30
00:01:55,840 --> 00:01:59,470
With PHP7, we now have added scalar types.

31
00:01:59,470 --> 00:02:04,260
Specifically, int,
float, string, and bool.

32
00:02:04,260 --> 00:02:08,380
By adding scalar type hints and
enabling strict requirements, it is hoped

33
00:02:08,380 --> 00:02:13,060
that more correct and self-documenting
PHP programs can be written.

34
00:02:13,060 --> 00:02:17,620
It also gives you more control over your
code and can make the code easier to read.

35
00:02:18,880 --> 00:02:24,110
By default, scalar type declarations
are non-strict, which means they attempt

36
00:02:24,110 --> 00:02:29,990
to change the original type to match the
type specified in the type declaration.

37
00:02:29,990 --> 00:02:34,850
In other words, if you pass a string that
starts with a number into a function that

38
00:02:34,850 --> 00:02:39,070
requires a float, it will grab
the number from the beginning and

39
00:02:39,070 --> 00:02:40,990
remove everything else.

40
00:02:40,990 --> 00:02:46,470
Passing a float into a function that
requires an int will become simply an int.

41
00:02:46,470 --> 00:02:49,730
Let's look at an example
of a non-strict type.

42
00:02:49,730 --> 00:02:53,207
The getTotal function receives two
floats and adds them together,

43
00:02:53,207 --> 00:02:55,470
while it returns the sum.

44
00:02:55,470 --> 00:02:59,180
Without strict types turned on,
PHP attempts to cast or

45
00:02:59,180 --> 00:03:03,600
to change these arguments to match
the type specified in the function.

46
00:03:03,600 --> 00:03:08,730
So when we call getTotal with non-strict
types using an int of two and

47
00:03:08,730 --> 00:03:14,010
a string of one week, PHP converts
these to floats, the first argument

48
00:03:14,010 --> 00:03:19,330
would be changed to 2.0, and the second
argument would be changed to 1.0.

49
00:03:19,330 --> 00:03:23,206
However, you will get a notice because
this is not a well formed numeric value.

50
00:03:23,206 --> 00:03:26,280
The function will then
return a value of three,

51
00:03:26,280 --> 00:03:29,400
which would be completely wrong
if we were trying to add days.

52
00:03:30,590 --> 00:03:35,548
When we call getTotal with the float
2.8 and the string of 3.2,

53
00:03:35,548 --> 00:03:39,822
PHP converts the string to
the float 3.2 with no notice,

54
00:03:39,822 --> 00:03:43,110
because it was a smooth conversion.

55
00:03:43,110 --> 00:03:45,696
It then returns a value of six.

56
00:03:45,696 --> 00:03:51,092
When we call getTotal with non-strict
types using the float 2.5,

57
00:03:51,092 --> 00:03:56,486
and the integer 1, the integer gets
converted to the float 1.0 and

58
00:03:56,486 --> 00:03:58,900
the function returns 3.5.

59
00:03:58,900 --> 00:04:03,759
Additionally, PHP7 gives us
the opportunity to enable strict mode

60
00:04:03,759 --> 00:04:06,200
on a file-by-file basis.

61
00:04:06,200 --> 00:04:10,220
We do this by declaring strict
types at the top of any given file.

62
00:04:10,220 --> 00:04:14,770
This must be the very first line,
even before name spaces.

63
00:04:14,770 --> 00:04:19,630
Declaring strict typing will ensure
that any function call made in that file

64
00:04:19,630 --> 00:04:21,690
strictly adheres to the type specified.

65
00:04:22,790 --> 00:04:27,130
Strict is determined by the file in
which the call to the function is made,

66
00:04:27,130 --> 00:04:29,940
not the file in which
the function is defined.

67
00:04:29,940 --> 00:04:34,080
If a type declaration mismatch occurs,
a fatal error is thrown, and

68
00:04:34,080 --> 00:04:36,930
we know that something is
not functioning as desired.

69
00:04:36,930 --> 00:04:40,860
Instead of allowing PHP to simply
guess at what we want to happen,

70
00:04:40,860 --> 00:04:46,290
allowing PHP to guess can cause seemingly
random and hard to diagnose issues.

71
00:04:46,290 --> 00:04:49,130
We'll look at catching and
handling errors in the next section.

72
00:04:49,130 --> 00:04:52,610
But for now, let's take a look at
examples using strict types turned on.

73
00:04:53,680 --> 00:04:56,150
When declare strict type
has been turned on,

74
00:04:56,150 --> 00:04:59,480
the first two calls that pass
a string will produce a fatal error.

75
00:05:00,610 --> 00:05:03,496
The exception to strict typing
is shown in the third call.

76
00:05:03,496 --> 00:05:07,253
If you pass an int as
an argument that is looking for

77
00:05:07,253 --> 00:05:11,189
a float,
PHP will perform what is called widening,

78
00:05:11,189 --> 00:05:16,122
by adding a dot zero to the end,
and the function returns 3.5.

79
00:05:16,122 --> 00:05:19,608
PHP7 also supports return
type declarations,

80
00:05:19,608 --> 00:05:23,016
which support all the same
types as arguments.

81
00:05:23,016 --> 00:05:26,791
To specify the return type,
we add a colon, and then the type,

82
00:05:26,791 --> 00:05:29,320
right before the opening curly bracket.

83
00:05:29,320 --> 00:05:34,190
If we specify the return type of float, it
will work exactly like it has been working

84
00:05:34,190 --> 00:05:39,510
in the previous two examples, since the
type being returned was already a float.

85
00:05:39,510 --> 00:05:44,120
Adding the return types allows you to
be sure that your function returns what

86
00:05:44,120 --> 00:05:45,880
you expected to return,

87
00:05:45,880 --> 00:05:50,040
as well as make int easy to see
up front how the function works.

88
00:05:50,040 --> 00:05:54,590
If we specify the return type
as int without strict type set,

89
00:05:54,590 --> 00:05:58,080
everything will work the same
as it did without a return type.

90
00:05:58,080 --> 00:06:01,920
The only difference is that it will
force the return to be an int.

91
00:06:01,920 --> 00:06:05,920
In the third call,
the return value will truncate to three

92
00:06:05,920 --> 00:06:07,720
because the floating
point will be dropped.

93
00:06:09,090 --> 00:06:13,200
If we turn strict types on,
we'll get a fatal type error.

94
00:06:13,200 --> 00:06:18,170
In this case, we'll need to specifically
cast our return value as an int.

95
00:06:18,170 --> 00:06:20,500
This will then return the truncated value.

96
00:06:21,640 --> 00:06:24,900
The new type declarations can
make code easier to read and

97
00:06:24,900 --> 00:06:28,150
forces things to be used
the way they were intended.

98
00:06:28,150 --> 00:06:33,160
Some people prefer to use unit testing
to check for intended use instead.

99
00:06:33,160 --> 00:06:36,590
Having automated tests for
your code is highly recommended, but

100
00:06:36,590 --> 00:06:41,028
you can use both unit tests and type
declarations working in harmony together.

101
00:06:41,028 --> 00:06:45,630
Either way, PHP does not require
that you declare types, but

102
00:06:45,630 --> 00:06:49,050
it can definitely make
code easier to read.

103
00:06:49,050 --> 00:06:52,976
You can see right at the start of
a function what is required and

104
00:06:52,976 --> 00:06:54,195
what is returned.

105
00:06:54,195 --> 00:06:57,971
When you are working with declared
types with strict types turned on,

106
00:06:57,971 --> 00:06:59,830
here are a few things to remember.

107
00:07:00,910 --> 00:07:07,570
Strict types are enabled or
disabled per file, not a php.ini setting.

108
00:07:07,570 --> 00:07:11,730
Strict applies to the file in which
the call to the function is made,

109
00:07:11,730 --> 00:07:13,930
not the file in which
the function is defined.

110
00:07:15,060 --> 00:07:17,899
If strict is defined in test.php,

111
00:07:17,899 --> 00:07:22,736
all function calls made from
test.php have strict typing.

112
00:07:22,736 --> 00:07:26,391
Integers will be widened into
floats by adding dot zero.

113
00:07:26,391 --> 00:07:28,700
All other type conversions will error.