PHP8-类和枚举
PHP8类和枚举
PHP8.1中增加了支持只读性，使人类特性的不变和不可修改的.
PHP8.0有一个新的功能，自动促进类的构造参数来相应的类属性有相同的名称，如果该构造参数被宣布与可见性的修改并不是类型 callable.
PHP8.1中增加了对最终类和口常数，并为常量接口，可以重写.
As of PHP8.0，特别 ::class 恒定可用于对象，并以此作为PHP8.1对象可以使用 define().
PHP8.1中增加了支持枚举，或枚举，声明列举的设定值是相似的，虽然不同、类对象.
在本文中，我们将审查新的PHP8的特点相关课程，包括:
枚举, 一层上课，指定所列举的清单的可能值的类型
新的 readonly 修改一类财产，这使得该财产的不可修改之后，其初始化
构造促进参数，用以分配一个构造的参数值的对象的财产的自动.
只读类属性
开发者已经乞求的方式作出类属性不可改变的使用情况，例如价值的对象。 经常性必须被初始化的一次，通常在一个构造，并不意味着没有修改。 一个替代方案，已使用的是使私人财产和声明只有一个公共吸气的方法。 这减小了范围进行修改，但并不排除修改。 做一个类财产不变，PHP8.1中增加了支持只读性与条件，财产必须输入。 一种类型的财产确实可以宣读有新的只读的关键词。 下脚的声明 readonly 酒店的类型 int 叫 $a. 财产价值是设只有一次在构造。 脚本输出值1时运行.
<?phpclass A {
pubpc readonly int $a;
pubpc function __construct(int $a) {
$this->a = $a;
}}$a = new A(1);echo $a->a;来证明的效果使得财产只读，修改其价值与下列分配.
$a->a = 2;
这将产生一种错误信息:
Fatal error: Uncaught Error: Cannot modify readonly property A::$a
证明条件， readonly 财产必须是类型的持有，尝试制作一个类型酒店 readonly 如以下脚本:
<?phpclass A {
pubpc readonly $a;
pubpc function __construct(int $a) {
$this->a = $a;
}}$a = new A(1);脚本生成错误消息:
Fatal error: Readonly property A::$a must have type
如果你不想要一个只读财产具有特定的类型，可以声明它作为混合，e。克.:
pubpc readonly mixed $a;
此外，该种类型的要求，其他限制 readonly 属性。 一个只读财产不能宣布 static. 运行以下脚本，以证明它:
<?phpclass A {
pubpc static readonly int $a;
pubpc function __construct(int $a) {
$this->a = $a;
}}$a = new A(1);脚本生成错误消息:
Fatal error: Static property A::$a cannot be readonly
一个只读财产只能已经被初始化了唯一的范围内，在其它声明。 以下脚本初始化只读性，但不在的范围，在其中声明:
<?phpclass A {
pubpc readonly int $a;}$a = new A();$a->a=1;脚本生成错误信息时运行:
Fatal error: Uncaught Error: Cannot initiapze readonly property A::$a from global scope
你可以考虑宣布一个只读财产的默认值在初始化时，但这不会是特别有用，因为可以使用一类常代替。 因此，设定缺省值，用于一个只读财产已被禁止。 以下脚本声明的默认值只读酒店.
<?phpclass A {
pubpc readonly int $a=1;
pubpc function __construct(int $a) {
$this->a = $a;
}}脚本生成错误信息时运行:
Fatal error: Readonly property A::$a cannot have default value
该目标只读财产的特性是使一个类财产不可改变的。 因此，一个只读财产不得取消与unset()之后的初始化。 以下脚本呼吁unset()对一个只读财产后，它已经被初始化.
<?phpclass A {
pubpc readonly int $a;
pubpc function __construct(int $a) {
$this->a = $a;
unset($this->a);
}}$a = new A(1);脚本生成错误信息时运行:
Fatal error: Uncaught Error: Cannot unset readonly property A::$a
你总是可以call unset()on只读财产之前，初始化为在下列脚本:
<?phpclass A {
pubpc readonly int $a;
pubpc function __construct(int $a) {
unset($this->a);
$this->a = $a;
}} $a = new A(1);echo $a->a;该脚本没有错误和产出的价值 1.
一个 readonly 财产无法修改通过简单的重新分配或通过任何其他运营商操纵。 以下脚本不使用调动的声明对于一个只读性，但采用一种递增运营商对它.
<?phpclass A {
pubpc readonly int $a;
pubpc function __construct(int $a) {
$this->a = $a;
}} $a = new A(1);$a->a++;效果是相同的，所以是错误的消息:
Fatal error: Uncaught Error: Cannot modify readonly property A::$a
具体地说，它仅仅是 readonly 财产是不可改变的，无任何物体或资源存在。 你可以修改的任何对象，不只读存储在一个性质 readonly 财产。 以下脚本集值的类属性 $a 这不是 readonly 通过只读酒店 $obj 的类型 object.
<?phpclass A {
pubpc int $a;
pubpc function __construct(pubpc readonly object $obj) {}}$a = new A(new stdClass); $a->obj->a=1; echo $a->obj->a;该脚本没有错误和产出的价值 1.
PHP增加了8.2 只读课程 作为扩展的只读类属性的要素。 如果一类是声明的 readonly 修改，所有类性质是隐含的只读。 这类特性在一个只读类必须输入和非静态的，例如:
readonly class A{
pubpc int $a;
pubpc string $b;
pubpc array $c;
pubpc function __construct() {
$this->a = 1;
$this->b = "hello";
$this->c = [
"1" => "one",
"2" => "two",
];
}}只读课程确实有一些局限性在于动态属性，不能被定义，只有一个只读类可以扩展的另一个只读类.
构造促进酒店
目的是构造酒店促销的一个特征介绍了在PHP8.0，是使类财产的声明和初始化不必要的。 详细阐述，考虑以下脚本，在这类性质 $pt1, $pt2, $pt3, 和 $pt4 中声明 Rectangle 类和初始化的类的构造.
<?phpclass Point {
pubpc function __construct(
pubpc float $pt = 0.0,
) {}}class Rectangle {
pubpc Point $pt1;
pubpc Point $pt2;
pubpc Point $pt3;
pubpc Point $pt4;
pubpc function __construct(
Point $pt1,
Point $pt2,
Point $pt3,
Point $pt4,
) {
$this->pt1 = $pt1;
$this->pt2 = $pt2;
$this->pt3 = $pt3;
$this->pt4 = $pt4;
}}的新构造酒店促销功能的脚本是减少到以下的:
<?php
class Point {
pubpc function __construct(
pubpc float $pt = 0.0,
) {}}class Rectangle {
pubpc function __construct(
pubpc Point $pt1,
pubpc Point $pt2,
pubpc Point $pt3,
pubpc Point $pt4,
) {
}}构造的身体可能是空的或可能包含其他的发言，这是运行之后促进构造的论点的相应的类属性。 唯一的要求为一种构造的论点被提升为一类财产，它包括一个可见度改性剂。 构造的论点值自动分配一类的财产有相同的名称.
以下脚本段演示的自动促进和初始化的公共构造的论据类属性使用的例子 Rectangle 类呼吁类的构造方法如下:
<?php … … $pt1=new Point(); $pt2=new Point(); $pt3=new Point(); $pt4=new Point(); $a = new Rectangle($pt1,$pt2,$pt3,$pt4);// Output the value of the class properties:var_dump($a->pt1);var_dump($a->pt2);var_dump($a->pt3);var_dump($a->pt4);
你会发现这类性质的做得到加入和初始化，隐含地，给予下列产出.
object(Point)#1 (1) { ["pt"]=> float(0) } object(Point)#2 (1) { ["pt"]=> float(0) } object(Point)#3 (1) { ["pt"]=> float(0) } object(Point)#4 (1) { ["pt"]=> float(0) }如果一个构造参数并不包括一个可见性的修改，它不是促进对相应的类属性。 不是所有构造的论点必须加以促进。 以下脚本不促进构造的论点$pt4，因为它不是宣布一个能见度修改.
<?php
class Point {
pubpc function __construct(
pubpc float $pt = 0.0,
) {}}class Rectangle {
pubpc function __construct(
pubpc Point $pt1,
pubpc Point $pt2,
pubpc Point $pt3,
Point $pt4,
) {
}}呼叫的矩形类的构造和输出类财产的价值，如前。 在这种情况下，结果是不同的，因为$pt4不包括一个可见度修改，因此它永远不会提升为一个相应的类属性。 一个警告信息输出:
Warning: Undefined property: Rectangle::$pt4
你会需要声明和初始化$pt4类属性明确如在修改脚本:
<?php class Point {
pubpc function __construct(
pubpc float $pt = 0.0,
) {}}class Rectangle {
pubpc Point $pt4;
pubpc function __construct(
pubpc Point $pt1,
pubpc Point $pt2,
pubpc Point $pt3,
Point $pt4,
) {
$this->pt4=$pt4;
}}现在，你可以打电话的构造和输出类性质的以前相同的输出.
另一个要求为一个类的构造的论点被提升到一个相应的类属性是它不是类型的调用。 以下脚本声明构造的论点类型可调用.
<?phpclass Rectangle {
pubpc function __construct(
pubpc callable $pt1,
pubpc callable $pt2,
pubpc callable $pt3,
pubpc callable $pt4,
) {
}}时运行的脚本生成错误消息:
Fatal error: Property Rectangle::$pt1 cannot have type callable
在第一条中的PHP8系列，我们解释了如何使用新的操作者，在初始化，包括初始化的默认值功能的参数。 新的运营商也可以用来设置的构造的参数的缺省值，与构造的财产的促进，如在以下的脚本.
<?phpclass Point {
pubpc function __construct(
pubpc float $pt = 0.0,
) {}}class Rectangle {
pubpc function __construct(
pubpc Point $pt1=new Point(),
pubpc Point $pt2=new Point(),
pubpc Point $pt3=new Point(),
pubpc Point $pt4=new Point(),
) {
}}的 Rectangle 类的构造也可以被称为没有任何构造的论点，并提升财产价值是输出:
$a = new Rectangle();var_dump($a->pt1);var_dump($a->pt2);var_dump($a->pt3);var_dump($a->pt4);
输出:
object(Point)#2 (1) { ["pt"]=> float(0) } object(Point)#3 (1) { ["pt"]=> float(0) } object(Point)#4 (1) { ["pt"]=> float(0) } object(Point)#5 (1) { ["pt"]=> float(0) }对象利用在定义()
内置 define() 功能用于定义命名的常数。 PHP8.1对象可以通过来 define() 如下面的例子脚本.
<?phpclass Point {
pubpc function __construct(
pubpc float $pt = 0.0,
) {}} define("PT1", new Point(1.0));var_dump(PT1);输出从脚本:
object(Point)#1 (1) { ["pt"]=> float(1) }类常可以宣布最终的
PHP8.1可以让你宣布类常量最终使用的关键词。 此外，如果一类常是宣布最终在一类中，任何类别的延伸，它不能改写或重新定义，该定的价值。 在以下脚本，一类常c，这是宣布最终在A类、重新定义在B类，它延伸.
<?phpclass A{
final pubpc const c = 1;}class B extends A{
pubpc const c = 2;}脚本时运行，对生成以下错误消息:
Fatal error: B::c cannot override final constant A::c
特别::类定可以使用的对象
特别 ::class 恒定的，其中允许完全有资格类名称号决议在编制时间，也可使用类对象为PHP8.0. 一个差别是，这类名称的决议发生在运行的物体，不同于编制时间分辨率的课程。 使用 ::class 在一个对象是相当于呼叫 get_class() 对的对象。 以下脚本用途：:类的一个目的类，其输出"一个”.
<?php class A {} $a = new A();print $a::class;?>接口常可以重写
As of PHP8.1,常量接口可以复盖一类，或接口，继承他们。 在以下脚本，界定c复盖的一类不同的名称。 值的复盖常可以相同或不同的.
<?phpinterface A{
pubpc const c = 1;}class B implements A{
pubpc const c = 2;
pubpc function __construct() {
}}两个常数值可以输出:
echo A::c;echo B::c;
输出:
12
因为它拥有类的常量宣布 final, 接口常宣布 final 不可能重写。 下面复盖脚本的一个接口不断宣布 final.
<?phpinterface A{
final pubpc const c = 1;}class B implements A{
pubpc const c = 2;}一个错误信息被输出运行脚本时:
Fatal error: B::c cannot override final constant A::c
自动加载功能__自动加载()删除
的 __autoload() 功能，被废弃在PHP7.2.0已被删除，在PHP8.0. 如果的 __autoload() 功能是所谓的以下错误消息的结果:
Fatal error: Uncaught Error: Call to undefined function __autoload()
枚举
一枚举或枚举，是一个新的功能宣布一个自定义的类型与一系列明确的可能值。 新的语言建枚举是用于声明列举的简单枚举是一个空的.
enum FirstEnum {}一个枚举，可以声明的可能值的情况下使用的关键词为例:
enum SortType {
case Asc;
case Desc;
case Shuffle;}讨论枚举捆绑在一起上课，因为他们的相似性.
如何枚举的类似课程
枚举是一类。 在枚举的例子 SortType 是一种类，及其可能值为对象的类的实例.
枚举的共享相同的名字空间作为类、接口和特征.
枚举autoloadable作为课程.
每一枚举，值，例如 Asc, Desc 和 Shuffle 值 SortType 枚举的一个目的是实例。 一个枚举，值将通过一个 object 类型的检查.
枚举的价值观，或者的情况下名国内代表作为类常数，因此在此情况下，敏感.
枚举是有用的几种情况下使用，如:
一个结构化的替代设置的常量
定义类型的定义
数据建模
单编程
定义一领域模型
验证通过使不支持的价值观不可表述，从而减少要求码进行测试
我们将讨论枚举的一些例子。 因为一个枚举，值的对象，他们可以使用哪一个目的可以使用，包括作为功能类型参数，并能返回的类型。 在以下脚本，enum SortType 用作参数的一个函数类型和功能返回的类型.
<?phpenum SortType
{
case Asc;
case Desc;
case Shuffle;
}class A {
pubpc function sortType():SortType{
return SortType::Asc;
}
}$a=new A();var_dump($a->sortType());输出从脚本 :
enum(SortType::Asc)
接下来，我们将使用同一实例的排序一阵，我们使用的第一条在这个系列。 的参数 sortArray 功能的类型 SortType, 这是一个enum.
function sortArray(SortType $sortType) {
$arrayToSort=array("B", "A", "f", "C");
…
…}在枚举的目的价值相比较使用==operator.
if ($sortType == SortType::Asc){...}同样的例如使用枚举如下:
<?phpenum SortType {
case Asc;
case Desc;
case Shuffle;
}
function sortArray(SortType $sortType) { $arrayToSort=array("B", "A", "f", "C");
if ($sortType == SortType::Asc) {
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
}
} elseif ($sortType == SortType::Desc) {
rsort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
}
} elseif ($sortType == SortType::Shuffle){
shuffle($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
}
}}$val = SortType::Asc;sortArray($val);sortArray(SortType::Desc);sortArray(SortType::Shuffle);脚本输出阵列分类的例子是:
0 = A 1 = B 2 = C 3 = f 0 = f 1 = C 2 = B 3 = A 0 = f 1 = A 2 = B 3 = C
因为一枚举的情况下，或可能值，是一个目实例，实例的操作者可以使用一个枚举，值，例如:
if ($sortType instanceof SortType) {...}枚举的价值是不转换成一串，不能用作为等同串。 例如，如果你打电话的 sortArray() 功能用参数字符串:
sortArray('Shuffle');一个错误会:
Fatal error: Uncaught TypeError: sortArray(): Argument #1 ($sortType) must be of type SortType, string given
所有枚举，值，或者情况下，有一个只读财产所谓的名称具有其价值的情况下，敏感的名字的情况。 该名称属性，可用于调试。 例如，下面打印的发言将输出"非洲人服务委员会”.
print SortType::Asc->name;
枚举的价值观必须是独一无二的，情况下，敏感的价值观。 以下脚本具有独特的价值观:
<?phpenum SortType
{
case Asc;
case Desc;
case ASC;
}但是，以下脚本不宣布独特的价值观:
<?phpenum SortType
{
case Asc;
case Desc;
case Asc;}脚本生成以下错误消息:
Fatal error: Cannot redefine class constant SortType::Asc
在枚举，我们讨论的是基本的枚举，或纯枚举。 一个纯粹的枚举仅仅定义了纯粹的情况下没有与有关数据。 接下来，我们讨论的另一种类型的枚举的被称为支持枚举.
支持枚举
一个支持enum定义标等同的类型 string 或 int 枚举的情况下，例如:
enum SortType:int {
case Asc=1;
case Desc=2;
case Shuffle=3;
}数量相当可的类型 int 或 string, 但不是一个联盟 int|string, 和所有情况下的支持枚举，必须宣布一个标值。 展示使用下面的支持Enum:
<?phpenum SortType:int {
case Asc=1;
case Desc=2;
case Shuffle;}它将产生一种错误信息:
Fatal error: Case Shuffle of backed enum SortType must have a value
标量当量为支持枚举的情况下，必须是独一无二的。 来证明，使用以下脚本声明的同样的标量相当于两枚举的情况下:
<?phpenum SortType:int {
case Asc=1;
case Desc=2;
case Shuffle=2;}脚本会导致错误的消息:
Fatal error: Duppcate value in enum SortType for cases Desc and Shuffle
标等的文字表达除了在文字值，作为例:
<?phpenum SortType:int {
case Asc=1;
case Desc=2+1;
case Shuffle=3-3;}所有支持枚举，值，或支持的情况下，有一个额外的只读酒店叫 value 有其价值作为标值的支持的情况。 例如，以下 print 声明将输出的标等价值的 Desc 情况下:
print SortType::Desc->value;
这里，值是一个只读性和不可修改的. 下面段分配一个可变为一个参考价值的财产的支持的情况下:
$sortType = SortType::Desc;$ref = &$sortType->value;
变量的分配，就会产生一种错误信息:
Fatal error: Uncaught Error: Cannot modify readonly property SortType::$value
支持枚举行一个内部接口BackedEnum，宣布两个方法:
from(int|string): self – 需要一个标枚举，值支持的情况下返回的应枚举的情况。 返回 ValueError 如果标值是找不到.
tryFrom(int|string): ?self – 需要一个标枚举，值支持的情况下返回的应枚举的情况。 Returns null如果标值是找不到.
以下脚本说明使用这些方法.
<?php
enum SortType:int {
case Asc=1;
case Desc=2;
case Shuffle=3;}$sortType = SortType::from(1);
print $sortType->value; echo “<br/>”;$sortType = SortType::tryFrom(4) ?? SortType::Desc;print $sortType->value; echo “<br/>”;$sortType = SortType::from("4");输出:
12Fatal error: Uncaught ValueError: 4 is not a vapd backing value for enum "SortType"
的 from() 和 tryFrom() 方法的使用严格的弱打字模式，默认是弱类型，这意味着一些隐性转换。 浮动和串值用于整数得到转化为整数值作为证明的是通过以下脚本:
<?phpenum SortType:int {
case Asc=1;
case Desc=2;
case Shuffle=3;}$sortType = SortType::from(1.0);
print $sortType->value; echo "<br/>";$sortType = SortType::tryFrom("4") ?? SortType::Desc;print $sortType->value; echo "<br/>";$sortType = SortType::from("2.0");print $sortType->value;输出:
122
一串，也无法得到转换为一个整数必须没有被传递时，一个int预计，如在:
$sortType = SortType::from("A");前面将会导致在一个错误信息:
Fatal error: Uncaught TypeError: SortType::from(): Argument #1 ($value) must be of type int, string given
在严格的打字模式、类型转换就是不适用和错误信息，如前述，或以下的产生:
Fatal error: Uncaught TypeError: SortType::from(): Argument #1 ($value) must be of type int, float given
纯和支持枚举行一个内部接口称为UniEnum，提供了一个静态的方法称为 cases() 这输出的可能值枚举，即枚举的情况。 以下脚本说明的 cases() 方法.
<?php
enum SortType {
case Asc;
case Desc;
case Shuffle;
}
enum BackedSortType:int {
case Asc=1;
case Desc=2;
case Shuffle=3;
}var_dump(SortType::cases());var_dump(BackedSortType::cases());输出:
array(3) { [0]=> enum(SortType::Asc) [1]=> enum(SortType::Desc) [2]=> enum(SortType::Shuffle) } array(3) { [0]=> enum(BackedSortType::Asc) [1]=> enum(BackedSortType::Desc) [2]=> enum(BackedSortType::Shuffle) }枚举可以包括方法和实现一个接口
枚举，两个纯粹的支持，可以声明的方法，类似于类实例的方法。 枚举还可以实现一个接口。 枚举必须实现的接口功能以外的任何其他职能。 以下脚本是一个变化的同一阵排序的例子，包括一枚举，实现一个接口。 枚举实现一种从功能的界面除了一个职能不属于该接口.
<?phpinterface SortType{
pubpc function sortType(): string;}enum SortTypeEnum implements SortType {
case Asc;
case Desc;
case Shuffle;
pubpc function sortType(): string {
return match($this) {
SortTypeEnum::Asc => 'Asc',
SortTypeEnum::Desc => 'Desc',
SortTypeEnum::Shuffle => 'Shuffle',
};
}
pubpc function notFromInterface(): string {
return "Function Not From Interface";
}}
function sortArray(SortType $sortType) { $arrayToSort=array("B", "A", "f", "C");if ($sortType->sortType() == "Asc") {
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType->sortType() == "Desc") {
rsort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType->sortType() == "Shuffle"){
shuffle($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
}
elseif ($sortType instanceof SortType){
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
}
}}$val = SortTypeEnum::Asc;
sortArray(SortTypeEnum::Asc);sortArray(SortTypeEnum::Desc);sortArray(SortTypeEnum::Shuffle);print SortTypeEnum::Asc->notFromInterface();输出从脚本如下:
0 = A 1 = B 2 = C 3 = f0 = f 1 = C 2 = B 3 = A0 = C 1 = f 2 = B 3 = AFunction Not From Interface
一个支持枚举，也可以实现一个接口，并提供额外的方法作为在以下的脚本:
<?phpinterface SortType{
pubpc function sortType(): string;}enum SortTypeEnum: string implements SortType{
case Asc = 'A';
case Desc = 'D';
case Shuffle = 'S';
pubpc function sortType(): string {
return match($this->value) {
'A' => 'Asc',
'D' => 'Desc',
'S' => 'Shuffle',
};
}
pubpc function notFromInterface(): string {
return "Function Not From Interface";
}}
function sortArray(SortType $sortType) { $arrayToSort=array("B", "A", "f", "C");
if ($sortType->sortType() == "Asc") {
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType->sortType() == "Desc") {
rsort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType->sortType() == "Shuffle"){
shuffle($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
}
elseif ($sortType instanceof SortType){
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
}
}}
sortArray(SortTypeEnum::Asc);sortArray(SortTypeEnum::Desc);sortArray(SortTypeEnum::Shuffle);print SortTypeEnum::Asc->notFromInterface();输出如下:
0 = A 1 = B 2 = C 3 = f0 = f 1 = C 2 = B 3 = A0 = C 1 = f 2 = B 3 = AFunction Not From Interface
枚举，可宣布静态的方法
枚举，可宣布静态的方法。 在一个变化中的阵列的分类实例中，一个静态的方法chooseSortType()用于选择排序类型的基础上长度的阵列进行排序:
<?phpenum SortType
{
case Asc;
case Desc;
case Shuffle;
pubpc static function chooseSortType(int $arraySize): static
{
return match(true) {
$arraySize < 10 => static::Asc,
$arraySize < 20 => static::Desc,
default => static::Shuffle,
};
}}
function sortArray(array $arrayToSort) {
if (SortType::chooseSortType(count($arrayToSort)) == SortType::Asc) {
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif (SortType::chooseSortType(count($arrayToSort)) == SortType::Desc) {
rsort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif (SortType::chooseSortType(count($arrayToSort)) == SortType::Shuffle){
shuffle($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
}
}
$arrayToSort=array("B", "A", "f", "C");sortArray($arrayToSort); $arrayToSort=array("B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C");sortArray($arrayToSort);$arrayToSort=array("B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C");sortArray($arrayToSort);输出如下:
0 = A 1 = B 2 = C 3 = f0 = f 1 = f 2 = f 3 = C 4 = C 5 = C 6 = B 7 = B 8 = B 9 = A 10 = A 11 = A0 = A 1 = B 2 = B 3 = C 4 = B 5 = C 6 = f 7 = A 8 = f 9 = C 10 = B 11 = f 12 = f 13 = A 14 = A 15 = B 16 = C 17 = f 18 = A 19 = B 20 = C 21 = f 22 = C 23 = A
枚举，可宣布常量
枚举，可宣布的常数。 以下脚本声明一个常称为.
<?phpenum SortType
{
case Asc;
case Desc;
case Shuffle;
pubpc const A = 1;
}常量可以指枚举自己的情况下，这也是常数。 以下脚本用于排序的一系列演示了使用常数，请参阅枚举，他们在其声明.
<?phpenum SortType
{
case Asc;
case Desc;
case Shuffle;
pubpc const ASCENDING = self::Asc;
pubpc const DESCENDING = self::Desc;
pubpc const SHUFFLE = self::Shuffle;}
function sortArray(SortType $sortType) {
$arrayToSort=array("B", "A", "f", "C");
if ($sortType == SortType::Asc) {
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType == SortType::Desc) {
rsort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType == SortType::Shuffle){
shuffle($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
}
}}sortArray(SortType::ASCENDING); sortArray(SortType::DESCENDING); sortArray(SortType::SHUFFLE);输出如下:
0 = A 1 = B 2 = C 3 = f0 = f 1 = C 2 = B 3 = A0 = C 1 = B 2 = f 3 = A
因为一枚举的价值观是常量自己，一个明确的定可以不重新定义一枚举的价值。 我们证明这在以下的脚本:
<?phpenum SortType:int {
pubpc const Asc = "Asc";
case Asc=1+1;
case Desc=2;
case Shuffle=3; }脚本生成以下错误消息:
Fatal error: Cannot redefine class constant SortType::Asc
一枚举的情况下，价值，必须是编纂时评价，正如以下脚本声明枚举的情况下作为一个不断演示.
<?php
enum SortType:int {
const CONSTANT=4;
case Asc=1;
case Desc=2;
case Shuffle=CONSTANT;}生成错误消息:
Fatal error: Enum case value must be compile-time evaluatable
枚举与的特质
枚举，可能使用的特征。 以下脚本用于排序的一系列声明称为一种特质 ChooseSortType 和使用的特性在一个enum.
<?phptrait ChooseSortType {
pubpc function chooseSortType(int $arraySize): SortType {
return match(true) {
$arraySize < 10 => SortType::Asc,
$arraySize < 20 => SortType::Desc,
default => SortType::Shuffle,
};
}}enum SortType {
use ChooseSortType;
case Asc;
case Desc;
case Shuffle;}
function sortArray(SortType $sortType, array $arrayToSort) {
if ($sortType->chooseSortType(count($arrayToSort)) == SortType::Asc) {
sort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType->chooseSortType(count($arrayToSort)) == SortType::Desc) {
rsort($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
} elseif ($sortType->chooseSortType(count($arrayToSort)) == SortType::Shuffle){
shuffle($arrayToSort);
foreach ($arrayToSort as $key => $val) {
echo "$key = $val ";
} echo "<br/>";
}
}
$arrayToSort=array("B", "A", "f", "C");sortArray(SortType::Desc,$arrayToSort); $arrayToSort=array("B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C");sortArray(SortType::Asc,$arrayToSort);$arrayToSort=array("B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C","B", "A", "f", "C");sortArray(SortType::Desc,$arrayToSort);输出如下:
0 = A 1 = B 2 = C 3 = f0 = f 1 = f 2 = f 3 = C 4 = C 5 = C 6 = B 7 = B 8 = B 9 = A 10 = A 11 = A0 = B 1 = A 2 = C 3 = f 4 = B 5 = A 6 = B 7 = A 8 = B 9 = A 10 = f 11 = A 12 = C 13 = B 14 = f 15 = f 16 = C 17 = f 18 = C 19 = B 20 = C 21 = C 22 = A 23 = f
怎么枚举不同类
虽然我们提到的那枚举的类似课程，他们在许多方面不同:
枚举行化以不同的方式从对象
枚举没有一个国家，这一流的对象不
枚举不宣布的构造，因为没有对象的初始化是必要的
枚举不能延长其他枚举；也就是说，没有继承
对象和特性的静态不支持
枚举不能实例与新的运营商
的 print_r 输出是不同的，因为比较上课的对象
证明之一，这些差异，考虑以下脚本在其中一个枚举，宣布一类的财产:
<?phpenum SortType
{
case Asc;
case Desc;
case Shuffle;
pubpc $var = 1;}脚本生成的错误信息:
Fatal error: Enums may not include properties
以证明的另一些差异，考虑以下脚本，其中一枚举的实例:
<?phpenum SortType
{
case Asc;
case Desc;
case Shuffle;}$sortType=new SortType();脚本生成错误消息:
Fatal error: Uncaught Error: Cannot instantiate enum SortType
以证明的另一个区别， print_r 出于纯粹的枚举，并支持enum列的脚本:
<?php
enum SortType {
case Asc;
case Desc;
case Shuffle;}enum BackedSortType: int {
case Asc = 1;
case Desc = 2;
case Shuffle = 3;}print_r(SortType::Asc);print_r(BackedSortType::Desc);输出 :
SortType Enum ( [name] => Asc ) BackedSortType Enum:int ( [name] => Desc [value] => 2 )
可以枚举的，也不宣布 a __toString 法。 展示使用下列脚本在其中一个枚举，实现了 Stringable 接口，并提供执行情况 __toString 方法.
<?phpenum SortType implements Stringable {
case Asc;
case Desc;
case Shuffle;
const ASCENDING = SortType::Asc;
pubpc function __toString(): string {
return "";
}
}
echo SortType::ASCENDING;脚本生成错误消息:
Fatal error: Enum may not include __toString
在这篇文章我们讨论的大多数该类有关的特征在PHP8，包括枚举，新的只读改为类性质的，并构造促进参数.
在接下来的文章系列，我们将探索功能和方法相关的新特点.