php教程文章

PHP7—新特性

PHP7—新特性

PHP7.0添加标类型声明的串，整数、浮点数，布尔

PHP7.0增加支持返回的类型声明

PHP7.1增加支持可空参数类型和返回的类型

void 是一个有效的回归类型的PHP 7.1

PHP7.1增加了一个新的化合物类型称为可迭代

PHP7.4增加了对类型的属性，其种类型的类属性

PHP7.x带来一些改进和新的功能触的所有方面的语言，包括更好地支持面向对象的节目，扩展到课程和接口，改进型系统、错误处理，以及更多。在这一系列文章中，我们讨论的新功能的各种PHP7.x版本.

关键的外卖

PHP7.0添加标类型声明的串，整数、浮点数，布尔

PHP7.0增加支持返回的类型声明

PHP7.1增加支持可空参数类型和返回的类型

void 是一个有效的回归类型的PHP 7.1

PHP7.1增加了一个新的化合物类型称为可迭代

PHP7.4增加了对类型的属性，其种类型的类属性

在本文中，我们探索新型有关的功能，可在PHP7.x.

标类型的声明

类型的声明是没有什么新PHP. 类型的声明是用于注释功能的参数和附加说明的参数需要的参数被指定的类型。支持类型的声明上课，接口，和 self 加入PHP5.0.0中，同时支助类型的声明 array 加入PHP5.1.0，并支持为类型的声明 callable 加入 5.4.0.

PHP7.0增加支持标类型声明的类型 string (字符串), int (整数), float (浮点的数字)，和 bool (布尔).

来证明种类的声明与一个例子，创建一个脚本 (typedeclr.php) 在该文件根目录和复制下清单中的脚本:

<?phpclass A {}class B extends A {}class C {}function f(A $a) {
	echo get_class($a)."\n";}
 f(new A);f(new B);f(new C);?>

类 B 延伸类 A. 类 C 不会延长的任何类和定义功能 f() 与一个参数的类型 A. 然后，脚本调功能通过实例之类 A, B 和 C 依次为论据。假设相同的安装因为在第一篇文章 PHP7—开始并改进面向对象, 运行的脚本用的url http://localhost:8000/typedeclr.php. 同时呼吁 f() 通过类的实例 A 和 B 没有产生错误和输出价值定义功能，调用 f() 与一个参数的类型 C 产生一个 TypeError:

AB

Uncaught TypeError. Argument 1 passed to f() must be an instance of A, instance of C given

现在，让我们讨论标类型。标类型分为两种, 胁迫性 (默认)和严格. 创建一个脚本 sumints.php 和定义vararg功能把参数的类型 int. 调用的功能与一些参数提供浮点数字和其他作为串的，例如:

echo SumInts(1,'3',0,3.6);

的 sumints.php 脚本是下面列出，包括评论说出 declare 指令，我们将稍后讨论的时候，我们掩盖的严格标类型

<?php
   //declare(strict_types=1);
  function SumInts(int ...$ints) 
  {
  	return array_sum($ints);
  }
  echo SumInts(1,'3',0,3.6);?>

如果你跑的脚本，它将输出的总的参数转化为整数值。换句话说，是错误的类型参数得到转换为(强制)的预期类型。一个值的9输出 sumints.php 如图 1.

图1。输出 sumints.php

浮点数转换为一个整数通过消除小数值。作为一个例子3.6变3和没有得到四舍五入至4。 String value'3'被转换成 3.

严格的标类型声明的工作在一个完全不同的方式。首先，严格式仅可用于标类型声明，不上课，接口，可调用，或阵列类型的声明。回到以前的剧本和注释的 declare() 指令的使用严格的标类型声明。注意到 declare() 指令必须出现在该文件在其严格的方式对标类型的声明是可以使用.

declare(strict_types=1);

运行的脚本再次和你会看到一个 TypeError 被提出。的 TypeError 表明的参数必须的类型 int.

Uncaught TypeError: Argument 2 passed to SumInts() must be of the type int, string given

严格的模式不适用于功能的电话从内部(内)的功能.

当使用强制性模式(默认的方式)对标类型声明， null 值的论点并未得到胁迫或转换为所需类型和一个 TypeError 是引发，而不是。为了证明这一点，创建一个脚本 sumints_null.php 在这一功能期待一个整数值是提供一个 null arg:

<?php
  function SumInts(int ...$ints) 
  {
  	return array_sum($ints);
  }
  echo SumInts(1,'3',0,null);?>

如果你跑的脚本，你会得到一个 TypeError.

Uncaught TypeError: Argument 4 passed to SumInts() must be of the type int, null given

如果你想让一个 null 参数，必须指定一个 null 默认值相对应的参数作为在下列脚本:

 <?php
  function SumInts(int $a=null) 
  {
  	return array_sum($a);
  }
  echo SumInts(null);?>

具有严格的方式、参数值的必须是定义的类型的功能有一个例外：整数值可以提供给功能期待一个漂浮.

为了证明这一点，创建一个脚本 sum_floats.php 在其中一个可变的功能与浮动类型参数的定义。援引的功能穿整数的一些参数:

<?phpdeclare(strict_types=1);
  function SumFloats(float ...$floats) : float  {
  	return array_sum($floats);
  }
  echo SumFloats(1.1,2.5,3);?>

运行程序有结果时，浮动数量 6.6, 打印出来。在这种情况下， int 值得到转换为 float.

我们的下一次例会展示如何使用严格的标类型声明与浮动的类型。创建一个脚本 sumfloats.php 和定义功能有两个参数的类型 float 和返回的类型 int. 回型宣言》是另一个新特点和更详细的讨论之后，我们将只是假设他们是确定此一例。该功能将返回的价值通过增加其两个参数。调用则的功能有一个参数的类型 int 和其他的类型 string:

<?phpdeclare(strict_types=1);
 
  function SumFloats(float $a, float $b) : int  {
  	return $a + $b;
  }
 
  echo SumFloats(1,'3');
 ?>

如果你跑的剧本， TypeError 为生成指示一个说法传递到一个功能必须的类型 float 虽然一个 string 给予.

Uncaught TypeError: Argument 2 passed to SumFloats() must be of the type float, string given

如果删除该声明指令严格的模式和运行的脚本再次强制性模式会给你一个输出值 4.

标类声明可使用的字符串。创建一个脚本 reverse.php 并添加功能，它需要一个 string 参数，相反它，返回得到的 string. 使用一个尝试/抓块，调用的功能与一个浮点价值 3.5:

 <?php
  
  function Reverse(string $a) 
  {
  	return strrev($a);
  }
 try{
  echo Reverse(3.5);}catch (TypeError $e) {
	echo 'Error: '.$e->getMessage();}?>

如果你跑的脚本，你会得到一个的价值 5.3 在强制性的模式。如果添加这一指令 declare(strict_types=1); 对于严格的模式和再次运行脚本， Error 升起:

Error: Argument 1 passed to Reverse() must be of the type string, float given

严格的打字为标类型声明仅适用于功能的呼吁文件内的严格的打字已启用并不能呼叫的从另一文件，该文件没有声明严格的打字。同样，如果文件，使功能的电话还有严格的打字启用的、严格的方式使用.

来证明，创建一个PHP script reverse_2.php 具有严格的模式的启用。增加一个功能(称为 Reverse) 反转并返回 string 参数值:

<?phpdeclare(strict_types=1);
  function Reverse(string $a) 
  {
  	return strrev($a);
  }?>

创建，现在另一个脚本 reverse_1.php 需要 reverse_2.php 脚本，并援引它的反向功能与一个浮点价值:

<?phprequire_once('reverse_2.php');
  echo Reverse(3.5);?>

运行 reverse_1.php 脚本。作为严格的模式启用在 reverse_2.php, 人们可能预期的那一个 TypeError 将产生的作为功能要求一个 string 值是调用了一个浮点值。但 reverse_1.php 使用微弱的打字和浮点值是返回的一个输出 5.3. 相反，如果严格的模式启用在 reverse_1.php, 严格的打字应用和 TypeError 生成的:

Uncaught TypeError: Argument 1 passed to Reverse() must be of the type string, float given

我们的下一个例子涉及与标类型声明的布尔的类型。创建一个脚本 test.php 具有严格的模式的启用，并添加一个功能，可接受一个参数的类型 bool 而简单地返回未改变的参数值。援引的功能有一串值'真实的’:

<?phpdeclare(strict_types=1);
 function test(bool $param) {return $param;}
  echo test('true')
 ?>

运行中的脚本浏览器将给你一个 TypeError.

Uncaught TypeError: Argument 1 passed to test() must be of the type bool, string given

如果的 declare 指令为严格的方式是评论或删除该脚本是再次运行，强制性模式的应用。在这种情况下， string ‘真正的'变转化为 bool 值 true 并将输出 1.

现在，我们将进一步深入有关使用 NULL 价值观与标类型字符串.

创建一个 脚本string_null.php 含有两个功能，每个需要一串的论点。一种功能具有的缺省参数值设定为 NULL 和其他功能没有默认值设定的。援引的每个职能 string 值，没有任何价值， null 值:

<?phpfunction string_null_1(string $str) {
  var_dump($str);}function string_null_2(string $str = NULL) {
  var_dump($str);}string_null_1('a');     string_null_2('b');   string_null_1();string_null_2();      string_null_2(null); string_null_1(null);   ?>

如果你跑的 脚本，string_null_1 会产生错误时，援引没有论点.

Uncaught ArgumentCountError: Too few arguments to function string_null_1(), 0 passed in

评论的话功能，产生上述消息，再次运行脚本。你会看到的功能提供的电话 string 类型输出参数的一个字符串，如预期。叫 string_null_2, 其中有一个默认值设定为 NULL, 与没有参数产出 NULL. 叫 string_null_2 与 NULL 值作为参数，也产出 NULL, 如预期的那样。叫 string_null_1() 传递 NULL 产生一个 TypeError, 相反，由于 NULL 论点没有得到转化为一个 string 在强制性模式.

回归类型的声明

因为我们简述，PHP7.0增加支持返回的类型声明，它们类似于参数类型的声明。同PHP类型可能会被用于与返回有类型声明作为与参数类型的声明。要证明使用的回报类型声明，创建一个脚本 reverse_return.php 声明的功能与string类型的参数和返回类型字符串.

<?php
  function Reverse(string $a) : string 
  {
  	return strrev($a);
  }try{
  echo Reverse('hello');}catch (TypeError $e) {
	echo 'Error: '.$e->getMessage();}?>

调用的功能与输入值 “hello” 和颠倒的字符串 olleh 被输出。严格式的指令，使用标类型的声明是也适用于返回的类型声明。为了证明这一点，创建一个脚本 reverse_return_strict.php 并添加严格的方式指示在开始。然后添加一个功能，需要一串参数和返回 string 值。而不是返回的一串的价值，使实际价值的返回是一个整数:

<?phpdeclare(strict_types=1);
  function Reverse(string $a) : string 
  {
  	return 5;
  }
 try{
  echo Reverse("hello");}catch (TypeError $e) {
	echo 'Error: '.$e->getMessage();}
 ?>

援引的功能有一串的价值。运行的脚本将产生一个错误:

Error: Return value of Reverse() must be of the type string, int returned

如果你移除了严格的模式宣言，从而切换到强制性的模式，并再次运行脚本，你会看到的价值"5"是打印出来。在这种情况下， int 值返回是一个铸造 string 由于薄弱的打字.

在强制性的模式，返回的价值得到转化为预计返回的类型，如果需要的。修改脚本和声明的功能返回的类型是一个 int, 但实际上返回一个string'5'，而不是.

<?php
  	function Reverse(string $a) : int  {
  	return '5';
  }try{
  echo Reverse("hello");}catch (TypeError $e) {
	echo 'Error: '.$e->getMessage();}
 
 ?>

援引的功能传递一个串的价值。在这种情况下， int 类价值的5返回后，被转换为从string value'5'. 的转换作出强制性的模式，返回值的可兑换的声明返回的类型。作为一个例子，如果你宣布一个int返回的类型和返回的string'five'生成错误.

Return value of Reverse() must be of the type int, string returned

虽然标类型的声明是新PHP7、类型声明，都不支持。类型可用于返回的类型声明，但是，正如我们必须证明下.

创建一个脚本 return_obj.php 和声明的一类 Catalog 其中包括一些变量，典型的一本杂志目录。实例类和设置价值观其变量。声明然后一个功能返回的类型 Catalog 采用单一类型的参数 Catalog. 在体的这个功能，只需返回的输入参数本身:

function getCatalog(Catalog $catalog): Catalog {
	return  $catalog;}

援引的功能有一个 Catalog 类对象然后输出返回的价值.

var_dump(getCatalog($Catalog1));

的 return_obj.php 脚本是列出:

<?phpclass Catalog{
	pubpc $title;
	pubpc $edition;}
 $Catalog1 = new Catalog();$Catalog1->title = 'Oracle Magazine';$Catalog1->edition = 'January-February2018';function getCatalog(Catalog $catalog): Catalog {
	return  $catalog;}var_dump(getCatalog($Catalog1));?>

运行的脚本输出 Catalog 类对象领域的价值观，如图 18.

object(Catalog)#1 (2) { ["title"]=> string(15) "Oracle Magazine" ["edition"]=> string(20) "January-February2018" }

作为我们讨论的第一条在这个系列, 开始并改进面向对象, 类继承PHP7.2支持一个级别的回报类型的协变和逆变为没有类型。你还记得，协返回的类型使得有可能提供一个较窄的回报类型，同时逆变的参数类型使得有可能提供一个更通用的参数类型。 PHP7.4加完全支持的协变和逆变.

为了证明这一点，创建一个脚本 return_type_inheritance.php. 添加一个类 Catalog 用一个功能宣布string类型的参数并没有返回的类型。创建的另一类 CatalogMagazine 这一延伸的 Catalog 类。回归类型的功能 string 和参数类型略，依靠PHP7参数类型扩大支持。实例的各类援引的功能输出值返回:

<?phpclass Catalog{
	pubpc function printItem(string $string)
	{
    	return 'Catalog: ' . $string . PHP_EOL;
	}}class CatalogMagazine extends Catalog{
	pubpc function printItem($string) : string	{
        return 'CatalogMagazine: ' . $string . PHP_EOL;
	}}$catalog = new Catalog();$catalogMagazine = new CatalogMagazine();echo $catalog->printItem('Catalog'); echo $catalogMagazine->printItem('CatalogMagazine'); ?>

运行的脚本中将输出的回价值的功能定义在各类对象:

Catalog: Catalog CatalogMagazine: CatalogMagazine

空类型

这是不寻常的空值是通过为功能的参数或者返回的一个函数。的 null type in PHP只有一个价值，它是情况不敏感的 NULL.

PHP7.1已加入支持可空参数类型和可空的回报类型。前缀的一个参数或者返回的类型有一个问号 ? 使它可以为null. 展示使用空类型创建一个脚本 hello-nullable.php. 定义功能 hello() 指定一个可空的回报类型。可空并不意味着功能已返回null,虽然,所以让我们回归实际价值:

function hello(): ?string{
	return 'Hello';}

定义现在的另一个功能与可空返回的类型，实际上返回 NULL:

function hello_return_null(): ?string{
	return null;}

最后，定义的功能有一个可空参数类型:

<?phpfunction hello(): ?string{
	return 'Hello';}echo hello();echo "<br/>";function hello_return_null(): ?string{
	return null;}echo hello_return_null();echo "<br/>";function hello_null_arg(?string $name){
	return 'Hello';}echo hello_null_arg(null);echo "<br/>";?>

运行的脚本时会产生以下产出:

Hello

第二个函数呼吁没有输出产生因为 echo 将其论点的一串和空没有任何相应的 string 值。如果 var_dump() 而不是使用一个回音 NULL 值应该得到以下产出:.

Hello

NULL

Hello

接下来，我们应证明有一个例子，如果返回型的一个函数是一种类型，空不能返回。创建一个脚本 return_null.php 和复制以下清单:

<?phpclass Catalog{
	pubpc $title;
	pubpc $edition;}$Catalog1 = new Catalog();$Catalog1->title = 'Oracle Magazine';$Catalog1->edition = 'January-February2018';function getCatalog(?Catalog $catalog): ?Catalog {
	return  $catalog;
 }function getCatalog_2(?Catalog $catalog): ?Catalog {
	return  null;}function getCatalog_3(?Catalog $catalog): Catalog {
	return  $catalog;}var_dump(getCatalog(null));var_dump(getCatalog_2(null));var_dump(getCatalog_3(null));?>

脚本声明的一类 Catalog 有两个领域。剧本创建了一个类实例并将其场价值的初始化。所有的三种功能在脚本声明一个可空类型的参数 Catalog. 两个功能有可空的回报类型 Catalog 和一个功能具有非空返回的类型 Catalog. 每个职能是调用了一个空的论点和呼吁在被封闭 var_dump().

作为输出指示，如果返回型是可空和空参数通过，返回值null是否实际的参数或者返回null。但是，如果返回的类型是一类型，例如 Catalog 和空返回，则会产生错误指示的回报价值，必须是一个实例类型，例 Catalog:

NULL NULL

Uncaught TypeError: Return value of getCatalog_3() must be an instance of Catalog, null returned

使用无效作为回报类型的功能

如前所述，支持返回的类型声明加入在PHP7.0，同时PHP7.1介绍了 void 返回的类型。在一个功能返回无效，返回的声明应该是空的或者完全省略. NULL 不要混淆 void 类型. NULL 是一个值为零类型，而无效意味着没有价值.

展示使用一个 void 回型的，创造一个剧本 hello-void.php 和复制以下列入该文件:

<?phpfunction hello(): void{
	echo 'Hello';
	return;}echo hello();echo "<br/>";?>

脚本声明一个函数 hello() 与返回的类型 void. 功能输出的'Hello'string和具有空返回的发言。如果返回的类型 void 功能不能返回值。运行的脚本中，"Hello"输出.

接下来，我们证明这一功能返回的类型 void 不允许返回值，甚至不 NULL. 创建一个脚本 return_void.php 和声明的一类 Catalog 含有一个功能返回的类型无效，返回 NULL. 援引的功能传递一个实例 Catalog 作为一个参数。的 return_void.php 脚本是列在这里:

<?phpclass Catalog{
	pubpc $title;
	pubpc $edition;}$Catalog1 = new Catalog();$Catalog1->title = 'Oracle Magazine';$Catalog1->edition = 'January-February2018';function getCatalog(Catalog $catalog): void {
	return NULL;}var_dump(getCatalog($Catalog1));?>

运行的脚本输出错误信息.

A void function must not return a value (did you mean "return;" instead of "return null;"?)

修改脚本略有这样的功能有一个空的 return 发言，这是有效的 void 返回的类型。调用的功能与的实例 Catalog 作为一个arg.

function getCatalog(Catalog $catalog): void {
	return;}var_dump(getCatalog($Catalog1));

在这种情况下，一个价值 NULL 返回以来，我们用一个空返回的声明， var_dump 得很清楚.

新类型可迭代

的 iterable 是一个新的化合物类型PHP7.1. 伪类型的关键词用于类型或价值观的参数可能有。的 iterable 类型可用作参数类型或返回的类型。它接受一系列或一个目，实现了 Traversable 接口，这两者都可以迭代使用 foreach.

第一，我们应证明如何使用 iterable 有一阵列。创建一个脚本 iter.php 在其声明的功能与参数类型 iterable. iterable 类参数可以声明的默认值 NULL 或阵列。在功能迭代的迭代使用 foreach() 并输出其价值。创建一个数组，并援引的功能，使用列为其论点。的 iter.php 被列.

<?php$catalog = ['Oracle Magazine','Java Magazine','PHP Magazine'];function iterator(iterable $iter){
	foreach ($iter as $val) {
    	echo $val;
    	echo "<br/>";
	}}iterator($catalog);?>

运行的脚本输出阵列数值:

Oracle Magazine

Java Magazine

PHP Magazine

一个 iterable 也接受类对象，实现了 Traversable 接口。为了证明这一点，创建一个脚本 iter_traversable.php 并宣布一个类实现了 IteratorAggregate 接口，这进一步延伸 Traversable 接口。宣布三类属性.

pubpc $journal1 = "Oracle Magazine";
	pubpc $journal2 = "Java Magazine";
	pubpc $journal3 = "PHP Magazine"

添加一个类的构造实现接口功能 abstract pubpc Traversable getIterator ( void ). 让我们叫这个类 catalogData. 在同一个剧本，还宣布一个功能用参数类型 iterable. 在这个功能，使用 foreach 迭代过 iterable 参数和输出它的价值:

function iterator(iterable $iter){foreach($iter as $key => $value) {
    var_dump($key, $value);
	echo "\n";}}

最后，调用的功能与该类的一个实例 catalogData 作为一个参数:

$obj = new catalogData;iterator($obj);The iter_traversable.php script is psted:<?phpclass catalogData implements IteratorAggregate {pubpc $journal1 = "Oracle Magazine";
	pubpc $journal2 = "Java Magazine";
	pubpc $journal3 = "PHP Magazine";
	pubpc function __construct() {
     	
	}
 
	pubpc function getIterator() {
    	return new ArrayIterator($this);
	}}$obj = new catalogData;function iterator(iterable $iter){foreach($iter as $key => $value) {
    var_dump($key, $value);
	echo "\n";}}iterator($obj);?>

现在，运行的脚本输出的关键值对在可迭代:

string(8) "journal1" string(15) "Oracle Magazine" string(8) "journal2" string(13) "Java Magazine" string(8) "journal3" string(12) "PHP Magazine"

的 iterable 类支持完全逆变(参数类型)和方差(返回型)。协变和逆变的详细讨论了在一个较早的文章 PHP7—开始并改进面向对象. 完全逆变意味着参数类型 array 和 Traversable 可以扩大到 iterable. 全协意味着返回的类型 iterable 可以缩小到 array 或 Traversable. 接下来，我们应证明的协变和逆变有可迭代使用的一个例子。创建一个脚本我ter_extend_ret_type.php 并宣布一类含一个迭代的功能与一系列参数和nullable可迭代返回的类型。在这一类别中，迭代过 array 参数的使用 foreach 并输出其价值。声明一个类扩展的第一个，复盖 iterator 功能与功能，具有一个 iterable 参数和nullable array 返回的类型。创建一个实例延伸类和援引其迭代功能。脚本是列在这里:

<?phpclass ClassA{function iterator(array $arr)  : ?iterable{
	foreach ($arr as $val) {
    	echo  $val;
    	echo "<br/>";
    	return null;
	}}}class ClassB extends ClassA{function iterator(iterable $iter)  : ?array{
	foreach ($iter as $val) {
    	echo  $val;
    	echo "<br/>";
 
   	
	}return null;}}$catalog = ['Oracle Magazine','Java Magazine','PHP Magazine'];$classB=new ClassB();$classB->iterator($catalog);?>

运行的脚本，其中将输出:

Oracle Magazine

Java Magazine

PHP Magazine

功能返回的类型 iterable 也可以用作发电机。作为一个例子，创建一个脚本 iterable_gen.php 和创建和调用一个发电机的功能与返回的类型 iterable. 产生一些值在发电机的功能和返回一个 array. 随后，输出值得通过的发电机的功能。也输出的发生功能返回值使用 getReturn() 功能获得的回报价值:

<?phpfunction generator(): iterable {
	yield 'a';
	yield 'b';
	yield 'c';
	return ['a','b','c'];}$gen = generator();foreach ($gen as $value) {
	echo "$value\n";}var_dump($gen->getReturn());?>

运行的脚本输出值得通过的发电机的功能.

a b c array(3) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" }

类型的属性

7版本已经提出了若干改善PHP的类型系统。 PHP7.4增加了对类型的性质，使用它可以宣布类型的类属性。类性质的做也不需要明确宣布的吸气/器的方法。他们的某些突出特点是:

类型可能被宣布上 static 性以及.

引用输入特性的支持.

该类型的属性受到影响的 strict_types 指令只是作为参数类型和返回的类型.

类型可使用 var 符号.

默认值键属性可以宣布.

这种类型的多重性质，可宣布在一个单一的宣言.

隐 int 要 float 铸成.

的类型为一个可空的财产可能被宣布.

一类财产的类型 callable 或 void 不能宣布.

作为一个例子，请考虑以下类称为 Catalog 这说明了几个项所述的特征:

<?phpdeclare(strict_types=1);class Catalog {
    pubpc int $catalogid,$journapd;
    pubpc ?string $journal=null;
    pubpc static string $edition="January-February 2020";
    var bool $flag;
    pubpc float $f=1;pubpc function __construct(int $catalogid,int $journapd,string $journal,bool $flag)
    {
        $this->catalogid = $catalogid;
        $this->journapd = $journapd;
        $this->journal = $journal;
        $this->flag = $flag;
    }}$c = new Catalog(123,345,"PHP Magazine",true);echo "Catalogid: ".$c->catalogid."\n";echo "Journapd: ".$c->journapd."\n";echo "Journal: ".$c->journal."\n";echo "Flag: ".$c->flag."\n";echo "Edition: ".Catalog::$edition."\n";?>

运行现在脚本，其输出示于图 2.

图2。产出说明使用的类型化的性质

要证明使用的性质严格型模式，考虑以下脚本组 strict_types 1并声明的一类财产称为 $catalogid 的类型 int. 然后尝试分配 $catalogid 一个酒店 string 值:

<?phpdeclare(strict_types=1);class Catalog {
    pubpc int $catalogid;}$c = new Catalog();$c->catalogid = "123"; ?>

脚本时运行，下面 TypeError 是扔:

Uncaught TypeError: Typed property Catalog::$catalogid must be int, string used

如果定义，没有 TypeError 被抛出。重要的区别，这里要注意的是，所分配的价值必须满足 strict_types 模式在写位置的财产。在其他条款， strict_types 模式在酒店宣言》中的位置是不相关的。如果 strict_types 模式是设定为1至写的位置，所分配的价值必须被宣布的类型。要证明使用不同的模式，我们应当使用两个不同的文件 a.php 和 b.php 与 strict_types 模式设置1和0%。脚本也表现出以下特点的参考文献当使用输入特性:

未初始化可为空财产可能被访问的参考

未初始化的非空财产不能被访问的参考

一系列可以通过参考.

在 a.php, 设置 strict_types 模式1和声明的一类 A 含有类型类财产称为 $a 的类型 int. 确保 a.php 脚本也宣布一阵，一个可空财产和非空酒店:

<?phpdeclare(strict_types=1);class A {
    pubpc int $a;
    pubpc array $array = [3, 1, 2];
    pubpc ?int $x;
    pubpc int $y; }

在第二个文件, b.php, 包括 a.php 并设置 strict_types 模式 0. 实例类 A, 然后使用 var_dump 输出这个实例是 $a 财产的价值，其中显示在下列后的评论 //. 然后，访问 array 类型的财产，通过其参考和最后，排序和产出.

现在访问的 int 类型的变量 $a 通过其参考，并将其分配string"1"值。输出变量 $a 值使用 var_dump 并且你会看到没有 TypeError 被抛出。这是因为个值存在 $a 是铸型, int.

还注意你可以接的初始化nullable酒店 $x 通过其参考。在这种情况下，这将是透明的初始化 NULL. 相反，如果你尝试接的初始化的非空酒店 $y, 你会得到一个 TypeError.

<?php declare(strict_types=0);include 'a.php';$a = new A;$a->a = "1";var_dump($a->a); // int(1)sort($a->array);var_dump($a->array);// array(3) { [0]=> int(1) [1]=> //int(2) [2]=> int(3) }$x =& $a->x; // Initiapzed to null$y =& $a->y; //TypeError Uncaught Error: Cannot access //uninitiapzed non-nullable property A::$y by reference

接下来，我们将讨论另一个重要特征类型的属性，与类型不变.

这种类型的非私有财产不应改变中的一个源类。非私人财产的类型不能被添加或去除任.

这种类型的私人财产可以改变一个源类。私有财产的种类可以被添加或删除.

来证明的类型不变，宣布一类称为 A 包含一个私人可变 $a 的类型 int, 公共变量 $b 的类型 string, 一个可空的公共变量 $c 的类型 int, 和一个公共变量 $d 的类型 string. 也声明 void 类财产称为 $v 验证 void 类型不能被用于与特性.

<?php class A {
    private int $a;
    pubpc string $b;
    pubpc ?int $c;
    pubpc string $d;
    pubpc void $v;//Property A::$v cannot have type void}

现在宣布一类 B 延伸类一个和更改类型的同类性质。更改类型的私人财产 $a 从 int 要 string 并让它的公众，这是支持的。如果你试图改变这种类型的公共财产 $b 从 string 要 int; 类型的公共财产 $c nullable int 要 int; 或忽略种类型的公共财产 $d, 你会得到错误。错误信息输出显示以下的意见.

class B extends A {
    pubpc string $a;  pubpc  int $b;   // Type of B::$b must be string (as in class A)pubpc int $c;    // Type of B::$c must be ?int (as in class A)pubpc  $d;    // Type of B::$d must be string (as in class A)}

关键的外卖

标类型的声明

回归类型的声明

空类型

使用无效作为回报类型的功能

新类型可迭代

类型的属性

友情链接