Let's talk about the valid range of declare(strict_types=1)

This article will introduce to you the effective range of declare(strict_types=1). I hope it will be helpful to friends in need!

About the valid range of declare(strict_types=1)

declare(strict_type=1); is the strict type checking mode introduced in php7Specification syntax

When single filestrict_typesWhere should be written

Basic syntax

<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

var_dump(add(1.0, 2.0));

When executing independently in this state, outputint (3)

What we provide is the double type, but php7 can handle it well, and php5There is no difference in the times

The following changes were made

<?php
declare(strict_types=1);    //加入这句

function add(int $a, int $b): int
{
    return $a + $b;
}

var_dump(add(1.0, 2.0));

TypeError occurred, as follows

PHP Fatal error:  Uncaught TypeError: Argument 1 passed to add() must be of 
the type integer, float given, called in /Users/hiraku/sandbox/stricttypes/A.php on line 9 and defined in 
/Users/hiraku/sandbox/stricttypes/A.php:4
Stack trace:
#0 /Users/hiraku/sandbox/stricttypes/A.php(9): add(1, 2)
#1 {main}
  thrown in /Users/hiraku/sandbox/stricttypes/A.php on line 4

strict_typesCannot be written in the middle of the script

declareThe syntax cannot be written in the middle of the script. The following writing is wrong

<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

declare(strict_types=1);

var_dump(add(1.0, 2.0));

The following error occurs

PHP Fatal error:  strict_types declaration must be the very first statement in the script in 
/Users/hiraku/sandbox/stricttypes/A.php on line 7

Fatal error is generated, this is not even Throwable, but an error generated during the compilation process

Similarly, the following syntax cannot be used in positions similar to the above examples

<?php
declare(strict_types=1) {
  //...
}

PHP Fatal error:  strict_types declaration must not use block mode in 
/Users/hiraku/sandbox/stricttypes/A.php on line 2

When there are two filesstrict_typesHow does it work

The following code

A.phpscript Declaring strict mode at the beginning

A.php脚本

<?php
declare(strict_types=1);
function add(int $a, int $b): int
{
    return $a + $b;
}

A.php is B.php filerequire, as follows

B.php脚本

<?php
require &#39;A.php&#39;;
var_dump(add(1.0, 2.0));    //注意这里键入的是1.0和2.0浮点数,而A.php声明需要int

execution results

$ php B.php
int(3)

What!!!! It can be executed without error!!!!!
It turns out that B.php did not declare strict_types , so for B script, it is the default loose mode

That is to say, for strict_types there is the following behavior

• No matter what , there will be no difference in the strict mode behavior when the function is defined
• There will be differences in the strict mode when the function is executed
• declare(strict_types=1);'s syntax itself is completed in the A.php file, and is B.phpfilerequire, and B.php does not define strict mode, so the file (B.php) that executes require will not become strict mode

The above explanation is as shown in the following code. In theory, the strict mode of the A.php file has been turned off, but only the B.php file has set declare (strict_types=1);, then even if A.php does not set strict mode, A.php is referenced by B.php, Just use strict mode for A.php

A.php

<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

B.php

<?php
declare(strict_types=1);

require &#39;A.php&#39;;
var_dump(add(1.0, 2.0));

$ php B.php
PHP Fatal error:  Uncaught TypeError: Argument 1 passed to add() 
must be of the type integer, float given, called in /Users/hiraku/sandbox/stricttypes/B.php on line 4 and 
defined in /Users/hiraku/sandbox/stricttypes/A.php:2

When there are three files, the role of declare(strict_types=1);

is in the function definition part Use declare(strict_types=1);

to add another require and try nesting three files

C.php → B.php → A.php

C.php

<?php
require_once &#39;B.php&#39;;
var_dump(add(1.0, 2.0));
var_dump(add2(1.0, 2.0));

B.php

<?php
declare(strict_types=1);    //在函数定义部分声明
require_once &#39;A.php&#39;;
function add2($a, $b)
{
    return add($a, $b);
}

A.php

<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

The execution result is as follows

$ php C.php 
int(3)
PHP Fatal error:  Uncaught TypeError: Argument 1 passed to add() must be of the type integer, float given, called in 
/Users/hiraku/sandbox/stricttypes/B.php 
on line 7 and defined in /Users/hiraku/sandbox/stricttypes/A.php:2

• ##var_dump(add(1.0, 2.0)); Can be executed correctly
• var_dump(add2 (1.0, 2.0));Produces TypeError

In other words,

declare(strict_types=1);will change as follows

The file that defines the function itself will not produce effects
Calling other functions in the defined function, strict mode can produce effects (
• B.php uses strict_types= 1, at the same time B.php calls A.php, so A.php can work)

Specify strict_types in the main part

Do not specify strict_types in the middle of B.php, but specify it in the main part, C.php. Is strict mode valid for all? However, in fact, strict mode is only quoted in Valid place

C.php → B.php → A.php

C.php

<?php
declare(strict_types=1);    //主体部分声明
require_once &#39;B.php&#39;;
var_dump(add2(1.0, 2.0));

B.php

<?php
require_once &#39;A.php&#39;;
function add2($a, $b)
{
    return add($a, $b);
}

A.php

<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

$ php C.php 
int(3)

strict_types=1 is used in C.php, so add2(1.0,2.0) is executed in strict mode, But since no variables are declared, there is no effect
On the other hand, B.php with add2() definition is in non-strict mode

Summary

Only Strict mode will only be executed in the execution part of the file where

declare is written. Other functions called in the file (functions in other files) will also be affected.

In other words, which file If

declare is written, all the code in that file needs to be checked, even if the code in it comes from other files. At the same time, even if the file that needs to be checked is also called by other files, the file that needs to be checked will not be changed. Fact

Foo.php

<?php
// 这个文件的strict有效
declare(strict_types=1);

class Foo
{
    private $bar;

    public function __construct()
    {
        $this->bar = new Bar; // 执行严格模式
    }

    public function aaa()
    {
        $this->bar->aaa(); // 执行严格模式
    }
}

rrree

Recommended study: "

PHP Video Tutorial"

The above is the detailed content of Let's talk about the valid range of declare(strict_types=1). For more information, please follow other related articles on the PHP Chinese website!