Lassen Sie uns über den gültigen Bereich von „declare(strict_types=1)' sprechen.

Dieser Artikel stellt Ihnen den gültigen Deklarationsbereich vor (strict_types=1). Ich hoffe, dass er Freunden in Not hilfreich sein wird!

Über den gültigen Bereich von „declare(strict_types=1)“

declare(strict_type=1); ist die angegebene Syntax des in PHP7 eingeführten strikten Typprüfungsmodus

Single Wo soll strict_types in die Datei geschrieben werden

Grundlegende Syntax

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

var_dump(add(1.0, 2.0));

Bei unabhängiger Ausführung in diesem Zustand wird int(3)< ausgegeben /code ><code>严格类型检查模式的指定语法

单个文件时strict_types应写在哪里

基本语法

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

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

var_dump(add(1.0, 2.0));

在此状态下执行独立时，输出int（3）

我们提供的是double类型，但php7能很好的处理它,和php5时代没什么区别

做了如下变更

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

有TypeError产生,如下

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

declare(strict_types=1);

var_dump(add(1.0, 2.0));

strict_types不能写在脚本中间

declare语法不能写在脚本的中间,如下写法是错误的

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

产生如下错误

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

Fatal error产生,这甚至不是Throwable,而是编译过程中产生的错误

同样,与上述例子相似的位置,也不能使用如下语法

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

A.php脚本

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

两个文件时strict_types如何产生作用

如下代码

A.php脚本在开头声明严格模式

B.php脚本

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

A.php被B.php文件require,如下

$ php B.php
int(3)

执行结果

A.php

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

什么!!!!居然能够执行而不报错!!!!!
原来是B.php并没有声明strict_types,所以对于B脚本来说,是默认的松散模式

也就是说,对于strict_types有以下的行为

• 不管怎么样,函数定义时的严格模式,行为并不会出现什么不同
• 函数执行时的,严格模式会出现差异
• declare(strict_types=1);的语法本身在A.php文件中完成,而被B.php文件require,而B.php并没有定义严格模式,那么执行require的文件(B.php)不会变成严格模式

上述解释就如如下代码所示,理论上A.php文件的严格模式已经关闭了,然而仅仅是B.php文件设定了declare(strict_types=1);,那么即使A.php没有设定严格模式,但A.php被B.php引用了,就对A.php使用严格模式

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

C.php

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

三个文件时declare(strict_types=1);的作用

在函数定义部分使用declare(strict_types=1);

再增加一个require,试试3个文件嵌套

C.php → B.php → A.php

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;
}

$ 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

执行结果如下

C.php

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

• var_dump(add(1.0, 2.0)); 能正确执行
• var_dump(add2(1.0, 2.0));产生TypeError错误

也就是说,declare(strict_types=1);会按照如下方式变化

• 定义函数本身的文件,并不能产生效果
• 在定义的函数中调用其它函数,严格模式能产生效果(B.php使用了strict_types=1,同时B.php调用了A.php,所以A.php能起作用)

在主体部分中指定strict_types

不在B.php中途位置指定strict_types,而在主要部分即C.php指定,strict模式对所有的都有效吗?然而,事实上strict模式只有在引用的地方有效

C.php → B.php → A.php

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)

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(); // 执行严格模式
    }
}

• C.php中使用strict_types=1,因此add2(1.0,2.0)以严格模式执行,但是由于没有声明变量,所以没有任何效果
• 另一方面,具有add2()定义的B.php处于非严格模式

总结

只有在写declare的文件的执行部分才会执行严格模式,该文件中调用的其它函数(其它文件中的函数)也会被影响

也就是说,哪个文件写了declare

Was wir bereitstellen, ist der Typ double, aber php7 kann damit sehr gut umgehen und unterscheidet sich nicht vom Typ php5 code> era

Die folgenden Änderungen wurden vorgenommen

Bar.php

<?php
// 这个文件strict无效
class Bar
{
    private $moo;

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

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

Ein TypeError ist wie folgt aufgetreten

rrreee

strict_types kann nicht in geschrieben werden Mitte des Skripts

declare-Syntax kann nicht in die Mitte des Skripts geschrieben werden. Die folgende Schreibweise ist falsch

rrreee

Der folgende Fehler wird generiert🎜rrreee

Schwerwiegender Fehler generiert, der nicht einmal auslösbar ist, sondern ein Fehler, der während des Kompilierungsprozesses generiert wird🎜

Ebenso kann die folgende Syntax nicht an ähnlichen Positionen verwendet werden die obigen Beispiele🎜rrreeerrree

Wie wäre es mit strict_types, wenn es zwei Dateien gibt? Es funktioniert

🎜Der folgende Code🎜🎜

A.phpDas Skript deklariert zu Beginn den strikten Modus🎜rrreee

A.php ist B.php Datei require, wie folgt🎜rrreeeDas Ausführungsergebnis🎜rrreee

🎜Was!!!! Es kann ohne Fehler ausgeführt werden!!!!!!🎜
Es stellt sich heraus, dass B.php nicht deklariert strict_types, also ist es für B-Skript der standardmäßige lose Modus🎜

Mit anderen Worten, für strict_types gilt das folgende Verhalten🎜

• Egal Was, das Verhalten wird sich im strikten Modus nicht unterscheiden, wenn die Funktion definiert wird
• 🎜Wenn die Funktion ausgeführt wird Ja, es wird Unterschiede im strikten Modus geben 🎜
• declare(strict_types=1); Die Syntax selbst wird in der Datei A.php und der Datei B.php vervollständigt code>require und B.php definieren keinen strengen Modus. Führen Sie dann require aus. Die Datei (B.php) wird ausgeführt nicht zum strikten Modus werden

Die obige Erklärung ist wie im folgenden Code dargestellt. Theoretisch wurde der strikte Modus der Codedatei A.php deaktiviert. aber nur in der Datei <code>B.php ist declare(strict_types=1); festgelegt, auch wenn der A.php Strict-Modus nicht festgelegt ist, aber A.php wird von B.php referenziert, also verwenden Sie den strikten Modus für A.php 🎜rrreeerrreeerrreee

Die Rolle von declare(strict_types=1);, wenn drei Dateien vorhanden sind

Verwenden Sie declare(strict_types=1); im Funktionsdefinitionsteil >

Fügen Sie eine weitere Anforderung hinzu und versuchen Sie, 3 Dateien zu verschachteln🎜🎜C.php → B.php → A.phprrreeerrreeerrreee

Die Ausführungsergebnisse sind wie folgt🎜rrreee

var_dump( add(1.0, 2.0)); Kann korrekt ausgeführt werden
• var_dump(add2(1.0, 2.0));Produziert TypeError

Mit anderen Worten: declare(strict_types=1); ändert sich wie folgt🎜

• Die Datei, die die Funktion selbst definiert, hat keine Auswirkung
Rufen Sie andere Funktionen in der definierten Funktion auf. Der strikte Modus kann Auswirkungen haben (B.php verwendet strict_types=1 und B .php-Aufrufe). A.php, damit A.php funktionieren kann)

im Körperteil strict_types angegeben

Do Geben Sie strict_types nicht in der Mitte von B.php an, sondern im Hauptteil, C.php. Ist der strikte Modus für alle gültig? Tatsächlich ist der strikte Modus nur dort gültig, wo er in C.php angegeben ist B.php → A.phprrreeerrreeerrreeerrreee

• strict_types=1 wird in C.php verwendet, daher wird add2(1.0,2.0) im strikten Modus ausgeführt, aber da keine Variablen deklariert sind, ist dies auch der Fall keine Auswirkung
• Andererseits befindet sich B.php mit add2()-Definition im nicht-strikten Modus

Zusammenfassung

Nur beim Schreiben declare

führt den strikten Modus aus. Andere in der Datei aufgerufene Funktionen (Funktionen in anderen Dateien) sind ebenfalls betroffen🎜

Mit anderen Worten, welche Datei schreibt deklarieren, alle Codes in einer Datei müssen überprüft werden, auch wenn der darin enthaltene Code aus anderen Dateien stammt, und gleichzeitig wird die zu überprüfende Datei auch von anderen Dateien aufgerufen ändert nichts an der Tatsache, dass die Datei überprüft werden muss🎜rrreeerrreee 🎜🎜Lernempfehlung: „🎜PHP Video Tutorial🎜“🎜

Das obige ist der detaillierte Inhalt vonLassen Sie uns über den gültigen Bereich von „declare(strict_types=1)' sprechen.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!