What are the features in PHP7

Type declaration

Look at the code and it’s clear at a glance.

class person
{
    public function age(int $age) : string
    {
        return 'Age is ' . $age;
    }
}

Namespace and use keyword batch declaration

Non-mixed mode

use Publishers\Packt\{ Book, Ebook, Video};
use function Publishers\Packt\{ getBook, saveBook };
use const Publishers\Packt\{ COUNT, KEY };

Mixed mode

use Publishers\Packt\{
    Book,
    Ebook,
    Video,
    function getBook,
    function saveBook,
    const COUNT,
    const KEY
};

Composite mode

use Publishers\Packt\{
    Paper\Book,
    Electronic\Ebook,
    Media\Video
};

Anonymous Class

Anonymous classes are declared and used at the same time and have all the functions of other classes. The difference is that anonymous classes have no class name. The syntax is as follows:

new class(argument) { definition };

Anonymous classes have no class names, but within PHP, they will be assigned a globally unique name in the memory reference address table.

$name = new class('You') {
    public function __construct($name)
    {
        echo $name;
    }
};

Anonymous classes can inherit the parent class and its methods.

class Packt
{
    protected $number;

    public function __construct()
    {
        echo 'parent construct';
    }

    public function getNumber() : float
    {
        return $this->number;
    }
}

$number = new class(5) extends Packt
{
    public function __construct(float $number)
    {
        parent::__construct();
        $this->number = $number;
    }
};

echo $number->getNumber();

Anonymous classes can inherit interfaces.

interface Publishers
{
    public function __construct(string name, string address);
    public function getName();
    public function getAddress();
}

class packt
{
    protected $number;
    protected $name;
    protected $address;
    public function ...
}

$info = new class('name', 'address') extends Packt implement Publishers
{
    public function __construct(string $name, string $address)
    {
        $this->name = $name;
        $this->address = $address;
    }

    public function getName() : string
    {
        return $this->name;
    }

    public function getAddress() : string
    {
        return $this->address;
    }
}

echo $info->getName() . ' ' . $info->getAddress();

Anonymous classes can be nested in a class.

class Math
{
    public $first_number = 10;
    public $second_number = 10;
    public function add() : float
    {
        return $this->first_number + $this->second_number;
    }

    public function mutiply_sum()
    {
        return new class() extends Math
        {
            public function mutiply(float $third_number) : float
            {
                return $this->add() * $third_number;
            }
        };
    }
}

$math = new Math();
echo $math->mutiply_sum()->mutiply(2);

Abandon the old-fashioned constructor

Starting from PHP4, the constructor can declare itself as a constructor by naming it consistent with the class name. In PHP7, it is still possible to declare the constructor in this way. Use, but deprecated, will output deprecated information Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; Packt has a deprecated constructor in ..., It is recommended to use __construct() in PHP7.

throwable interface

Starting from PHP7, fatal errors in the program can be intercepted. PHP7 provides the throwable interface, and exceptions and errors are inherited from this interface.

Error

Now most fatal error conditions will throw an error instance, similar to intercepted exceptions, error instances can be intercepted by try/catch.

try
{
    ...
} catch(Error $e)
{
    echo $e->getMessage();
}

In some error situations, only sub-instances of error will be thrown, such as TypeError, DivisionByZeroError, ParseError, etc.

<=>Operator

<=>The operator will ==, < , >The three comparison operators are packaged together. The specific usage rules are as follows.

Returns 0 when both sides of the operator are equal
Returns -1 when the left side of the operator is less than the right side
Returns 1 when the left side of the operator is greater than the right side

null merge Operator

?? Combination operator can be returned directly when the first operand exists, otherwise the second operand is returned.

$title = $post['title'] ?? NULL;

$title = $post['title'] ?? $get['title'] ?? 'No title';

uniform variable syntax

$first = ['name' => 'second'];
$second = 'two';
echo $$first['name'];
echo ${Sfirst['name']}; // PHP7

...
echo $object->$methods['title'];
echo $object->{$methods['title']}; // PHP7

The main reason is that the parsing method of PHP7 is different from the previous version of PHP. Just add curly braces in PHP7, just like the above code, otherwise it will Report an error.

Constant array

Starting from PHP5.6, constant arrays can be declared using the const keyword. In PHP7, constant arrays can be declared through the define function. to initialize.

const STORES = ['en', 'fr', 'ar']; // php5.6
define('STORES', ['en', 'fr', 'ar']); // php7

Default value in switch

Before PHP7, multiple default values ​​were allowed in the switch statement. Starting from PHP7, there can only be one default value, otherwise a fatal level will occur. mistake.

// php7之前
switch (true) {
    case 'value':
        # code...
        break;
    default:
        # code...
        break;
    default:
        # code...
        break;
}

// php7
switch (true) {
    case 'value':
        # code...
        break;
    default:
        # code...
        break;
}

Option array in session_start function

Before PHP7, the session_start() function must be called first when using session, and this function has no parameters to be passed, all session-related configurations They are all in the php.ini file. Starting from PHP7, you can pass an array of parameter options when calling this function. These setting information will override the session configuration in php.ini.

session_start([
    'cookie_lifetime' => 3600,
    'read_and_close' => true
]);

unserialize function introduces filters

unserialize() can deserialize any type of object without any filter items, which is unsafe. PHP7 introduces filters in unserialize(), and Deserialization of all types of objects is allowed by default.

$result = unserialize($object, ['allowed_classes' => ['Book', 'Ebook']]);

The above is the detailed content of What are the features in PHP7. For more information, please follow other related articles on the PHP Chinese website!