PHP入门笔记--基础语法一

一、基本语法

1. php标记 <?php ?>
2. php代码结束标记
3. 三种注释 // /**/ #

二、类型

四种标量类型：boolean, integer, float, string

三种复合类型： array, object, callable

两种特殊类型： resource，NULL

查看表达式的值和类型，用var_dump()函数。

gettype函数得到一个易读的类型表达式用于调试。

检验某个类型，用is_type函数。

<?php
$a_bool = TRUE;   // 布尔值 boolean
$a_str  = "foo";  // 字符串 string
$an_int = 12;     // 整型 integer

echo gettype($a_bool); // 输出:  boolean
echo gettype($a_str);  // 输出:  string

// 如果是整型，就加上 4
if (is_int($an_int)) {
    $an_int += 4;
}
?>

1. Boolean

   • 不区分大小写

   • 强制转换 bool($var)

   • 当转换为bool时，以下值为FALSE:

     整型值0

     浮点型0.0

     空字符串，以及字符串“0”

     空数组

     NULL（包括未被赋值的变量）

     从空标签生成的XML对象

   • 任何资源和NAN被认为是TRUE

2. integer

   • 语法结构

     • 十进制 ： [1-9][0-9]+|0
     • 十六进制 ： 0[xX][0-9a-fA-F]+
     • 八进制 ： 0[0-7]+
     • 二进制 ： 0b[01]+
     • 最大值为 PHP_INT_MAX 最小值为 PHP_INT_MIN

   • 整形溢出

     • 超出了 integer的范围，将会被解释为float

     <?php
     // 32 位系统下的整数溢出
     
     $large_number = 2147483647;
     var_dump($large_number);                     // int(2147483647)
     
     $large_number = 2147483648;
     var_dump($large_number);                     // float(2147483648)
     
     $million = 1000000;
     $large_number =  50000 * $million;
     var_dump($large_number);                     // float(50000000000)
     ?>
     

     • php没有整除运算符

       1/2 = 0.5 (int)(25/7)=int(3)

       四舍五入：round(25/7)=float(4)

   • 转换：

     • intval()
     • 资源转为整数时，结果是资源分配的资源号
     • 浮点转为整数时，向下取整，如果浮点数超出了整数范围，则结果为未定义。

3. float

   • 浮点比较 abs($a - $b) < $epsilon

   • 某些数学运算会产生一个由常量 NAN 所代表的结果。此结果代表着一个在浮点数运算中未定义或不可表述的值。任何拿此值与其它任何值（除了 TRUE）进行的松散或严格比较的结果都是 FALSE。

     由于 NAN 代表着任何不同值，不应拿 NAN 去和其它值进行比较，包括其自身，应该用is_nan()来检查。

4. string

   • 语法

     • 单引号

       \' 单引号自身，\\ 反斜杠自身

       其他无转义，无变量

     • 双引号

       转义

     • Heredoc 结构（类似双引号）

       结束标识符必须在新行第一列

       $str = <<<EOD
       ```
       ```
       ```
       EOD;
       

     • Nowdoc 结构（类似单引号）

       $str = <<<`EOD`
       ```
       ```
       ```
       `EOD`;
       

   • 变量解析

     • 简单语法

       当 PHP 解析器遇到一个美元符号（$）时，它会和其它很多解析器一样，去组合尽量多的标识以形成一个合法的变量名。可以用花括号来明确变量名的界线。

       <?php
       $juice = "apple";
       
       echo "He drank some $juice juice.".PHP_EOL;
       // Invalid. "s" is a valid character for a variable name, but the variable is $juice.
       echo "He drank some juice made of $juices.";
       ?>
       

       以上例程会输出：

       He drank some apple juice.
       He drank some juice made of .
       

       类似的array和object属性也可以被解析

       <?php
       $juices = array("apple", "orange", "koolaid1" => "purple");
       
       echo "He drank some $juices[0] juice.".PHP_EOL;
       echo "He drank some $juices[1] juice.".PHP_EOL;
       echo "He drank some juice made of $juice[0]s.".PHP_EOL; // Won't work
       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;
       echo "$people->robert greeted the two $people->smiths."; // Won't work
       ?>
       

     • 花括号语法

       只有$ 紧挨着{时才会被识别

       <?php
       // 显示所有错误
       error_reporting(E_ALL);
       
       $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()}";
       ?>
       

       <?php
       // 显示所有错误
       error_reporting(E_ALL);
       
       class beers {
           const softdrink = 'rootbeer';
           public static $ale = 'ipa';
       }
       
       $rootbeer = 'A & W';
       $ipa = 'Alexander Keith\'s';
       
       // 有效，输出： I'd like an A & W
       echo "I'd like an {${beers::softdrink}}\n";
       
       // 也有效，输出： I'd like an Alexander Keith's
       echo "I'd like an {${beers::$ale}}\n";
       ?>
       

   • 存取和修改字符串中的字符

     • 可以把string当成字符组成的array

       用超出字符串长度的下标写入将会拉长该字符串并以空格填充。非整数类型下标会被转换成整数。非法下标类型会产生一个E_NOTICE 级别错误。用负数下标写入字符串时会产生一个 E_NOTICE 级别错误，用负数下标读取字符串时返回空字符串。写入时只用到了赋值字符串的第一个字符。用空字符串赋值则赋给的值是 NULL 字符。

   • 字符串可以用.点运算符串联起来

   • 转化成字符串

     • （string)或strval()函数
     • TRUE => '1' FALSE => ''
     • Array => "Array" object =>"Object" resource=>"Resource id #1"

   • 字符串转化为数值

     当一个字符串被当作一个数值来取值，其结果和类型如下：

     如果该字符串没有包含 '.'，'e' 或 'E' 并且其数字值在整型的范围之内（由 PHP_INT_MAX 所定义），该字符串将被当成 integer来取值。其它所有情况下都被作为float来取值。

     该字符串的开始部分决定了它的值。如果该字符串以合法的数值开始，则使用该数值。否则其值为 0（零）。合法数值由可选的正负号，后面跟着一个或多个数字（可能有小数点），再跟着可选的指数部分。指数部分由 'e' 或 'E' 后面跟着一个或多个数字构成。

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

5. Array 有序映射--(key, value)

   • 创建

     $array = array("key" => "valude");
     $array = ["key" => "valude"];
     

   • key 为 integer 或 string ，value可以是任意类型。(key 会强制转换)

     • 包含有合法整型值的字符串会被转换为整型。例如键名 "8" 实际会被储存为 8。但是 "08" 则不会强制转换，因为其不是一个合法的十进制数值。
     • 浮点数也会被转换为整型，意味着其小数部分会被舍去。例如键名 8.7 实际会被储存为 8。
     • 布尔值也会被转换成整型。即键名 true 实际会被储存为 1 而键名 false会被储存为 0。
     • Null 会被转换为空字符串，即键名 null 实际会被储存为 ""。
     • 数组和对象不能被用为键名。坚持这么做会导致警告：Illegal offset type。

     <?php
     $array = array(
         1    => "a",
         "1"  => "b",
         1.5  => "c",
         true => "d",
     );
     var_dump($array);  //array(1) { [1]=>string(1) "d"}
     ?>
     

   • 可同时含有int 或 string 键

     $swtching = array(10, //key = 0
                       5 => 6,
                       3 => 7,
                       'a' => 4,
                       11, //key = 6
                       '8' => 2, //key = 8
                       '02' => 77, //key = '02'
                       0 => 12 //overwirtten
     );
     

   • 数组赋值总是值拷贝 => 引用 $arr3 = &$arr1

   • <?php
     // PHP 5
     foreach ($colors as &$color) {
         $color = strtoupper($color);
     }
     unset($color); /* ensure that following writes to
     $color will not modify the last array element */
     
     ?>
     

6. 类型转换

   PHP 的自动类型转换的一个例子是乘法运算符“”。如果任何一个操作数是float，则所有的操作数都被当成float，结果也是float。否则操作数会被解释为integer，结果也是integer。注意这并没有*改变这些操作数本身的类型；改变的仅是这些操作数如何被求值以及表达式本身的类型。

   <?php
   $foo = "1";  // $foo 是字符串 (ASCII 49)
   $foo *= 2;   // $foo 现在是一个整数 (2)
   $foo = $foo * 1.3;  // $foo 现在是一个浮点数 (2.6)
   $foo = 5 * "10 Little Piggies"; // $foo 是整数 (50)
   $foo = 5 * "10 Small Pigs";     // $foo 是整数 (50)
   ?>
   

三、变量

1. 大小写敏感，表述为：[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*

2. 未初始化变量的默认值

   • 布尔类型的变量默认值是 FALSE
   • 整形和浮点型变量默认值是零
   • 字符串型变量（例如用于 echo中）默认值是空字符串
   • 数组变量的默认值是空数组。

3. 预定义变量

   • 超全局变量 — 超全局变量是在全部作用域中始终可用的内置变量
   • $GLOBALS — 引用全局作用域中可用的全部变量
   • $_SERVER — 服务器和执行环境信息
   • $_GET — HTTP GET 变量
   • $_POST — HTTP POST 变量
   • $_FILES — HTTP 文件上传变量
   • $_REQUEST — HTTP Request 变量
   • $_SESSION — Session 变量
   • $_ENV — 环境变量
   • $_COOKIE — HTTP Cookies
   • $php_errormsg— 前一个错误信息
   • $HTTP_RAW_POST_DATA — 原生POST数据
   • $http_response_header — HTTP 响应头
   • $argc— 传递给脚本的参数数目
   • $argv — 传递给脚本的参数数组

4. 变量范围

   • local （不会被外部作用域覆盖，不同于C++)

     <?php
     $a = 1; /* global scope */
     
     function Test()
     {
         echo $a; /* reference to local scope variable */
     }
     
     Test();
     ?>
     

   • global

     <?php
     $a = 1;
     $b = 2;
     function Sum()
     {
         global $a, $b;
         $b = $a + $b;
     
         $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
     }
     Sum();
     echo $b;
     ?>
     

   • static

     <?php
     function test()
     {
         static $a = 0;
         echo $a;
         $a++;
     }
     ?>
     

5. 可变变量

   变量的变量名可以动态的设置和使用。

   <?php
   $a = 'hello';
   $$a = 'world';
   echo "$a ${$a}"; //hello world
   echo "$a $hello";  //hello world
   ?>
   

四、常量

1. 定义define('FOO', 'hello')可在任何地方定义和访问

2. 常量只能包含标量数据(boolean, integer, float, string)。

3. 常量和变量有如下不同：

   • 常量前面没有美元符号（$）；
   • 常量只能用define() 函数定义，而不能通过赋值语句；
   • 常量可以不用理会变量的作用域而在任何地方定义和访问；
   • 常量一旦定义就不能被重新定义或者取消定义；
   • 常量的值只能是标量。

4. 魔术常量

   有八个魔术常量它们的值随着它们在代码中的位置改变而改变。例如__LINE__ 的值就依赖于它在脚本中所处的行来决定。这些特殊的常量不区分大小写，如下：

   • __LINE__ 文件中当前的行号
   • __FILE__ 文件中完整的路径和文件名
   • __DIR__ 文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于 dirname(__FILE__)。除非是根目录，否则目录中名不包括末尾的斜杠。
   • __FUNCTION__ 函数名（区分大小写）
   • __CLASS__类的名称。当用在 trait 方法中时，__CLASS__ 是调用 trait 方法的类的名字。
   • __TRAIL__Trait的名称。返回 trait 被定义时的名字（区分大小写）。
   • __METHOD__类的方法名称。
   • __NAMESPACE__当前命名空间的名称（区分大小写）。

五、表达式

1. 附值语句本身的值
2. 前、后递增和递减
3. 三元条件运算符

六、运算符

1. 错误控制运算符：@。当将其放置在一个 PHP 表达式之前，该表达式可能产生的任何错误信息都被忽略掉。

2. 执行运算符：反引号（``）。注意这不是单引号！PHP 将尝试将反引号中的内容作为 shell 命令来执行，并将其输出信息返回（即，可以赋给一个变量而不是简单地丢弃到标准输出）。使用反引号运算符的效果与函数 shell_exec() 相同。

   <?php
   $output = `ls -al`;
   echo "<pre>$output</pre>";
   ?>
   

3. 字符串运算符

   .	串接	$txt1 = "Hello" $txt2 = $txt1 . " world!"
   .=	串接赋值	$txt1 = "Hello" $txt1 .= " world!"

4. 比较运算符

   ==	等于
   ===	全等	如果 $x 等于 $y，且它们类型相同，则返回 true。
   ！=	不等于
   <>	不等于
   !===	不全等	如果 $x 不等于 $y，或它们类型不相同，则返回 true。

5. 数组运算符

   +	联合	$x 和 $y 的联合（但不覆盖重复的键）
   ===	相等	如果 $x 和 $y 拥有相同的键/值对，则返回 true。
   ===	全等	如果 $x 和 $y 拥有相同的键/值对，且顺序相同类型相同，则返回 true。
   ！=	不相等	如果 $x 不等于 $y，则返回 true。
   <>	不相等	如果 $x 不等于 $y，则返回 true。
   !==	不全等	如果 $x 与 $y 完全不同，则返回 true。

   + 运算符把右边的数组元素附加到左边的数组后面，两个数组中都有的键名，则只用左边数组中的，右边的被忽略。

   <?php
   $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
   $a = array("apple", "banana");
   $b = array(1 => "banana", "0" => "apple");
   
   var_dump($a == $b); // bool(true)
   var_dump($a === $b); // bool(false)
   ?>
   

6. 类型运算符

   instanceof 用于确定一个 PHP 变量是否属于某一类 class的实例。也可用来确定一个变量是不是继承自某一父类的子类的实例。instanceof也可用于确定一个变量是不是实现了某个接口的对象的实例。

   <?php
   interface MyInterface
   {
   }
   
   class MyClass implements MyInterface
   {
   }
   
   $a = new MyClass;
   
   var_dump($a instanceof MyClass);  //bool(true)
   var_dump($a instanceof MyInterface);  //bool(true)
   ?>
   

七、流程控制

1. elseif

   <?php
   if ($a > $b) {
       echo "a is bigger than b";
   } elseif ($a == $b) {
       echo "a is equal to b";
   } else {
       echo "a is smaller than b";
   }
   ?>
   

2. switch

   <?php
   if ($i == 0) {
       echo "i equals 0";
   } elseif ($i == 1) {
       echo "i equals 1";
   } elseif ($i == 2) {
       echo "i equals 2";
   }
   
   switch ($i) {
       case 0:
           echo "i equals 0";
           break;
       case 1:
           echo "i equals 1";
           break;
       case 2:
           echo "i equals 2";
           break;
   }
   ?>
   

3. foreach

   foreach (array_expression as $value)
       statement
   foreach (array_expression as $key => $value)
       statement
   

4. require

   require 和 include几乎完全一样，除了处理失败的方式不同之外。require 在出错时产生 E_COMPILE_ERROR 级别的错误。换句话说将导致脚本中止而 include只产生警告（E_WARNING），脚本会继续运行

5. require_once

   require_once 语句和 require 语句完全相同，唯一区别是 PHP 会检查该文件是否已经被包含过，如果是则不会再次包含。