一、基本语法

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

比较运算符

==	等于
===	全等	如果 $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入门笔记--基础语法一

一、基本语法

二、类型

三、变量

四、常量

五、表达式

六、运算符

七、流程控制

请发表评论

全部评论

上一篇：

下一篇：

【视频】详解小程序wx.requestpayment用法

bradtraversy/iweather: Ionic 3 mobile we

joaomh/curso-de-matlab

断牙刷新位置时间（断牙属性及刷新位置介绍

rugk/mastodon-simplified-federation: Sim

GitbookIO/gitbook:

takuoka/TKSubmitTransition: Animated UIB

juleswhite/mobile-cloud-asgn1

kyamagu/matlab-json: Use official API: h

墙壁眼睛膝盖

sevenjay/cpp-markdown: Cpp-Markdown is a

关于我们

产品与服务

解决方案

139-2527-9053