An example of a function that does nothing. It has a name, no input arguments, an empty body, it doesn’t return anything (no return value):<\/span><\/p>\n<?<\/b>php<\/b>\r\nfunction nothing()\r\n{}<\/pre>\nor we can try something meaningful, e.g.:<\/span><\/p>\n<?<\/b>php<\/b>\r\nfunction<\/span> content_of_circle_using_radius<\/span>(<\/span>$radius<\/span>)<\/span>\r\n{<\/span>\u00a0<\/span>\r\n\u00a0\u00a0\u00a0\u00a0<\/span>return<\/span> M_PI <\/span><\/i>*<\/span> $radius <\/span>**<\/span> 2<\/span>;<\/span>\r\n}<\/span><\/pre>\nThis function has a name, an input argument, a body and a return value. The function defined in this way (as the name implies) returns the area of the circle according to the specified argument (it should be a radius). We can reasonably deduce that from the definition.<\/span><\/p>\nHowever, there may be situations created in the program when the function doesn’t return the expected result. E.g. if <\/span>$radius = \u2018xXx\u2019; <\/b>at best it throws out an<\/span> exception <\/b>(from php v8.0) or returns a <\/span>0.<\/b> What about the return value? In this case, it’s still a <\/span>float<\/b>, but if we don’t know (see) the body of the function, it could be anything. Therefore, we shouldn’t rely on <\/span>float<\/b>, but we should also treat it after calling the function so that the program behaves as expected.<\/span><\/p>\nThis can be avoided a little and the definition of the function can be supplemented by the types of input arguments and the type of return value \u2013 this can be described in the function description. In order for the interpreter to verify and evaluate it for us, we turn on the so-called <\/span>strict mode<\/b>. Insert <\/span>declare(strict_types=1)<\/b> at the beginning of the file.<\/span> In strict mode, PHP expects values with the same type as the target types. If a mismatch occurs, PHP invokes an exception (<\/span>TypeError<\/b>). Like this:<\/span>\u00a0<\/b><\/p>\n<?php\r\ndeclare(strict_types=1);\r\n\/**<\/i>\r\n* @param float $radius radius, should be positive value<\/i>\r\n*<\/i>\r\n* @return float<\/i>\r\n*\/<\/i>\r\nfunction content_of_circle_using_radius(float $radius): float\r\n{\r\n\u00a0\u00a0\u00a0return M_PI <\/i>* $r ** 2;\r\n}<\/pre>\nNow we know by definition that the argument must be a <\/span>float <\/b>and the return value will also be a <\/span>float.<\/b> We can certainly rely on that now.<\/span><\/p>\nWhen creating functions, it’s sometimes advisable to set the<\/span> default<\/b> value of the argument. This is used mainly if we assume that the argument will be the same in most cases. To define the default value, we simply assign it to a variable.<\/span><\/p>\n<?<\/b>php<\/b>\r\ndeclare<\/span>(<\/span>strict_types<\/span>=<\/span>1<\/span>);<\/span>\r\nfunction<\/span> how_you_feel<\/span>(<\/span>string<\/span> $name<\/span>,<\/span> int<\/span> $age <\/span>=<\/span> 25<\/span>):<\/span> string<\/span>\r\n{<\/span>\r\n\u00a0\u00a0\u00a0<\/span>return<\/span> $name <\/span>.<\/span> \" feels \"<\/span> .<\/span> $age <\/span>.<\/span> \" years old\"<\/span>;<\/span>\r\n}<\/span>\r\nhow_you_feel<\/span>(<\/span>\"Tomas\"<\/span>);<\/span> \/\/ returns Tomas feels 25 years old<\/span>\r\nhow_you_feel<\/span>(<\/span>\"Viktor\"<\/span>,<\/span> 43<\/span>);<\/span> \/\/ returns Viktor feels 43 years old<\/span><\/pre>\nThis actually tells us that the argument is optional and we can omit it when calling the function. Here, however, it should be noted that optional arguments, or arguments with default values, should be placed after the mandatory arguments. Since PHP v8.0.0, it’s <\/span>deprecated<\/b> to declare optional arguments before mandatory ones. However, there’s an exception \u2013 if an optional argument has a specified type and has a declared default value of <\/span>null<\/span><\/i>, then it’s possible to place it before the mandatory argument. So it’s essentially necessary to enter it when calling, but we can use a <\/span>null value.<\/span><\/i><\/p>\n<?<\/b>php<\/b>\r\ndeclare<\/span>(<\/span>strict_types<\/span>=<\/span>1<\/span>);<\/span>\r\nfunction<\/span> foo<\/span>(<\/span>$bar<\/span>,<\/span> $baz<\/span>)<\/span> {}<\/span> \/\/ all ok<\/span>\r\nfunction<\/span> foo<\/span>(<\/span>$bar<\/span>,<\/span> $baz <\/span>=<\/span> null<\/span>)<\/span> {}<\/span> \/\/ all ok<\/span>\r\nfunction<\/span> foo<\/span>(<\/span>$bar <\/span>=<\/span> null<\/span>,<\/span> $baz<\/span>){}<\/span> \/\/ deprecated as of PHP v8.0.0<\/span>\r\nfunction<\/span> foo<\/span>(<\/span>int<\/span> $bar <\/span>=<\/span> null<\/span>,<\/span> $baz<\/span>){}<\/span> \/\/ all ok<\/span><\/pre>\nWhen declaring a function, we can also use “…”, the so-called spread operator. This notation tells us that a function can have a variable number of arguments.<\/span><\/p>\n<?<\/b>php<\/b>\r\ndeclare<\/span>(<\/span>strict_types<\/span>=<\/span>1<\/span>);<\/span>\r\nfunction<\/span> foo<\/span>(<\/span>$bar<\/span>,<\/span> ...<\/span>$baz<\/span>)<\/span> {}<\/span>\r\nfoo<\/span>(<\/span>1<\/span>,<\/span> 2<\/span>);<\/span> \/\/ valid call<\/span>\r\nfoo<\/span>(<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>);<\/span> \/\/ valid call<\/span><\/pre>\nThe <\/span>$baz <\/b>argument is a field of arguments, i.e. in the function body, the argument can be scrolled as a classic field, e.g. by <\/span>foreach<\/span><\/i>. We can even set the type for the given variable arguments,\u00a0<\/span><\/p>\n<?<\/b>php<\/b>\r\ndeclare<\/span>(<\/span>strict_types<\/span>=<\/span>1<\/span>);<\/span>\r\nfunction<\/span> foo<\/span>(<\/span>$bar<\/span>,<\/span> int<\/span> ...<\/span>$baz<\/span>)<\/span> {}<\/span>\r\nfoo<\/span>