类型
标量类型
boolean(布尔型)
TEUE | FALSE 不区分大小写
$foo = True; // 设置 $foo 为 TRUE
?>
if("0"){
echo 'true';
}else{
echo 'false'; // 输出 false
}
if("0.0"){
echo 'true'; // 输出 true
}else{
echo 'false';
}
要将一个值转换成 boolean，用 (bool) 或者 (boolean) 来强制转换。
但是很多情况下不需要用强制转换，因为当运算符，函数或者流程控制结构需要一个 boolean 参数时，PHP 具有类型自动转换。
当转换为 boolean 时，以下值被认为是 FALSE：
布尔值 FALSE 本身
整型值 0(零)
浮点型值 0.0(零)
空字符串，以及字符串 "0"
不包括任何元素的数组
特殊类型 NULL(包括尚未赋值的变量)
从空标记生成的 SimpleXML 对象
所有其它值都被认为是 TRUE(包括任何资源 和 NAN)。
Warning
-1 和其它非零值(不论正负)一样，被认为是 TRUE！
integer(整型)
PHP 支持 十进制、二进制、八进制、十六进制；
$a = 1234; // 十进制数
$a = -123; // 负数
$a = 0123; // 八进制数 (等于十进制 83)
$a = 0x1A; // 十六进制数 (等于十进制 26)
$a = 0b11111111; // 二进制数字 (等于十进制 255)
整型数的长度和平台有关;
Windows 下 ,PHP 7 以前的版本，都是 32 位版本的PHP。
PHP 不支持无符号的 integer。
Integer 值的占用字节长度可以用常量 PHP_INT_SIZE 来查看;
最大值可以用常量 PHP_INT_MAX 来表示，最小值用常量 PHP_INT_MIN 表示。
32位的范围： -2147483648 ~ 2147483647
64位的范围： -9223372036854775808 ~ 9223372036854775807
超过 Integer 范围的 数，溢出了范围，会被自动转换为 浮点数;待会讲浮点数的时候会具体说明原因
(同样，计算的结果如果溢出了范围，也会被自动转换为浮点数)
在PHP中，进行除法运算会返回浮点数或者整数，如果可以整除则返回整数，如果不能整除则返回小数；
如果想要像其他语言一样，在计算除法的时候，舍弃掉小数部分，可以进行强制转换(int) 强制转换为整数，强制转换为整数的时候会向下取整(砍掉小数)
GMP扩展
如果 内建 Integer 的范围不够使用(特别是32位情况下)，可以使用任意长度整数gmp库，需要在php的配置文件中开启；
(GMP库是任意长度整数库，不支持浮点数运算)
echo gmp_strval(gmp_add("99999999999999999999999999999999999999999999999","1"));
float(浮点型，也称作 double)
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
和其他语言一样，PHP支持科学记数法，PHP中所有的浮点数对应其他语言的 double ，占用 8字节(64位)。
符号位
阶码
尾数
长度
精度
float
1
8
23
32
有效数字支持6~7位
double
1
11
52
64
有效数字支持14~15位
Tip: 一个浮点数的有效数字是指从左边第一位不是0的数开始计数;
如： 0.00123，有效数字是 123，则有三位有效数字;
PHP 中 浮点数 可以精确表达 有效数字 为 14~ 15的小数，超过14~15位，则无法精确表达，使用科学计数法，粗略表述；
由于浮点数是非精确描述数字，所以范围非常的庞大，整数溢出了范围，则会被自动转换为 浮点数，浮点数粗略表示，所以如果庞大的数字，还是要使用 GMP 库，任意长度整数
浮点数在日常使用过程中，经常会出现一些怪异的情况，这种情况在其他语言都有可能出现，如
0.7+0.1 的结果不是 0.8,而是 0.799999999；
(0.7+0.1) * 10 的结果不是 8,而是 7;
为什么会产生这样的问题？ 如何解决？ 如果想要了解详细的原理，可以看我另外的文章(浮点数)
这里我们直接说结论，永远不要相信浮点数的计算结果； 可以使用下面两种方式：
统一使用整数存储；如： 可以讲余额存成整数，单位为“分”，11.31元存成 1131分;
使用 BCMath 库 (任意精度数学库) 值得信赖的精度计算~
BCMath 使用案例
echo bcadd("0.1232132132132132132121" , "0.12321321321321321323213213213",20);
// 输出 0.24642642642642642644
// 参数： 字符串A，字符串B，保留小数位数
// 返回： 字符串计算结果
判断浮点数相等
一般不要简单判断浮点数是否相等，因为这是一个坑！浮点数本身是不精确的，0.7 实际是 0.70000000000001; 可以使用下面这种方法判断相等；
// $a 和 $b 在小数点后五位精度内都是相等的。 则判定相等
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;
if(abs($a-$b) < $epsilon) {
echo "true";
}
对于这种下面这种超大极限数情况，上面的比较算法就会出现错误，知道这是为什么吗？ ~
$a = 12345678998989899899.129;
$b = 12345678998989899888.123;
$epsilon = 0.00001;
echo $a ;
echo '
';
echo $b ;
if(abs($a-$b) < $epsilon) {
echo "true"; // 还是会输出 true ,其实上面两个数已经是天壤之别
}
小数的比较还是推荐使用： bccomp() 函数来解决
总结：
小数的计算结果永远不要信任(除非使用高精度函数库)
有效位数超过13位的，就不精确了，如果想要精确要使用 高精度函数库
推荐使用高精度函数库来处理小数的计算， 高精度小数的表示与输出;
内建数学函数库 Math
PHP 也提供了 数学函数库 Math ，这些函数是内建的；可以直接使用；
string(字符串)
PHP中有4中方式(2组) 表示字符串;
单引号
nowdoc
双引号
hredoc
单引号和 nowdoc 为一组，他们不支持 变量解析 也不支持 转义字符，类似于 raw 字符串;
单引号和 nowdoc 也是有区别的; 单引号常备用作表示一行字符串, nowdoc 被用作表示一段字符串；
单引号表示字符串的时候，可以有部分转义支持(输出单引号和反斜杠)；而 nowdoc则没有任何转义支持;
单引号和nowdoc 可以被用作初始化类属性
单引号字符串
// 单引号
echo 'this is a simple string';
// 可以录入多行
echo 'You can also have embedded newlines in
strings this way as it is
okay to do';
// 输出： Arnold once said: "I'll be back" ; 支持 \' 转义输出 单引号
echo 'Arnold once said: "I\'ll be back"';
// 输出： You deleted C:\*.*? ;
// 支持 \\ 转义输出 1个反斜杠
echo 'You deleted C:\\*.*?';
// 输出： You deleted C:\*.*?
echo 'You deleted C:\*.*?';
// 输出： This will not expand: \n a newline
echo 'This will not expand: \n a newline';
// 输出： Variables do not $expand $either
echo 'Variables do not $expand $either';
nowdoc
以下内容会被原封不动的输出~ 不会有任何的转义
语法上要注意， EOT 要带 单引号，(不带带引号就变成了 heredoc); EOT 是可以自定义的，就是个标记而已； EOT的开头和结尾要一致; EOT 的结尾必须顶行写;
echo <<
My name is "$name". I am printing some $foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should not print a capital 'A': \x41
''
\\
\'
EOT;
双引号和 heredoc 为一组； 他们支持变量解析和转义字符(\n，\r，\0，\u，\t ..等);
(存在变量解析的 双引号字符串 或 heredoc ，不可以被用作类属性初始化; 没有变量解析的可被用做类属性初始化)
heredoc
$str = <<
Example of string
spanning multiple lines
using heredoc syntax.
EOD;
/* 含有变量的更复杂示例 */
class foo
{
var $foo;
var $bar;
function foo()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new foo();
$name = 'MyName';
// heredoc 中含表达式
echo <<
My name is "$name". I am printing some $foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should print a capital 'A': \x41
EOT;
// 在参数中使用 heredoc
var_dump(array(<<
foobar!
EOD
));
双引号和变量解析
简单示例:
$juices = array("apple", "orange", "koolaid1" => "purple");
echo "He drank some $juices[0] juice.".PHP_EOL;
echo "He drank some $juices[1] juice.".PHP_EOL;
// 不工作,因为 和 s 粘在一起了，无法解析
echo "He drank some juice made of $juice[0]s.".PHP_EOL;
// 正常工作，不需要''来表示字符串key
echo "He drank some $juices[koolaid1] juice.".PHP_EOL;
class people {
public $john = "John Smith";
public $jane = "Jane Smith";
public $robert = "Robert Paulsen";
public $smith = "Smith";
}
$people = new people();
echo "$people->john drank some $juices[0] juice.".PHP_EOL;
echo "$people->john then said hello to $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
// 不会工作，找不到 smiths 的属性
echo "$people->robert greeted the two $people->smiths.";
复杂示例
$great = 'fantastic';
// 无效，输出: This is { fantastic}
echo "This is { $great}";
// 有效，输出： This is fantastic
echo "This is {$great}";
echo "This is ${great}";
// 有效
echo "This square is {$square->width}00 centimeters broad.";
// 有效，只有通过花括号语法才能正确解析带引号的键名
echo "This works: {$arr['key']}";
// 有效
echo "This works: {$arr[4][3]}";
// 这是错误的表达式，因为就象 $foo[bar] 的格式在字符串以外也是错的一样。
// 换句话说，只有在 PHP 能找到常量 foo 的前提下才会正常工作；这里会产生一个
// E_NOTICE (undefined constant) 级别的错误。
echo "This is wrong: {$arr[foo][3]}";
// 有效，当在字符串中使用多重数组时，一定要用括号将它括起来
echo "This works: {$arr['foo'][3]}";
// 有效
echo "This works: " . $arr['foo'][3];
echo "This works too: {$obj->values[3]->name}";
echo "This is the value of the var named $name: {${$name}}";
echo "This is the value of the var named by the return value of getName(): {${getName()}}";
echo "This is the value of the var named by the return value of \$object->getName(): {${$object->getName()}}";
// 无效，输出： This is the return value of getName(): {getName()}
echo "This is the return value of getName(): {getName()}";
也可以在字符串中用此语法通过变量来调用类的属性。
class foo {
var $bar = 'I am bar.';
}
$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar}\n";
echo "{$foo->{$baz[1]}}\n";
只有和字符串在同一个命名空间下的 变量，才会被解析；
PHP 字符串的本质
PHP中的字符串是字节数组，字节从哪里来？
PHP解析器会根据 PHP脚本文件的编码，对代码进行解码和解析；
如 $str = "a你好b"; ，即假设文件编码为 UTF-8，则 str 在内存中的编码则是 UTF-8，UTF-8是可变长度编码，所以 a 占 1个字节,“你好”占6个字节(1个汉子3字节)，b占1个字节，总共8个字节；
这和其他语言有很大的不同, 在Java中，Java虚拟机的字符串是由字符组成，而不是字节；字符编码是UTF-16 ；
Class文件在用 java 命令运行的时候，可以指定编码，告诉Java虚拟机，以什么编码解析 Class 中的字符串；如： UTF-8 解析，则用UTF-8编码解析，解码成 unicode 序列，再将unicode序列，编码成UTF-16 序列，形成字符串；
所以，在PHP中， a你好b 的长度是8；在Java中它的长度是4;
然而，PHP 的绝大部分内部字符串处理函数其实都是针对单字节的，比如常见的 strlen()，substr()，strpos()，strcmp()......如果应用这些函数对多字节字符处理，可能会得到预想不到的结果; 如下代码：
$str = "a你好b";
echo $str[0]; // 输出 a
echo $str[1] ; // 输出乱码~ 因为 下标为1的字节，不是一个字符编码，而是 你 字的UTF-8码 的 1/3；
mbstring 扩展
前文说到，自带的字符串处理函数都是以字节为单位来处理的，在英文国家可能非常好用，但是在中国，一个汉子3个字节的时候，就不好用了；
可以使用 mbstring 扩展，来进行日常的字符串操作:
$str = "a你好b";
echo mb_substr($str,1,1); // 输出 你
mbstring 如果没有开启需要在 配置文件中开启; 常见的配置项如下，主要就是配置默认的字符编码；
[mbstring]
mbstring.language = Chinese
mbstring.internal_encoding = UTF-8
mbstring.encoding_translation = On
mbstring.http_input = UTF-8
mbstring.http_output = UTF-8
mbstring.detect_order = UTF-8
mbstring.substitute_character = none
每一个 mbxxx函数的最后一个都是 encoding ，可以指定 解析 字符串(字节数组) 所使用得编码，如果不填则使用配置编码；
编码可以在上述的配置文件中配置，如果没有配置，则默认是使用PHP配置中的
; PHP's default character set is set to UTF-8.
; http://php.net/default-charset
default_charset = "UTF-8"
输出的区别 print、printf、var_dump等
echo 和 print： 都是输出，但是 echo 比 print 快建议用 echo；
print_r函数打印关于变量的易于理解的信息
如果变量是string , integer or float , 将会直接输出其值，如果变量是一个数组，则会输出一个格式化后的数组，便于阅读；
也就是有key和value对应的那种格式。对于object对象类同。
print_r(array('a','b',array('aa','bb','cc'))) ;
输出： Array ( [0] => a [1] => b [2] => Array ( [0] => aa [1] => bb [2] => cc ) );
printf函数 和 stringf
%% – 返回百分比符号
%b – 二进制数
%c – 依照 ASCII 值的字符
%d – 带符号十进制数
%e – 可续计数法(比如 1.5e+3)
%u – 无符号十进制数
%f – 浮点数(local settings aware)
%F – 浮点数(not local settings aware)
%o – 八进制数
%s – 字符串
%x – 十六进制数(小写字母)
%X – 十六进制数(大写字母)
C语言形式的格式化输出
var_dump 和 var_export
echo var_export(array('a','b',array('aa','bb','cc'))) ;
echo '';
var_dump(array('a','b',array('aa','bb','cc'))) ;
输出
array ( 0 => 'a', 1 => 'b', 2 => array ( 0 => 'aa', 1 => 'bb', 2 => 'cc', ), )
array(3) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> array(3) { [0]=> string(2) "aa" [1]=> string(2) "bb" [2]=> string(2) "cc" } }
var_dump 是输出调试信息;
var_export 输出 代码形式的信息，这种代码可以直接拷贝使用，就是原生代码
复合类型
array(数组)
注意！！！！ PHP中的数组是值拷贝，默认情况下是数组整体拷贝,和其他语言有很大不同
PHP 中的数组是 k，v 类型； 如果没有指定 key 则从 0 开始排列;
$arr = array('a','b','c');
var_export($arr); // array ( 0 => 'a', 1 => 'b', 2 => 'c', )
也可以使用短语法来定义 array
// 自 PHP 5.4 起
$arr = [
'a',
'b',
'c'
];
var_export($arr); // array ( 0 => 'a', 1 => 'b', 2 => 'c', )
也可以直接使用数组，如果数组不存在则自动定义；
$arr['name'] = 'zhangsan';
var_dump($arr); // 自动创建一个 数组，并且 填入 name = zhangsan
$arr2['stu']['name'] = 'zhangsan';
$arr2['stu']['age'] = '17';
var_dump($arr2); // 自动创建一个二维数组; 并且填入相关信息
可以使用 [] 符号，给数组新增 k,v； 相当于 push；
$arr[] = 'zhangsan';
var_dump($arr); // 给数组新增一个k,v；
$arr2[]['name'] = 'zhangsan';
$arr2[]['age'] = '17';
var_dump($arr2); // 二维数组
key 可以是 integer 或 string ; 如果 key 已存在，则会覆盖；
此外 key 会有如下的强制转换：
包含有合法整型值的字符串会被转换为整型。例如键名 "8" 实际会被储存为 8。但是 "08" 则不会强制转换，因为其不是一个合法的十进制数值。
浮点数也会被转换为整型，意味着其小数部分会被舍去。例如键名 8.7 实际会被储存为 8。
布尔值也会被转换成整型。即键名 true 实际会被储存为 1 而键名 false 会被储存为 0。
Null 会被转换为空字符串，即键名 null 实际会被储存为 ""。
如果在数组定义中多个单元都使用了同一个键名，则只使用了最后一个，之前的都被覆盖了。
$array = array(
1 => "a",
"1" => "b", // 会被转换成 1=> 'b'
1.5 => "c", // 会被转换成 1=> 'c'
true => "d", // 会被转换成 1=> 'd'
);
var_dump($array); // 输出 1 => 'd';
PHP 数组的key，可以支持 自增 key 和 自定义 key 混合使用；
自增key 规则： 若数组中已存在 数字key ，在最大的 数字key 且要>=0 的基础上 +1 ，如果没有则从0开始；
$arr=[
-9=>'-9', // 数字key， 但它小于0
-2, // 0=>-2，按照规则找数组中最大的 数字key (>=0) ，并没有，所以从0 开始；
'zhangsan', // 没有key，所以在最大key的基础上+1，则是 ： 1 => zhangsan
3=> '0',
2=>'-1',
'ermazi' // 4=>ermazi
];
var_export($arr);
// 输出 array ( -9 => '-9', 0 => -2, 1 => 'zhangsan', 3 => '0', 2 => '-1', 4 => 'ermazi', )
$arr[] = 'lisi'; // 相当于 push , 5=>lish
var_export($arr);
数组实用函数
count() 可以来获得数组的数量;
list($a,$b,$c) 可以将数组拆分成变量;
$info = array('coffee', 'brown', 'caffeine');
// 列出所有变量
list($drink, $color, $power) = $info;
echo "$drink is $color and $power makes it special.\n";
// 列出他们的其中一个
list($drink, , $power) = $info;
echo "$drink has $power.\n";
// 或者让我们跳到仅第三个
list( , , $power) = $info;
echo "I need $power!\n";
// list() 不能对字符串起作用
list($bar) = "abcde";
var_dump($bar); // NULL
判断key是否存在
echo array_key_exists(3,$arr);
echo isset($arr[3]); // 使用这种速度更快
其他的请见： 数组函数
数组与 循环
// 方式1，KV
foreach ($arr as $item => $value){
echo $item . ' - ' .$value;
echo '
';
}
echo '
';
// 方式2,只有V
foreach ($arr as $value){
echo $value;
echo '
';
}
// 循环中改变数组值 (常规方式)
foreach ($arr as $item => $value){
echo $arr[$item] = 'newvalue';
echo '
';
}
// 循环中改变数组值 (引用方式)
foreach ($arr as &$value){ // & 相当于循环把每一个数组元素的 引用给 $value ;
echo $value = 'newvalue2'; // 通过引用改变值
echo '
';
}
var_export($arr);
删除数组元素
unset($arr[0]); // 清理数组某个元素
unset($arr); // 清理整个数组
多维数组
$fruits = array ( "fruits" => array ( "a" => "orange",
"b" => "banana",
"c" => "apple"
),
"numbers" => array ( 1,
2,
3,
4,
5,
6
),
"holes" => array ( "first",
5 => "second",
"third"
)
);
// Some examples to address values in the array above
echo $fruits["holes"][5]; // prints "second"
echo $fruits["fruits"]["a"]; // prints "orange"
unset($fruits["holes"][0]); // remove "first"
// Create a new multi-dimensional array
$juices["apple"]["green"] = "good";
数组的比较
可以用 array_diff()和数组运算符来比较数组。
$a = array("a" => "apple", "b" => "banana");
$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");
$c = $a + $b; // Union of $a and $b
echo "Union of \$a and \$b: \n";
var_dump($c);
$c = $b + $a; // Union of $b and $a
echo "Union of \$b and \$a: \n";
var_dump($c);
$a += $b; // Union of $a += $b is $a and $b
echo "Union of \$a += \$b: \n";
var_dump($a);
输出
Union of $a and $b:
array(3) {
["a"]=>
string(5) "apple"
["b"]=>
string(6) "banana"
["c"]=>
string(6) "cherry"
}
Union of $b and $a:
array(3) {
["a"]=>
string(4) "pear"
["b"]=>
string(10) "strawberry"
["c"]=>
string(6) "cherry"
}
Union of $a += $b:
array(3) {
'a' =>
string(5) "apple"
'b' =>
string(6) "banana"
'c' =>
string(6) "cherry"
}
注意！！！！ PHP中的数组是值拷贝，默认情况下是数组整体拷贝,和其他语言有很大不同
object(对象)
PHP 支持面向对象，也就是说可以自定义 class;
callable(可调用)
特殊类型
resource(资源)
资源 resource 是一种特殊变量，保存了到外部资源的一个引用(ID)。资源是通过专门的函数来建立和使用的。如打开文件、打开数据库等函数，反回的就是资源类型； 从其他类型转换为资源没有实际意义；
get_resource_type()
此函数返回一个字符串，用于表示传递给它的 resource 的类型。如果参数不是合法的 resource，将产生错误。
$c = mysql_connect();
echo get_resource_type($c)."\n";
// 打印：mysql link
$fp = fopen("foo","w");
echo get_resource_type($fp)."\n";
// 打印：file
$doc = new_xmldoc("1.0");
echo get_resource_type($doc->doc)."\n";
// 打印：domxml document
释放资源
引用计数系统是 Zend 引擎的一部分，可以自动检测到一个资源不再被引用了(和 Java 一样)。这种情况下此资源使用的所有外部资源都会被垃圾回收系统释放。因此，很少需要手工释放内存。 如果外部资源有 close 等回收函数，还是需要手动回收一下确保回收资源；
Note: 持久数据库连接比较特殊，它们不会被垃圾回收系统销毁。需要手动 close; 参见数据库永久连接一章。
NULL(无类型)
特殊的 NULL 值表示一个变量没有值。NULL 类型唯一可能的值就是 NULL。
在下列情况下一个变量被认为是 NULL：
被赋值为 NULL。
尚未被赋值。
被 unset()。
文档类型
文档类型并不是实际的PHP语言类型无法在代码中使用， 文档类型指的是为了我们方便读懂 PHP的文档所在文档中使用得一些类型；
mixed
mixed 说明一个参数可以接受多种不同的(但不一定是所有的)类型。
例如 gettype() 可以接受所有的 PHP 类型，str_replace() 可以接受字符串和数组。
number
number 说明一个参数可以是 integer 或者 float。
callback
本文档中在 PHP 5.4 引入 callable 类型之前使用 了 callback 伪类型。二者含义完全相同。
array|object
array|object 意思是参数既可以是 array 也可以是 object。
void
void 作为返回类型意味着函数的返回值是无用的。void 作为参数列表意味着函数不接受任何参数。
...
在函数原型中，$... 表示等等的意思。当一个函数可以接受任意个参数时使用此变量名。
类型转换
转BOOL
当转换为 boolean 时，以下值被认为是 FALSE：
布尔值 FALSE 本身
整型值 0(零)
浮点型值 0.0(零)
空字符串，以及字符串 "0"
不包括任何元素的数组
特殊类型 NULL(包括尚未赋值的变量)
从空标记生成的 SimpleXML 对象
所有其它值都被认为是 TRUE(包括任何资源 和 NAN)。
Warning
-1 和其它非零值(不论正负)一样，被认为是 TRUE！
'\0'不是FALSE；
转换为数字(整数和浮点数)
BOOL值，TRUE： 1， FALSE 为0；
从字符串转换为数值：
$foo = 1 + "10.5"; // $foo is float (11.5)
$foo = 1 + "-1.3e3"; // $foo is float (-1299)
$foo = 1 + "bob-1.3e3"; // $foo is integer (1)
$foo = 1 + "bob3"; // $foo is integer (1)
$foo = 1 + "10 Small Pigs"; // $foo is integer (11)
$foo = 4 + "10.2 Little Piggies"; // $foo is float (14.2)
$foo = "10.0 pigs " + 1; // $foo is float (11)
$foo = "10.0 pigs " + 1.0; // $foo is float (11)
转换为数组
对于任意 integer，float，string，boolean 和 resource 类型，如果将一个值转换为数组，将得到一个仅有一个元素的数组，其下标为 0，该元素即为此标量的值。换句话说，(array)$scalarValue 与 array($scalarValue) 完全一样。
如果一个 object 类型转换为 array，则结果为一个 K，V数组，键名将为成员变量名；
不过有几点例外：私有变量前会加上类名作前缀；保护变量前会加上一个 '*' 做前缀。这些前缀的前后都各有一个 空 字符。这会导致一些不可预知的行为：
class A {
private $A = '1'; // This will become "\0A\0A"
}
class B extends A {
private $A = '2'; // This will become "\0B\0A"
public $AA = '3'; // This will become "AA"
protected $CC = '4'; // This will become "\0*\0CC";
}
$arr = (array) new B() ;
var_dump($arr);
echo $arr["AA"]; // 输出3
echo $arr["\0B\0A"]; // 输出 2
echo $arr["\0A\0A"]; // 输出 1
echo $arr["\0*\0CC"]; // 输出 4
?>
将 NULL 转换为 array 会得到一个空的数组。
\0
\0 在C语言中表示表示一个字符串的结尾符号；但是在PHP里面就是一个空字符，通过 trim 可以去掉 开头和结尾的空字符; 空字符没有实际意义，输出的时候也无法通过观察字符串内容看到空字符，但它确实是存在的； 在使用得时候要注意一下； (\0 不是NULL，它的 strlen 是1)；
转换为对象
如果将一个对象转换成对象，它将不会有任何变化。
如果其它任何类型的值被转换成对象，将会创建一个内置类 stdClass 的实例。
如果该值为 NULL，则新的实例为空。
array 转换成 object 将使键名成为属性名并具有相对应的值。
$obj = (object) array('1' => 'foo');
var_dump(isset($obj->{'1'})); // PHP 7.2.0 后输出 'bool(true)'，之前版本会输出 'bool(false)'
var_dump(key($obj)); // PHP 7.2.0 后输出 'string(1) "1"'，之前版本输出 'int(1)'
?>
对于其他值，会包含进成员变量名 scalar。
$obj = (object) 'ciao';
echo $obj->scalar; // outputs 'ciao'
?>
使用 settype 类型转换
$foo = "5bar"; // string
$bar = true; // boolean
settype($foo, "integer"); // $foo 现在是 5 (integer)
settype($bar, "string"); // $bar 现在是 "1" (string)
引用
122
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
