class Number {

    private int|float $number;

 

    public function setNumber(int|float $number): void {

        $this->number = $number;

    }

 

    public function getNumber(): int|float {

        return $this->number;

    }

}

Supported types:

With certain limitations, union types support all available types. 

Void type:

The void type couldn't be important for an association, as void implies that a capacity doesn't give back any worth.

Null type:

The null type is only supported in union types, however; it is used, as an independent sort isn't permitted. 

Null able type notation: 

The nullable type notation (? T) is also permitted, which means T |null, however, we are not permitted to incorporate the ?T documentation in association types (?T1|T2 isn't permitted and we should utilize T1|T2|null all things being equal).

The same number of capacities (for example strpos(), strstr(), substr(), and so forth) include false among the conceivable return types, the errors pseudo-type is also supported. You can know more about Union Types V2 in the RFC.

For Internal Functions what kind of consistent type errors occurred? 

Internal and user-defined functions behave unexpectedly way if using a parameter of illegal type. However, user functions behaved in multiple ways, but user defined functions occurred multiple type error but both based on the condition. On the other hand, typical behavior gives a warning and returns null.  According to PHP 7.7, look at the following example; 

var_dump(strlen(new stdClass));

This would result in the following warning such as; 

Warning: strlen() expects parameter 1 to be string, object given in /path/to/your/test.php on line 4

NULL

The behavior will be different in case, the strict type is enabled, or argument information specifies types. In such circumstances, type error occurred in results. That kind of situation occurred multiple issues that will be well explained in RFC’s issues sections. Some internal parameters are made by this RFC proposes that remove these all issues with APIs that always occur a throwing error if the parameter will not match. 

 

In PHP 8, the code mentioned above throws the following error:

Fatal error: Uncaught TypeError: strlen(): Argument #1 ($str) must be of type string, object given in /path/to/your/test.php:4

Stack trace:

#0 {main}

  thrown in /path/to/your/test.php on line 4

What does mean by throw Expression? 

The throw is a statement in PHP, it is impossible to use in those places where only one expression is required. According to RFC, we can convert throw statement into an expression then that will be used in any kind of context where expressions are allowed such as, null coalesce, operator, arrow functions, ternary and Elvis operators, etc. Look at the following examples form the RFC;

$callable = fn() => throw new Exception();

 

// $value is non-nullable.

$value = $nullableValue ?? throw new InvalidArgumentException();

 

// $value is truthy.

$value = $falsableValue ?: throw new InvalidArgumentException();

 

What are weak maps in PHP 8? 

Weak maps allow making a guide from objects to self-assertive qualities (like SplObjectStorage) without forestalling the items that are used as keys from being trash gathered. If the real article key is trash gathered, it will be taken out from the map. In PHP 7.4, top-notch support weak references were presented at the time of introduction. However, commonly weak maps are used in practice but on the other hand, raw weak references are used for a limited time by them. 

However, on top of PHP weak references, the efficient weak map are not implemented in a possible way due to destruction callback is not provided for registration. The overall use case for weak maps is to connect information with singular item occasions, without driving them to remain alive and in this manner successfully spill memory in long-running cycles. For example, a week map might be used to memorize a calculation result:

Look at the following example from the RFC:

$map = new WeakMap;

$obj = new stdClass;

$map[$obj] = 42;

var_dump($map);

With PHP 8, the following result will produce by the above code (see the code in action here):

object(WeakMap)#1 (1) {

    [0]=>

    array(2) {

        ["key"]=>

        object(stdClass)#2 (0) {

        }

        ["value"]=>

        int(42)

    }

}

If we unset the object, the key is automatically removed from the weak map:

unset($obj);

var_dump($map);

Now the result would be the following:

object(WeakMap)#1 (0) {

}

For a closer look at Weak maps, see the RFC. The proposal was consistently approved.

What is Trailing Comma in Parameter List? 

Well! PHP 7.3 will not have an arrow function (that would be fantastic). However, an excellent addition in PHP 7.3 is trailing commas in function calls that will be valid syntax. In other words, you can use trailing commas when calling functions, but we can’t define them. However, trailing commas in function calls are explicitly helpful for variadic functions. However, PHP 7.2 introduced trailing commas in list syntax, PHP 7.3 introduced trailing commas in function calls, and now in 2020, PHP 8 introduced  trailing commas in parameter lists with functions, methods, and closures, as shown in the following example:

lass Foo {

    public function __construct(

        string $x,

        int $y,

        float $z, // trailing comma

    ) {

        // do something

    }

}

This proposal passed with 58 to 1 votes.

How can Allow:: class syntax on objects? 

To bring the name of a class, we can use the Foo\Bar:: class syntax. This RFC proposes to stretch out the similar syntax to objects so that it's presently conceivable to bring the name of the class of a given abject as appeared in the example below:

$object = new stdClass;

var_dump($object::class); // "stdClass"

                             

$object = null;

var_dump($object::class); // TypeError

 

With PHP 8, $object, the class gives a similar outcome as getting class ($object). However, $object isn't an object, it will occur with a Type Error special exception. This proposal was consistently approved.

What is Attributes v2? How can it work? 

Attributes are also called annotations Attributes that are a type of organized metadata that can be used to indicate properties for elements, files, or objects. Until PHP 7.4, doc-comments were the best way to add metadata to the declaration of classes, functions, etc.  Presently, the Attributes v2 RFC presents attributes for PHP characterizing them as a type of organized, syntactic metadata that can be added to affirmations of classes, properties, methods, parameters, and constants. Before the declarations, they refer to add attributes. From the RFC see the following example that also called annotations, are a type of organized metadata that can be used to determine properties for objects, elements, or files. 

<>

class Foo

{

    <>

    public const FOO = 'foo';

 

    <>

    public $x;

 

    <>

    public function foo(<> $bar) { }

}

 

$object = new <> class () { };

 

<>

function f1() { }

 

$f2 = <> function () { };

 

$f3 = <> fn () => 1;

Attributes can be added before or after a doc-block comment:

<>

/** docblock */

<>

function foo() {}

Each declaration may have one or more attributes and each attribute may have one or more associated values:

<>

<>

<>

function foo() {}

See the RFC for a deeper overview of PHP attributes, use cases, and alternative syntax.

What are the new functions of PHP 8?

There are multiple new functions to language that PHP 8 introduced now such as; 

• str_contains

• str_starts_with() and str_ends_with()

• get_debug_type

  1. str_contains: 

One of the improved used that PHP 8 brings that is the new str_contains function. As the name recommends, it checks if the given hayrick string contains a given string needle then to find out a given string that consists of another string that is used to the strpos() function. However, PHP developers are confused and not able to understand the use of both functions. Look at the given example; 

$mystring = 'Managed WordPress Hosting';

$findme = 'WordPress';

$pos = strpos($mystring, $findme);

 

if ($pos !== false) {

    echo "The string has been found";

} else {

    echo "String not found";

}

In this example we used! == Comparison operator that check the two types of similar values through which we get an error if the position of the needle is zero: 

 

str_contains functions may give back  Boolean FALSE, however, may also give back a non-Boolean worth which assesses to FALSE. [… ] Use the === operator for testing the return estimation of this function.

Besides, a few structures give helper functions to look to an incentive inside a given string (consider Laravel to be documentation for example). Now, this RFC stated the presentation of another function permitting to look inside a string: str_contains.

str_contains ( string $haystack , string $needle ) : bool

However, the use of this function is pretty direct that checks if a $needle is found in $haystack and returns valid or invalid accordingly. So, due to str_contains, we can write the following code:

$mystring = 'Managed WordPress Hosting';

$findme   = 'WordPress';

 

if (str_contains($mystring, $findme)) {

    echo "The string has been found";

} else {

    echo "String not found";

}

According to this code, we check that which function is more readable and which have fewer suspects of errors. So, str_contains case is sensitive at the time of writing but that will be changed in the future. 

However, the str_contains proposal passed with 43 to 9 votes.

• 2. str_starts_with() and str_ends_with():

 If you find a needle inside a given string then str_contains presents two updated functions such as str_starts_with and str_ends_with. 

We can check both functions if the provided string starts and ends with another function; 

str_starts_with (string $haystack , string $needle) : bool

str_ends_with (string $haystack , string $needle) : bool

Return of both functions false if $needle is longer than $haystack. Now, we could try not to use imperfect and less natural functions like substr, strops. Both functions are case sensitive:

$str = "WordPress";

if (str_starts_with($str, "Word")) echo "Found!";

 

if (str_starts_with($str, "word")) echo "Not found!";

You can see this code in action here.

This RFC has been approved with 51 to 4 votes.

• 3. get_debug_type:

That is the new function in PHP that gives back the type of a variable. The new function works in a significant comparative manner as the get type work, but get_debug_type returns native type names and resolves class names.

According to RFC, two examples are required for doing a difference between both functions such as; 

$bar = [1,2,3];

 

if (!($bar instanceof Foo)) { 

    throw new TypeError('Expected ' . Foo::class . ', got ' . (is_object($bar) ? get_class($bar) : gettype($bar)));

}

 

With PHP 8, we could use get_debug_type, instead:

if (!($bar instanceof Foo)) { 

    throw new TypeError('Expected ' . Foo::class . ' got ' . get_debug_type($bar));

}

 

The Following table shows returning values of get_debug_type and gets type:

Additional RFCs: 

Here are some additional approves improvements that will be part of PHP 8. 

1. Stringable interface: This RFC stated that automatically added a string able interface into the __to String() method. The main objective is to use the string|Stringable union type.

2. New DOM Living Standard APIs in ext/dom: In this RFC, we added the recent DOM Living Standard to the PHP DOM extension by introducing new interfaces and public properties.

3. Static return type: In PHP 8 proposed the use of static as return type next to self and parent types.

4. Variable Syntax Tweaks: In this RFC settle some leftover irregularities in PHP's variable sentence syntax.

SUMMARY:

With the release of the new PHP 8 version, we covered all the modifications and implementation. Now it’s your turn to get ready for testing the upcoming PHP features that one is your favorite? Drop your all queries in the comment section if you want to ask anything. We are available 24/7 a day.