【php基础入门】细说php的变量以及常量的知识点详解

---

前言：混一天和努力一天，一天看不出任何差别，三天看不到任何变化，七天也看不到任何距离…… 但是一个月后会看到话题不同，三个月后会看到气场不同，半年后会看到距离不同，一年后会看到人生道路不同。

一、PHP 变量详解

变量就是临时存储值的容器，它可以储存数字、文本、或者一些复杂的数据等。变量的值在程序运行中会随时发生变化，能够为程序中准备使用的一段数据起一个简短容易记的名字，另外它还可以保存用户输入的数据或运算的结果。

1.1输出语句

在PHP中，可以使用echo 、 print 、 print_r 、 printf 、 sprintf 、 var_dump六种语句来实现输出。

1. echo语句
   echo() 实际上不是一个函数，是php语句，因此您无需对其使用括号。不过，如果您希望向 echo() 传递一个以上的参数，那么使用括号会发生解析错误。而且echo是返回void的，并不返回值，所以不能使用它来赋值。

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语句，进行输出时，则使用括号将生成解析错误。

2. print语句
   print() 和 echo() 用法一样，但是echo速度会比print快一点点。实际上它也不是一个函数，因此您无需对其使用括号。print语句也可以实现输出，且有返回值。当输出成功会返回1，失败就会返回0；因此它可以在表达式中使用。

print "hello "；

print ("world！");

echo print "hello";
?>

3. printf()函数
   printf()函数也可以实现输出，可以输出普通的字符串，也格式化输出字符串。例：

// 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大写字母）

4. sprintf函数
   此函数使用方法和printf一样，唯一不同的就是该函数把格式化的字符串写写入一个变量中，而不是输出来。（他不会输入内容，而是返回格式化的字符串）

 
// 有时我们只想要将格式化后的字符串保存起来，而不是打印输出
// 这时候就用到了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;
?>

5. print_r 函数
   print_r()函数是用来输出变量的，可以用人类容易读取的格式来显示这个变量的信息。

print_r有两个参数，第一个是变量，第二个可设为true，如果设为true，则会返回字符串，否则返回布尔值TRUE。

$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 "

"; print_r ($a); echo ""; ?>

6. var_dump()函数
   var_dump()函数用于输出变量的内容、类型、长度，可以显示变量的结构化信息，例如：类型、值。常用来开发阶段的代码调试。

$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);函数把一个字符串写入文件中

//下面输出的 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 "
".print_r($arr,true)."
";
?>

1.2数据类型

PHP 中的数据类型可以分为三大类，分别是标量数据类型、复合数据类型和特殊数据类型

类型	成员
基本类型	布尔,字符串,数值(整数和浮点数)
复合类型	数组, 对象
特殊类型	null, 资源, 回调,闭包

1.四种基本类型

• 整数型（integer）
• 浮点数型（float）
• 布尔型（boolean）
• 字符串（string）

类型	功能
string	字符串是连续的字符序列
integer	整型包含所有的整数，可以是正数也可以是负数
float	浮点型表示整数外它还可以用来表示小数和指数
boolean	布尔型

    //双引号方式声明字符串
    $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],'
';  // a
echo $arr[1],'
';  // b
echo $arr[5],'
';  // f

// 遍历索引数组
for($i=0;$i<count($arr);$i++) {
     
    echo $arr[$i],'
';
}

// 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,'
';
}
// 注意：我们可以省略其中的键，只打印值，但无法只打印键
// 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(数据，类型)
自动转换	根据操作符对操作数的类型要求进行

1. 临时转换：用户
   临时转换用小括号的形式，我们可以通过(int)都是这样的形式转换成整型，或者转换成浮点型(boolean)缩写(bool),还可以转换成数组，(array)的形式转换成数组，还可以转换成对象。
   

$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]);
?>

2. 永久转换：只针对变量

$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);
?>

临时转换和永久转换总结

//临时转换
$var = true;
var_dump($var);
$res = (int)$var;
var_dump($res);
var_dump((int)$var, (integer)$var);
echo "
";

//临时转换成浮点型
var_dump((float)$var, (double)$var, (real)$var);
echo "
";

$var = 3.6;
//舍掉小数部分
var_dump((int)$var, (integer)$var);
echo "
";

//临时转换成字符串型
$var = true;
var_dump((string)$var);
echo "
";

//临时转换成布尔类型
$var = "3xuxiaoke";
var_dump((bool)$var, (boolean)$var);
echo "
";

//临时转换成空
$var = "空";
var_dump((unset)$var);
echo "
";

//临时转换成数组
$var = 123;
var_dump((array)$var);
echo "
";

//临时转换成对象
$var = 12.3;
var_dump((object)$var);
echo "
";

//通过系统函数完成临时转换(类型+val())
$var = "3xuxiaoke";
$res = intval($var);
var_dump($res);
echo "
";

var_dump(floatval($var), doubleval($var));
echo "
";

echo "
";



//永久转换------------------------------------
$var = 123;

var_dump($var);
echo "
";

echo gettype($var);
echo "
";

$var = true;

echo gettype($var);
echo "
";

$var = 123;
var_dump($var);
echo "
";

settype($var, "boolean");
var_dump($var);
echo "
";

/*type 的可能值为：
“boolean” （或为“bool”）
“integer” （或为“int”）
“float” （或为“double”）
"string"
"array"
"object"
“null” */

$var = "3xuxiaoke";
echo settype($var, "int")."
";
echo floatval($var)."
";
echo gettype($var)."
";

// settype(数据，类型) 设置类型  gettype(数据) 获取类型

3. 自动转换：系统
   程序会根据上下文环境自动进行转换
   其它类型转换成布尔型

• 0>-false
• 0.0>-false
• 空字符串“或者”或者“0”或者“0”>-false
• null>-false
• 空数组array()>-false

// "+"要求参与计算的数据都是数值类型，如果不是，就会触发自动转换
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中，也有检测数据类型的方法，具体如下：

1. 输出变量的数据类型（gettype）

 
 
   $arry = array('a','b','c'); 
 
   echo gettype($arry); //array 
 
 ?> 

2. 输出变量的数据类型、包含的数量以及具体内容（var_dump）

 
 
  $str = 'hello world'; 
 
  var_dump($str);//string(11) "hello world"  
 
?> 

3. 检测某个变量是否是指定的数据类型(is_double、is_array、is_int、is_string等)，假如结果为真返回1，为假就会返回空。

类型	函数
标量	is_int(),is_string(),is_bool()…
复合	is_array(),is_object()
特殊	is_null(),is_resource()

 
 
  $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 
',$a,$b,($a+$b));
    }else if(is_float($a) && is_float($b)){
        return sprintf('%f + %f = %f 
',$a,$b,($a+$b));
    }else if(is_numeric($a) && is_numeric($b)){
        return sprintf('%f + %f = %f 
',$a,$b,($a+$b));
    }else{
        return "非法数值";
    }
  }*/
  // php7+：参数类型检测，支持复合类型，也支持标量
  function sum1(float $a,float $b):string{
     
    return sprintf('%s + %s = %s 
',$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 变量必须使用一个美元符号“$”后面跟变量名来表示，然后再使用“=”给这个变量赋值。如下所示：

    $a = 1;
    $b = 2;
    $c = 3;
    echo $a.', '.$b.', '.$c; // 1,2,3
?>

1.6变量命名规则

变量名并不是可以随意定义的，一个有效的变量名应该满足以下几点要求：

• 变量必须以 $ 符号开头，其后是变量的名称，$ 并不是变量名的一部分；
• 变量名必须以字母或下划线开头；
• 变量名不能以数字开头；
• 变量名只能包含字母（A_{z）、数字（0}9）和下划线（_）；
• 与其它语言不同的是，PHP 中的一些关键字也可以作为变量名（例如 $true、$for）。
• 标识符分为：预定义（保留字、关键字，class，public）和自定义的。

注意：PHP 中的变量名是区分大小写的,函数名不区分大小写，因此 $var 和 $Var 表示的是两个不同的变量。

$_str = "PHP是世界上最好的语言";        
// 变量名为：_str，变量值为：PHP是世界上最好的语言

当使用多个单词构成变量名时，可以使用下面的命名规范：

• 下划线命名法：将构成变量名的单词以下划线分割，例如 $ge{t}_{u}se{r}_{n}ame、$set_user_name；
• 驼峰式命名法(推荐使用)：第一个单词全小写，后面的单词首字母小写，例如 $getUserName、$getDbInstance；
• 帕斯卡命名法：将构成变量名的所有单词首字母大写，例如 $Name、$MyName、$GetName。

1.8变量赋值

就是用不同的名字访问同一个变量内容。当改变其中任何一个变量的值，另一个也会发生变化。引用赋值使用“&”来表示引用。

//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 变量分为全局变量和局部变量两种。

可以在当前源码中任何地方（函数外部）使用的变量称为全局变量，它们具有全局作用域；只能在对其进行定义的函数内部使用的变量称为局部变量，它们具有局部作用域。

局部变量与局部作用域

局部变量就是在函数的内部定义的变量，它只能在定义它的函数内使用。局部变量会在函数调用结束时自动销毁。

    function example(){
     
        $a = "php中文网";  // 在函数内定义变量 a
        echo "局部变量 a 的值为：".$a."
";
    }
    example();
    if(isset($a)){
         // 在函数外部调用 $a,如果 $a 存在则会打印下面的内容
        echo "在函数外部调用函数内的局部变量 a，其值为：".$a;
    }
// 只打印了函数体内的 “局部变量 a 的值为：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：包含了 ${}_{G}ET，$_POST 和 $_COOKIE 的所有信息；
• $_POST：通过 POST 方法提交的数据；
• $_GET：通过 GET 方法提交的数据；
• $_FILES：通过 POST 方式上传到服务器的文件数据；
• $_ENV：通过环境方式传递给当前脚本的变量组成的数组；
• $_COOKIE：通过 HTTP Cookies 方式传递给当前脚本的变量所组成的数组；
• $_SESSION：当前脚本可用 SESSION 变量组成的数组。

$GLOBALS 是一个包含了全局作用域中所有变量的数组，变量的名字就是数组的键。

    $name = 'php中文网';
    $title = 'PHP 预定义变量';
    function demo(){
     
        static $str = 'PHP 教程';
        $url = 'http://www.php.cn';
    }
    echo "
";
    var_dump($GLOBALS);
	echo "
";
/*
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 变量 = 值;

定义一个静态变量来记录函数调用的次数，另外再定义一个局部变量与静态变量做对比，具体代码如下：

    // 静态变量并不是说它的值是不能改变的，不能改变值的那叫常量。 其实静态变量的值是可以改变的，而且它会保持最新的值。之所以称为静态，是因为它不会随着函数的调用和退出而发生变化。即上次调用函数的时候，如果我们给静态变量赋予某个值的话，那么下次函数调用时，这个值是保持不变。
    function demo(){
     
        static $a = 0;
        $b = 0;
        $a++;
        $b++;
        echo '第 '.$a.' 次运行 demo 函数, 局部变量 $b 的值为：'.$b.'
';
    }
    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关键字
class User{
     
    // 常量必须初始化赋值
    const APP_PATH = '0426/demo.php';
}

2.2预定义常量和魔术常量

预定义常量

定义常量顾名思义也就是 PHP 中预先定义好的常量，使用这些预定义常量可以帮助我们来获取一些 PHP 中的信息，比如，我们可以使用预定义常量来获取当前电脑的操作系统，当前使用的 PHP 版本信息等等。另外需要注意的是预定义常量是区分大小写的。

查看系统预定义常量：echo "

".print_r(get_defined_constants(true),true)."

";

下面列举了一些 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__：当前文件的命名空间的名称。

注意：与预定义常量不同，魔术常量是不区分大小写的。

    echo "
当前文件的根路径：".__dir__;
 	echo "
当前文件的路径：".__FILE__;
    echo "
当前的行数：".__LINE__;
    echo "
当前PHP的版本信息：".PHP_VERSION;
    echo "
当前的操作系统：".PHP_OS;
/*
当前文件的根路径：E:\zhang\0426
当前文件的路径：E:\zhang\0426\demo.php
当前的行数：4
当前PHP的版本信息：7.2.31
当前的操作系统：WINNT
*/
function getName(){
     
    echo "
当前函数名称：".__FUNCTION__;
}
getName(); // 当前函数名称：getName

class Person{
     
    public function walk(){
     
    	echo "当前类名为 ".__CLASS__;
        echo "当前类名和方法名为 ".__METHOD__;
    }
}
$zhang = new Person;
$zhang->walk(); // 当前类名为 Person 当前类名和方法名为 Person::walk
?>

---