一、目录
第一章 PHP 变量详解
1.1变量的输出语句
1.2变量的数据类型
1.3变量数据类型转换
1.4变量数据类型检测
1.5变量的声明创建
1.6变量的命名规则
1.7变量的赋值操作
1.8变量的相关函数
1.9变量的作用域
第二章 PHP 常量详解
2.1常量的声明与使用
2.1预定义常量和魔术常量
前言：混一天和努力一天，一天看不出任何差别，三天看不到任何变化，七天也看不到任何距离…… 但是一个月后会看到话题不同，三个月后会看到气场不同，半年后会看到距离不同，一年后会看到人生道路不同。
一、PHP 变量详解
变量就是临时存储值的容器，它可以储存数字、文本、或者一些复杂的数据等。变量的值在程序运行中会随时发生变化，能够为程序中准备使用的一段数据起一个简短容易记的名字，另外它还可以保存用户输入的数据或运算的结果。
1.1输出语句
在PHP中，可以使用echo 、 print 、 print_r 、 printf 、 sprintf 、 var_dump六种语句来实现输出。
- echo语句
echo() 实际上不是一个函数，是php语句，因此您无需对其使用括号。不过，如果您希望向 echo() 传递一个以上的参数，那么使用括号会发生解析错误。而且echo是返回void的，并不返回值，所以不能使用它来赋值。
<?php
echo "words";
echo ("words");
echo ("apple","bear"); //发生错误，有括号不能传递多个参数
echo "alice","bill","cart", "daring"; // 不用括号的时候可以用逗号隔开多个值， 会输出 alicebillcartdaring 不管是否换行，最终显示都是为一行
$fistname="alice";
echo "$fistname com"; // 如果 $firstname = "alice", 则会输出 alice com.
echo ‘$firstname com‘; // 由于使用单引号，所以不会输出$firstname的值，而是输出 $firstname com
// 这里注意，后面会学到，单引号不能解析变量
$a = echo("words"); // 错误！不能用来赋值
?>
说明：在平时，echo或echo()的输出是一样的，只有在将多个参数传递给echo语句，进行输出时，则使用括号将生成解析错误。
- print语句
print() 和 echo() 用法一样，但是echo速度会比print快一点点。实际上它也不是一个函数，因此您无需对其使用括号。print语句也可以实现输出，且有返回值。当输出成功会返回1，失败就会返回0；因此它可以在表达式中使用。
<?php
print "hello "；
print ("world！");
echo print "hello";
?>
- printf()函数
printf()函数也可以实现输出，可以输出普通的字符串，也格式化输出字符串。例：
<?php
// printf(格式模板，数据……)
$a=20;
$b=30;
printf("输出： a=%d,b=%d,%1\$d+%2\$d=%d",$a,$b,$a+$b); // 输出：a=20,b=30,20+30=50
printf("My name is %s %s。","alice", "com"); // My name is alice com。
printf("My name is %1\$s %1\$s","alice", "com"); // 在s前添加1\$或2\$.....表示要显示后面第几个参数位置，此行输出 My name is alice alice因为只显示第一个参数两次。
printf("My name is %2\$s %1\$s","alice", "com"); // My name is com alice
?>
- %% – 返回百分比符号
- %b – 二进制数
- %c – 依照 ASCII 值的字符
- %d – 带符号十进制数
- %e – 科学计数法（比如 1.5e+3）
- %u – 无符号十进制数
- %f – 浮点数(local settings aware)
- %o – 八进制数
- %s – 字符串
- %x – 十六进制数（%x小写字母%X大写字母）
- sprintf函数
此函数使用方法和printf一样，唯一不同的就是该函数把格式化的字符串写写入一个变量中，而不是输出来。（他不会输入内容，而是返回格式化的字符串）
<?php
// 有时我们只想要将格式化后的字符串保存起来，而不是打印输出
// 这时候就用到了sprintf()
// pdo:dsn,‘mysql:host=localhost;dbname=phpedu;‘
$type = ‘mysql‘;
$host = ‘localhost‘;
$dbname = ‘phpedu‘;
$linkParams = [$type,$host,$dbname];
// 直接格式化输出
printf(‘%s:host=%s;dbname=%s;‘,$type,$host,$dbname);
// vprintf()支持数组参数
vprintf(‘%s:host=%s;dbname=%s;‘,$linkParams); // mysql:host=localhost;dbname=phpedu;
// 直接返回格式化字符串不输出
$dsn = sprintf(‘%s:host=%s;dbname=%s;‘,$type,$host,$dbname);
$dsn = vsprintf(‘%s:host=%s;dbname=%s;‘,$linkParams);
echo $dsn;
?>
- print_r 函数
print_r()函数是用来输出变量的，可以用人类容易读取的格式来显示这个变量的信息。
print_r有两个参数，第一个是变量，第二个可设为true，如果设为true，则会返回字符串，否则返回布尔值TRUE。
<?php
$a="alice";
$c = print_r($a); // 打印alice 返回布尔值true
echo $c; // $c的值是TRUE
// 第二个参数设置为true 可以将变量的信息转换成一个字符串 不输出到浏览器 用于线上调试,sql日志记录
$c = print_r($a,true); // 不打印，返回字符串内容
echo $c; // $c的值是字符串alice
$a = array (‘a‘ => ‘apple‘, ‘b‘ => ‘banana‘, ‘c‘ => array (‘x‘,‘y‘,‘z‘));
echo "</pre>";
print_r ($a);
echo "</pre>";
?>
- var_dump()函数
var_dump()函数用于输出变量的内容、类型、长度，可以显示变量的结构化信息，例如：类型、值。常用来开发阶段的代码调试。
<?php
$var_name=array(99,‘w3resource‘,67899.99, array(‘X‘,‘Y‘,1));
var_dump($var_name);
$passed = true;
// 直接echo 让会将布尔值转换为字符串输出为1
echo $passed; // 1
// 打印实际值
echo var_export($passed,true); // true
// 打印类型
echo gettype($passed); // boolean
echo gettype(gettype($passed)); // string
// var_dump() 可以同时打印值和类型
var_dump($passed);
?>
输出方式总结:
- echo 可以输出数字型和字符型。输出布尔型的时候，true输出的结果是1，false输出的结果是空
- printf 可以输出数字型、字符型、布尔型。输出布尔型的时候，true输出的结果为1，false输出的结果为0。
- print_r可以输出数字型、字符型、布尔型和数组。输出布尔型的时候，true输出的结果为1，false输出的结果为空；输出数组是以‘键’=>‘值’的形式。
- var_dump() 判断一个变量的类型与长度,并输出变量的数值,如果变量有值输的是变量的值并回返数据类型。此函数显示关于一个或多个表达式的结构信息，包括表达式的类型与值。数组将递归展开值，通过缩进显示其结构。
- die() 有两个功能：先输出内容，然后退出程序。一般用于数据库连接的判断，一旦执行die()后面的内容将不执行。
mysql_connect("locahost","root","root") or die("链接服务器失败！");
ob_clean() 为一个可以清空输出缓冲区内容的内置函数
file_put_contents(‘log.text‘,$res);函数把一个字符串写入文件中
<?php
//下面输出的 hello 会被加入缓存区
echo ‘hello‘;
//清空缓存区的内容，上面的 hello 不会再次输出
ob_clean();
echo "world！";
$arr = ["id"=>1,"name"=>"zhang","gender"=>"man",age=>18];
$res = print_r($arr,true);
file_put_contents(‘log.text‘,‘写入数组信息‘.$res);
echo "<pre>".print_r($arr,true)."</pre>";
?>
1.2数据类型
PHP 中的数据类型可以分为三大类，分别是标量数据类型、复合数据类型和特殊数据类型
| 类型 | 成员 |
|---|---|
| 基本类型 | 布尔,字符串,数值(整数和浮点数) |
| 复合类型 | 数组, 对象 |
| 特殊类型 | null, 资源, 回调,闭包 |
1.四种基本类型
- 整数型（integer）
- 浮点数型（float）
- 布尔型（boolean）
- 字符串（string）
| 类型 | 功能 |
|---|---|
| string | 字符串是连续的字符序列 |
| integer | 整型包含所有的整数，可以是正数也可以是负数 |
| float | 浮点型表示整数外它还可以用来表示小数和指数 |
| boolean | 布尔型 |
<?php
//双引号方式声明字符串
$str1 = "PHP 学习";
//单引号方式声明字符串
$str2 = ‘输出 hello world!‘;
// 字符串的拼接(用点 . 拼接字符串)
echo $str1.$str2; // PHP 学习输出 hello world!
// 当字符串内部包含双引号或单引号与定界符冲突时
// 我们可以将定界符改为单引号
echo ‘你好 “zhang”!‘; // 你好 “zhang”!
// 使用反引号转义字符
echo "你好\"zhang\"!"; // 你好"zhang"!
echo "C:\\web\\table\\index.html";
// 注意：单引号只能识别2个转义字符 \‘ , \ // 单双引号区别：字符转移、变量解析、运行速度。
// 定义一个整型数据类型的变量
$x = 5985;
// 输出此变量
var_dump($x); // int(5985)
// 八进制 十六进制 二进制
var_dump(0745,0x5ac,0b11011); // int(485) int(1452) int(27)
// 定义一个浮点型变量
$num1 = 3.1415926;
var_dump($num1); // float(3.1415926)
var_dump(5.6e3); // float(5600) 科学计算法
// 定义一个布尔型为假的变量
$y = faLse;
var_dump($y); // bool(false)
// 标量类型
$int = 18;
$float = 18.88;
$bool = false;
$str = ‘hello world!‘;
?>
2.两种复合类型
- 数组（array）
- 对象（object）
数组是一组数据的集合，是将数据按照一定规则组织起来形成的一个整体。数组的本质是存储管理和操作一组变量。按照数组的维度划分，可以有一维数组、二维数组和多维数组。我们可以使用 array() 函数来创建数组。
// array数组 array(键(key)=>值(value),键(key)=>值(value),……)
// 默认索引 0 1 2 3（索引数组）
$arr1 = [12,13,18,62,85];
// 指定数组的键 也就是索引.类似于js中的对象字面量（关联数组）
$arr2 = ["id"=>1,"name"=>"zhang","age"=>18,"gender"=>‘man‘];
$user = array("id"=>1,"name"=>"zhang","age"=>18,"gender"=>‘man‘);
var_dump($arr1,$arr2);
// array(5) { [0]=> int(12) [1]=> int(13) [2]=> int(18) [3]=> int(62) [4]=> int(85) }
// array(3) { ["id"]=> int(1) ["name"]=> string(5) "zhang" ["age"]=> int(18) ["gender"]=> string(man) }
$arr = array(‘a‘,‘b‘,‘c‘,‘d‘,‘e‘);
// 在最后增加一项
$arr[] = "f";
// 打印数组
vprintf(‘Array ( [0] => %s [1] => %s [2] => %s [3] => %s [4] => %s [5] => %s ) ‘,$arr);
// 输出效果一样 用于打印数组
print_r($arr); // Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f )
echo $arr[0],‘<br >‘; // a
echo $arr[1],‘<br >‘; // b
echo $arr[5],‘<br >‘; // f
// 遍历索引数组
for($i=0;$i<count($arr);$i++) {
echo $arr[$i],‘<br >‘;
}
// foreach是专门用来循环数组的
foreach ($variable as $key => $value) {
# code...
}
// foreach 里面的键值的变量名($k,$v) 为任意合法的变量名
$arr = array(‘name‘=>‘zhangsan‘ , ‘age‘=>24 , ‘area‘=>‘Beijing‘);
foreach($arr as $k=>$v) {
echo $k,‘:‘,$v,‘<br >‘;
}
// 注意：我们可以省略其中的键，只打印值，但无法只打印键
// array_keys — 返回数组中所有的键名
print_r(array_keys(arr2)); // 返回键名组成的数组
对象（Object）可以用于存储数据。在 PHP 中对象必须声明。首先必须使用 class 关键字声明类对象。类是可以包含属性和方法的结构。然后在类中定义数据类型，在实例化的类中使用数据类型。
在支持面向对象的语言中，可以把各个具体事物的共同特征和行为抽象成一个实体，称之为一个“类”，而对象是类使用 new 关键字实例化后的结果。
class Car //使用 class 声明一个类对象
{
private $color; // 变量=》属性
// 函数=》方法
public function setCar($color="black") {
// $this 表示当前对象
$this->color = $color;
}
public function getColor() {
return $this->color;
}
}
$car1 = new Car(); // 实例化对象
// 实例化名称->成员属性方法
$car1->setCar(‘red‘); // 设置$color的值red
echo $car1->getColor(); // 获取$color的值 red
$car2 = new Car();
$car2->setCar();
echo $car2->getColor(); // black
3.两种特殊类型
- 空值 NULL
- 资源 （resource）
// NULL 在 PHP 中是一种特殊的数据类型，它只有一个值，即 NULL，表示空值（变量没有值），需要注意的是它与空格的意义不同
// 他并不表示空格，空字符串，零，null不区分大小写NULL
$str = NULL;
var_dump($str);
$username = ‘zhang‘;
unset($username); // 释放变量
@var_dump($username); // @错误抑制符
// （resource） 资源类型 保存到外部资源的一个引用
// fopen()
header("content-type:text/html;charset=utf-8");//设置编码，解决中文乱码
$file = fopen("log.txt", "rw");//打开test.txt文件
var_dump($file); // resource(3) of type (stream) 3是资源类型id stream资源类型
// imagecreate()
$image_handle = imagecreate(100,50);
var_dump($image_handle); // resource(2) of type (gd)
1.3数据类型转换
PHP数据类型转换分为自动转换（隐式转换）和强制转换（显示转换），强制转换又分为临时转换和永久转换。
| 转换方式 | 函数 |
|---|---|
| 临时转换 | (int),(string),(array),(object)... |
| 强制转换 | settype(数据，类型) |
| 自动转换 | 根据操作符对操作数的类型要求进行 |
- 临时转换：用户
临时转换用小括号的形式，我们可以通过(int)都是这样的形式转换成整型，或者转换成浮点型(boolean)缩写(bool),还可以转换成数组，(array)的形式转换成数组，还可以转换成对象。
<?php
$var=123;
var_dump((string)$var); // 用string关键字 实现
var_dump($var); // int(123)
$res=strval($var);//通过strval函数实现
var_dump($res); // string(3) "123"
// 临时转换并不会改变原数据的类型
// http://zhang.com/php/0426/demo.php?id=3&p=5
var_dump($_GET[‘id‘]);
// 这里看到id是个字符串，url中的内容全部默认是字符串
// 我们将其临时转换为整数，方便运算
$id = (int)$_GET[‘id‘];
if($id === 3){
echo "查找成功！";
}
$myAge = 18;
var_dump($myAge,(string)$myAge,(float)$myAge);
var_dump((array)$myAge,((array)$myAge)[0]);
?>
- 永久转换：只针对变量
<?php
$var=12;
var_dump($var); // int(12)
settype($var, ‘string‘);
var_dump($var); // string(2) "12"
$s = true;
var_dump($s); // bool(true)
settype($s,"int");
var_dump($s); // int(1)
$s = 32;
var_dump($s); // int(32)
settype($s,"array");
var_dump($s); // array(1) { [0]=> int(32) }
// 字符串转换数组意义不大，字符串本身就可以当数组使用
$str = "admin";
echo $str[0],$str[1]; // ad
// 转对象，默认属性名scalar
var_dump(((object)$str)->scalar);
?>
临时转换和永久转换总结
<?php
//临时转换
$var = true;
var_dump($var);
$res = (int)$var;
var_dump($res);
var_dump((int)$var, (integer)$var);
echo "<br>";
//临时转换成浮点型
var_dump((float)$var, (double)$var, (real)$var);
echo "<br>";
$var = 3.6;
//舍掉小数部分
var_dump((int)$var, (integer)$var);
echo "<br>";
//临时转换成字符串型
$var = true;
var_dump((string)$var);
echo "<br>";
//临时转换成布尔类型
$var = "3xuxiaoke";
var_dump((bool)$var, (boolean)$var);
echo "<br>";
//临时转换成空
$var = "空";
var_dump((unset)$var);
echo "<br>";
//临时转换成数组
$var = 123;
var_dump((array)$var);
echo "<br>";
//临时转换成对象
$var = 12.3;
var_dump((object)$var);
echo "<br>";
//通过系统函数完成临时转换(类型+val())
$var = "3xuxiaoke";
$res = intval($var);
var_dump($res);
echo "<br>";
var_dump(floatval($var), doubleval($var));
echo "<br>";
echo "<hr/>";
//永久转换------------------------------------
$var = 123;
var_dump($var);
echo "<br>";
echo gettype($var);
echo "<br>";
$var = true;
echo gettype($var);
echo "<hr/>";
$var = 123;
var_dump($var);
echo "<br>";
settype($var, "boolean");
var_dump($var);
echo "<br>";
/*type 的可能值为：
“boolean” （或为“bool”）
“integer” （或为“int”）
“float” （或为“double”）
"string"
"array"
"object"
“null” */
$var = "3xuxiaoke";
echo settype($var, "int")."</br>";
echo floatval($var)."</br>";
echo gettype($var)."</br>";
// settype(数据，类型) 设置类型 gettype(数据) 获取类型
- 自动转换：系统
程序会根据上下文环境自动进行转换
其它类型转换成布尔型
- 0>-false
- 0.0>-false
- 空字符串“或者”或者“0”或者“0”>-false
- null>-false
- 空数组array()>-false
<?php
// "+"要求参与计算的数据都是数值类型，如果不是，就会触发自动转换
echo 123+"456"; // 579
echo 123+(int)"456"; // ====> 579
// "."字符串拼接，希望两边都是字符串
echo "php". 123 ."cn"; // php123cn
echo "php" . (string)123 . "cn";
// 最常用的自动转换，一般用于布尔转换，有则为真，无则为假
if(!$email) echo "邮箱未定义";
// 未定义为NULL 会自动转换为false
$a = ‘100abc‘; // “100abc”==>100 非数字开头 "abc100"==>0
$b = 5;
echo "类型为".gettype($a+$b)."值为".($a+$b); // integer 105
@$res = null + ‘10 kg rice‘;
var_dump($res); // int(10)
$s = 10;
var_dump($s.‘kg rice‘); // string(9) "10kg rice"
?>
1.4数据类型检测
在JavaScript中，使用typeof可以检测基本数据类型，使用instanceof可以检测引用数据类型。在PHP中，也有检测数据类型的方法，具体如下：
- 输出变量的数据类型（gettype）
<?php
$arry = array(‘a‘,‘b‘,‘c‘);
echo gettype($arry); //array
?>
- 输出变量的数据类型、包含的数量以及具体内容（var_dump）
<?php
$str = ‘hello world‘;
var_dump($str);//string(11) "hello world"
?>
- 检测某个变量是否是指定的数据类型(is_double、is_array、is_int、is_string等)，假如结果为真返回1，为假就会返回空。
| 类型 | 函数 |
|---|---|
| 标量 | is_int(),is_string(),is_bool()... |
| 复合 | is_array(),is_object() |
| 特殊 | is_null(),is_resource() |
<?php
$num = 123;
if(is_array($num)){
echo ‘这是一个数组‘;
}else if(is_string($num)){
echo ‘这是一个字符串‘;
}else if(is_int($num)){
echo ‘这是一个整数‘;
}else if(is_double($num)){
echo ‘这是一个浮点数‘;
}
/*function sum1($a,$b){
if(is_int($a) && is_int($b)){
return sprintf(‘%d + %d = %d </br>‘,$a,$b,($a+$b));
}else if(is_float($a) && is_float($b)){
return sprintf(‘%f + %f = %f </br>‘,$a,$b,($a+$b));
}else if(is_numeric($a) && is_numeric($b)){
return sprintf(‘%f + %f = %f </br>‘,$a,$b,($a+$b));
}else{
return "非法数值";
}
}*/
// php7+：参数类型检测，支持复合类型，也支持标量
function sum1(float $a,float $b):string{
return sprintf(‘%s + %s = %s </br>‘,$a,$b,($a+$b));
}
echo sum1(10,15); // 10 + 15 = 25
echo sum1("10",15.845); // 10 + 15.845 = 25.845
echo sum1("ab",6); // 非法数值
/* is_numeric() 检测是否为数值字符串
is_int() 检测是否为整型
is_float() 检测是否为浮点型
is_string() 检测是否为字符串
is_bool() 检测是否为布尔
is_array() 检测是否为数组
is_object() 检测是否为对象
is_null() 检测是否为Null
is_resource() 检测是否为资源
is_scalar() 检测是否为标量类型 （字符串、数值、布尔）*/
var_export(is_scalar(12)); // true
var_export(is_scalar([1,2,3])); // false
var_export(is_scalar(null)); // false
?>
1.5变量声明创建
因为 PHP 是一种弱类型的语言，所以使用变量前不用提前声明，变量在第一次赋值时会被自动创建，这个原因使得 PHP 的语法和C语言、Java 等强类型语言有很大的不同。
声明 PHP 变量必须使用一个美元符号“$”后面跟变量名来表示，然后再使用“=”给这个变量赋值。如下所示：
<?php
$a = 1;
$b = 2;
$c = 3;
echo $a.‘, ‘.$b.‘, ‘.$c; // 1,2,3
?>
1.6变量命名规则
变量名并不是可以随意定义的，一个有效的变量名应该满足以下几点要求：
- 变量必须以 $ 符号开头，其后是变量的名称，$ 并不是变量名的一部分；
- 变量名必须以字母或下划线开头；
- 变量名不能以数字开头；
- 变量名只能包含字母（Az）、数字（09）和下划线（_）；
- 与其它语言不同的是，PHP 中的一些关键字也可以作为变量名（例如 $true、$for）。
- 标识符分为：预定义（保留字、关键字，class，public）和自定义的。
注意：PHP 中的变量名是区分大小写的,函数名不区分大小写，因此 $var 和 $Var 表示的是两个不同的变量。
$_str = "PHP是世界上最好的语言";
// 变量名为：_str，变量值为：PHP是世界上最好的语言
当使用多个单词构成变量名时，可以使用下面的命名规范：
- 下划线命名法：将构成变量名的单词以下划线分割，例如 $get_user_name、$set_user_name；
- 驼峰式命名法(推荐使用)：第一个单词全小写，后面的单词首字母小写，例如 $getUserName、$getDbInstance；
- 帕斯卡命名法：将构成变量名的所有单词首字母大写，例如 $Name、$MyName、$GetName。
1.8变量赋值
就是用不同的名字访问同一个变量内容。当改变其中任何一个变量的值，另一个也会发生变化。引用赋值使用“&”来表示引用。
<?php
//php引用变量：不同变量名指向同一地址
// 传值赋值
//定义一个变量a，此时内存开辟了一块区域，$a指向该区域
$a = 100;
//定义变量b，将a变量的值赋值给b，此时该区域有两个变量（$a和$b）指向。
$b = $a;
printf("a=%d,b=%d",$a,$b); // a=10 b=10
//修改$a变量的值，php变量具有Copy On Write的特性，所以会复制并重写a所指向的区域值，此时a和b分别指向不同区域。
$a = 10;
printf("a=%d,b=%d",$a,$b); // a=10 b=100
// ------------------------
// 引用赋值 &地址引用符
$c = 100;
$d = &$c;
$c = 10;
printf("c=%d,d=%d",$c,$d); // c=10 d=10
//当引用指向时，php变量不在具有Copy On Write特性，且指向同一内存区域，无论$c或$d谁变化，另外一个都会变化
unset($c); // 仅仅是将$c与$d取消关联，$d依然可以用
var_dump($d); // int(10)
// -------------------------------
// 可变变量 使用两个美元符号（$）
$a = "hello";
$$a = "world";
var_dump($a); // string(5) "hello"
var_dump($hello); // string(5) "world"
// 两个变量都被定义了：$a 的内容是“hello”，并且 $hello 的内容是“world”。
// 因此，可以表述为：echo “$a ${$a}”;或者 echo “$a $hello”;它们都会输出：hello world
1.8相关函数
- ob_clean() 为一个可以清空输出缓冲区内容的内置函数
- file_put_contents() 函数把一个字符串写入文件中
- unset() 函数用于销毁释放给定的变量
- die("字符串")和exit(“字符串”)都是中止脚本执行函数
- isset()与empty() 用来检测变量是否声明和是否为空
$arr = [1,2,3,4];
var_dump($arr);
$res = print_r($arr,true); // 不打印直接返回数组内容
file_put_contents("log.txt",$res); // 将数组内容存储到log.txt中
ob_clean(); // 清空输出缓冲区内容的内置函数
// 上面的内容将不会输出
// 销毁单个变量
unset ($foo);
// 销毁单个数组元素
unset ($bar[‘quux‘]);
// 销毁一个以上的变量
unset($foo1, $foo2, $foo3);
// 输入信息终止后面程序
exit(‘123‘); // 输出123
die(‘1234‘); // 输出1234
$fp = @fopen("./readme.txt","r") or die("不能打开该文件！！！");
// 这种情况下，如果fopen函数被调用返回布尔值false时，die()将立即终止脚本，并马上打印， 传递给它的字符串，“死前还能说一两句话”。
// isset() 判断变量是否声明并且不是 NULL
// 若变量存在并且值不为null才返回true 否则返回false
var_export(isset($username)); // 变量未定义 false
$username = "zhang";
var_export(isset($username)); // true
// 使用 isset() 测试一个被设置成 NULL 的变量，将返回 FALSE
unset($username); // null
var_export(isset($username)); // false
echo !isset($username)?‘变量未被检测到‘:‘变量已定义‘;
// empty()检测变量是否为空（为空返回true 不为空 返回false）
var_export(empty(18)); // 不为空 false
var_export(empty(""),empty(0),empty(NULL),empty(false)); // 变量为空 bool(true) bool(true) bool(true)
/*
使用 empty 判断以下变量时，会被认为是空的：
"" (空字符串)
0 (作为整数的0)
0.0 (作为浮点数的0)
"0" (作为字符串的0)
NULL
FALSE
array() (一个空数组)
*/
//------------------
1.9作用域
变量的作用范围（可以被使用的范围）称为变量作用域，变量必须在其有效范围内使用，如果超出有效范围，变量就会失去其意义。按作用域可以将 PHP 变量分为全局变量和局部变量两种。
可以在当前源码中任何地方（函数外部）使用的变量称为全局变量，它们具有全局作用域；只能在对其进行定义的函数内部使用的变量称为局部变量，它们具有局部作用域。
局部变量与局部作用域
局部变量就是在函数的内部定义的变量，它只能在定义它的函数内使用。局部变量会在函数调用结束时自动销毁。
<?php
function example(){
$a = "php中文网"; // 在函数内定义变量 a
echo "局部变量 a 的值为：".$a."<br>";
}
example();
if(isset($a)){ // 在函数外部调用 $a,如果 $a 存在则会打印下面的内容
echo "在函数外部调用函数内的局部变量 a，其值为：".$a;
}
// 只打印了函数体内的 “局部变量 a 的值为：php中文网”
?>
全局变量与全局作用域
全局变量就是定义在所有函数以外的变量，其作用域是当前源码的任何地方，但是在函数内部是不可用的。在程序运行期间全局变量会一直存在，只有程序结束运行时才会被销毁。
<?php
$a = "php中文网"; // 在函数外部定义全局变量 a
function example(){
if(isset($a)){
echo "在函数内部调用全局变量 a，其值为：".$a;
}
}
example();
echo "在函数外部调用全局变量 a，其值为：".$a;
// 只打印了函数体外的 “在函数外部调用全局变量 a，其值为：php中文网”
// 通过运行结果可以看出，在函数内部并没有成功调用到 $a，但是在函数外部可以。
// -------------在函数体内使用外部全局变量
// 1. 在函数体内调用全局变量需要使用global关键字引用
function example(){
global $a; // 在函数体内通过global关键字引用外部全局变量
if(isset($a)){
echo "在函数内部调用全局变量 a，其值为：".$a;
}
}
// 2.使用超全局变量$GLOBALS[‘variable‘]
function example(){
if(isset($GLOBALS[‘a‘])){
echo "在函数内部调用全局变量 a，其值为：".$GLOBALS[‘a‘];
}
}
?>
预定义变量和静态变量
预定义变量（超全局变量）
预定义变量又叫超全局变量，它们不需要提前声明就可以在所有的作用域中使用。通过这些预定义变量可以获取用户会话、用户操作系统的环境和本地操作系统的环境等信息。
常用的预定义变量如下所示：
- $GLOBALS：全局作用域中的全部可用变量；
- $_SERVER：服务器和执行环境的信息；
- $_REQUEST：包含了 $_GET，$_POST 和 $_COOKIE 的所有信息；
- $_POST：通过 POST 方法提交的数据；
- $_GET：通过 GET 方法提交的数据；
- $_FILES：通过 POST 方式上传到服务器的文件数据；
- $_ENV：通过环境方式传递给当前脚本的变量组成的数组；
- $_COOKIE：通过 HTTP Cookies 方式传递给当前脚本的变量所组成的数组；
- $_SESSION：当前脚本可用 SESSION 变量组成的数组。
$GLOBALS 是一个包含了全局作用域中所有变量的数组，变量的名字就是数组的键。
<?php
$name = ‘php中文网‘;
$title = ‘PHP 预定义变量‘;
function demo(){
static $str = ‘PHP 教程‘;
$url = ‘http://www.php.cn‘;
}
echo "<pre>";
var_dump($GLOBALS);
echo "</pre>";
/*
array(7) {
["_GET"]=>
array(0) {
}
["_POST"]=>
array(0) {
}
["_COOKIE"]=>
array(0) {
}
["_FILES"]=>
array(0) {
}
["GLOBALS"]=>
array(7) {
["_GET"]=>
array(0) {
}
["_POST"]=>
array(0) {
}
["_COOKIE"]=>
array(0) {
}
["_FILES"]=>
array(0) {
}
["GLOBALS"]=>
*RECURSION*
["name"]=>
string(12) "php中文网"
["title"]=>
string(19) "PHP 预定义变量"
}
["name"]=>
string(12) "php中文网"
["title"]=>
string(19) "PHP 预定义变量"
} // 注意：$GLOBALS 中并不包含函数中的局部变量和静态变量。
*/
?>
静态变量 （static）
静态变量是一个特殊的局部变量，通过前面的学习我们知道，在函数内部定义一个局部变量，函数调用结束之后这个变量就会被销毁，不能继续使用了。而静态变量不同，静态变量在初始化之后，会在程序运行期间会一直存在。
和局部变量相比，静态变量具有一下特点：
- 当函数执行完毕后，静态变量不会消失；
- 静态变量只能在函数内部使用；
- 静态变量只会被初始化一次；
- 静态变量初始化的值可以省略，默认值为 null；
- 静态变量的初始值只能是具体的字符串、数值等，而不能是一个表达式。
定义静态变量需要用到 static 关键字了，使用方法如下：
static 变量 = 值;
定义一个静态变量来记录函数调用的次数，另外再定义一个局部变量与静态变量做对比，具体代码如下：
<?php
// 静态变量并不是说它的值是不能改变的，不能改变值的那叫常量。 其实静态变量的值是可以改变的，而且它会保持最新的值。之所以称为静态，是因为它不会随着函数的调用和退出而发生变化。即上次调用函数的时候，如果我们给静态变量赋予某个值的话，那么下次函数调用时，这个值是保持不变。
function demo(){
static $a = 0;
$b = 0;
$a++;
$b++;
echo ‘第 ‘.$a.‘ 次运行 demo 函数, 局部变量 $b 的值为：‘.$b.‘<br>‘;
}
demo();
demo();
demo();
demo();
/*
第 1 次运行 demo 函数, 局部变量 $b 的值为：1
第 2 次运行 demo 函数, 局部变量 $b 的值为：1
第 3 次运行 demo 函数, 局部变量 $b 的值为：1
第 4 次运行 demo 函数, 局部变量 $b 的值为：1
*/
?>
二、PHP 常量详解
所谓常量就是不能改变的量，PHP 中常量一旦被定义，就不能被修改或取消定义。
PHP 常量通常用来存储一个不被改变也不希望变化的数据，该数据只能是四种标量数据类型的数据：整型、浮点型、字符串、布尔型，不过从 PHP7 开始常量支持了数组（array）类型。
与变量相比，常量具有以下几个特点：
- 常量前面没有美元符号（$）；
- 常量只能用 define() 和 const 定义；
- 常量、类、接口、函数的作用域都是全局的；
- 常量一旦被定义就不能被重新定义或者取消定义。
- 常量名称推荐全部为大写字母
2.1常量的声明与使用
- define(): 函数
define("NATION","中国");
define("AGE",18);
- const: 关键字
const NAME = ‘zhangshuai‘;
const GENDER = "man";
$user = sprintf(‘姓名：%s,性别：%s,年龄：%d,国籍：%s‘,NAME,GENDER,AGE,NATION);
echo $user;
// 姓名：zhangshuai,性别：man,年龄：18,国籍：中国
// const 运行在编译阶段
// define()在运行阶段才创建常量
// if function里面只能用define() 运行这段代码时才创建
function func(){
// 只能用define()定义常量，const一定会报错
define("SITE","zhang.com");
}
func();
echo SITE;
// 类中定义常量只能使用const关键字
class User{
// 常量必须初始化赋值
const APP_PATH = ‘0426/demo.php‘;
}
2.2预定义常量和魔术常量
预定义常量
定义常量顾名思义也就是 PHP 中预先定义好的常量，使用这些预定义常量可以帮助我们来获取一些 PHP 中的信息，比如，我们可以使用预定义常量来获取当前电脑的操作系统，当前使用的 PHP 版本信息等等。另外需要注意的是预定义常量是区分大小写的。
查看系统预定义常量：echo "<pre>".print_r(get_defined_constants(true),true)."</pre>";
下面列举了一些 PHP 中的预定义常量：
- PHP_VERSION：当前 PHP 的版本号；
- PHP_OS：当前的操作系统名称；
- PHP_EOL：系统换行符，Windows 是（\r\n），Linux 是（\n），MAC 是（\r）；
- PHP_INT_MAX：当前 PHP 支持的最大整数；
- PHP_INT_MIN：当前 PHP 支持的最小整数；
- PHP_EXTENSION_DIR：PHP 的扩展目录；
- TRUE：布尔类型的 true；
- FALSE：布尔类型的 false；
- NULL：Null 值。
// 仅设置当前脚本中的error_reporting()函数调用的后面区的域错误报告级别
error_reporting(E_ALL)；
// 参数可以是整型或对应的常量标识符，推荐使用常量的形式
// 使用 error_reporting(0) 或者在函数前面加 @，可以抑制错误输出，以防止错误消息泄露敏感信息。
魔术常量
魔术常量属于特殊的预定义常量，这些常量可以根据它们的使用位置而变化。魔术常量通常以两个下划线__开头，并以两个下划线__结尾。
PHP 中魔术常量有八个，如下所示：
-
__LINE__：文件中的当前行号； -
__FILE__：当前文件的绝对路径（包含文件名）； -
__DIR__：当前文件的绝对路径（不包含文件名），等价于dirname(__FILE__)； -
__FUNCTION__：当前函数（或方法）的名称； -
__CLASS__：当前的类名（包括该类的作用区域或命名空间）； -
__TRAIT__：当前的 trait 名称（包括该 trait 的作用区域或命名空间）； -
__METHOD__：当前的方法名（包括类名）； -
__NAMESPACE__：当前文件的命名空间的名称。
注意：与预定义常量不同，魔术常量是不区分大小写的。
<?php
echo "<br/>当前文件的根路径：".__dir__;
echo "<br/>当前文件的路径：".__FILE__;
echo "<br/>当前的行数：".__LINE__;
echo "<br/>当前PHP的版本信息：".PHP_VERSION;
echo "<br/>当前的操作系统：".PHP_OS;
/*
当前文件的根路径：E:\zhang\0426
当前文件的路径：E:\zhang\0426\demo.php
当前的行数：4
当前PHP的版本信息：7.2.31
当前的操作系统：WINNT
*/
function getName(){
echo "<br>当前函数名称：".__FUNCTION__;
}
getName(); // 当前函数名称：getName
class Person{
public function walk(){
echo "当前类名为 ".__CLASS__;
echo "当前类名和方法名为 ".__METHOD__;
}
}
$zhang = new Person;
$zhang->walk(); // 当前类名为 Person 当前类名和方法名为 Person::walk
?>