一、基本语法

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

二、类型

四种标量类型：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;

}

?>

Boolean
- 不区分大小写
- 强制转换 bool($var)
- 当转换为bool时，以下值为FALSE:
  
  整型值0
  
  浮点型0.0
  
  空字符串，以及字符串“0”
  
  空数组
  
  NULL（包括未被赋值的变量）
  
  从空标签生成的XML对象
- 任何资源和NAN被认为是TRUE
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()
  - 资源转为整数时，结果是资源分配的资源号
  - 浮点转为整数时，向下取整，如果浮点数超出了整数范围，则结果为未定义。
float
- 浮点比较 abs($a - $b) < $epsilon
- 某些数学运算会产生一个由常量 NAN 所代表的结果。此结果代表着一个在浮点数运算中未定义或不可表述的值。任何拿此值与其它任何值（除了 TRUE）进行的松散或严格比较的结果都是 FALSE。
  
  由于 NAN 代表着任何不同值，不应拿 NAN 去和其它值进行比较，包括其自身，应该用is_nan()来检查。

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)

?>
```

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 */

?>

类型转换

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)

?>
```

三、变量

大小写敏感，表述为：[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
未初始化变量的默认值
- 布尔类型的变量默认值是 FALSE
- 整形和浮点型变量默认值是零
- 字符串型变量（例如用于 echo中）默认值是空字符串
- 数组变量的默认值是空数组。
预定义变量
- 超全局变量 — 超全局变量是在全部作用域中始终可用的内置变量
- $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 — 传递给脚本的参数数组

变量范围

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++;

}

?>

可变变量

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

<?php

$a = 'hello';

$$a = 'world';

echo "$a ${$a}"; //hello world

echo "$a $hello";  //hello world

?>

四、常量

定义define('FOO', 'hello')可在任何地方定义和访问
常量只能包含标量数据(boolean, integer, float, string)。
常量和变量有如下不同：
- 常量前面没有美元符号（$）；
- 常量只能用define() 函数定义，而不能通过赋值语句；
- 常量可以不用理会变量的作用域而在任何地方定义和访问；
- 常量一旦定义就不能被重新定义或者取消定义；
- 常量的值只能是标量。
魔术常量

有八个魔术常量它们的值随着它们在代码中的位置改变而改变。例如__LINE__ 的值就依赖于它在脚本中所处的行来决定。这些特殊的常量不区分大小写，如下：
- __LINE__ 文件中当前的行号
- __FILE__ 文件中完整的路径和文件名
- __DIR__ 文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于 dirname(__FILE__)。除非是根目录，否则目录中名不包括末尾的斜杠。
- __FUNCTION__ 函数名（区分大小写）
- __CLASS__类的名称。当用在 trait 方法中时，__CLASS__ 是调用 trait 方法的类的名字。
- __TRAIL__Trait的名称。返回 trait 被定义时的名字（区分大小写）。
- __METHOD__类的方法名称。
- __NAMESPACE__当前命名空间的名称（区分大小写）。

五、表达式

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

六、运算符

错误控制运算符：@。当将其放置在一个 PHP 表达式之前，该表达式可能产生的任何错误信息都被忽略掉。
执行运算符：反引号（``）。注意这不是单引号！PHP 将尝试将反引号中的内容作为 shell 命令来执行，并将其输出信息返回（即，可以赋给一个变量而不是简单地丢弃到标准输出）。使用反引号运算符的效果与函数 shell_exec() 相同。
```
<?php

$output = `ls -al`;

echo "<pre>$output</pre>";

?>
```
字符串运算符

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

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

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

比较运算符

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

数组运算符

+	联合	$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)

?>

类型运算符

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)

?>
```

七、流程控制

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

}

?>

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;

}

?>

foreach

foreach (array_expression as $value)

    statement

foreach (array_expression as $key => $value)

    statement

require

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

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

巴特西

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