PHP快速教程

1.本文主要针对有C语言（或其他编程语言）基础的人快速学习PHP的，所以不会对一些基础知识作过多解释，比如“=”是赋值不是等于。
2.本文适合已学过一门编程语言，想要快速入门PHP的人。
3.基本上看完本文即可入门，可以动手实践或是进阶。

简介

PHP是Hypertext Preprocessor（超文本预处理器）的递归缩写。
这是一种特别适合网页开发的服务器端脚本语言。
它是运行在服务器上的脚本，因此不能直接用浏览器打开.php脚本，需要服务器解析后发送给浏览器才能查看网页内容。因此要在浏览器里输入地址访问.php文件，然后服务器解析后发送给浏览器解析后的Html，才能查看网页内容。
如果要在自己电脑上运行.php文件，需要先搭建配置服务器环境，初学者可以使用集成服务器组件，比如XAMPP，下载地址：https://www.apachefriends.org/zh_cn/index.html
这部分不作过多介绍，大家可以去百度。

语法

标记

PHP可以内嵌在Html文档中的任何位置。
PHP 脚本以<?php 开头，以 ?> 结尾。
例：

<!DOCTYPE html>

<html>

<body>

<h1>我的第一张 PHP 页面</h1>

<?php

echo 'Hello World!';  // 输出 Hello World！

?>

</body>

</html>

注释

PHP支持C、C++、Perl三种风格的注释：

<?php

    echo 'This is a test'; // This is a one-line c++ style comment

    /* This is a multi line comment

       yet another line of comment */

    echo 'This is yet another test';

    echo 'One Final Test'; # This is a one-line shell-style comment

?>

大小写敏感

PHP只有变量大小写敏感。
所有用户定义的函数、类和关键词（例如 if、else、echo 等等）都对大小写不敏感。

变量

PHP变量以$符号开头。
PHP是弱类型语言，无需声明类型。
PHP变量名称大小写敏感。

作用域

函数之外声明的变量拥有 Global 作用域，只能在函数以外进行访问。
函数内部声明的变量拥有 LOCAL 作用域，只能在函数内部进行访问。
例：

<?php

$x=5; // 全局作用域

function myTest() {

  $y=10; // 局部作用域

  echo "<p>测试函数内部的变量：</p>";

  echo "变量 x 是：$x";    // 输出 变量x是：

  echo "<br>";

  echo "变量 y 是：$y";    // 输出 变量y是：10

} 

myTest();

echo "<p>测试函数之外的变量：</p>";

echo "变量 x 是：$x";      // 输出 变量x是：5

echo "<br>";

echo "变量 y 是：$y";      // 输出 变量y是：

?>

在函数内访问Global变量使用global关键字。
例：

<?php

$x=5;

$y=10;

function myTest() {

  global $x,$y;

  $y=$x+$y;

}

myTest();

echo $y; // 输出 15

?>

也可以使用$GLOBALS超全局变量访问全局变量：
例：

<?php

$x=5;

$y=10;

function myTest() {

  $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];

} 

myTest();

echo $y; // 输出 15

?>

static关键字声明静态变量。
当函数完成/执行后，不会删除静态变量。

超全局变量

超全局变量在 PHP 4.1.0 中引入，是在全部作用域中始终可用的内置变量。在函数或方法中无需执行 global $variable; 就可以访问它们。

$GLOBALS— 引用全局作用域中可用的全部变量

$_SERVER— 服务器和执行环境信息

$_REQUEST— HTTP Request 变量

$_POST— HTTP POST 变量

$_GET— HTTP GET 变量

$_FILES— HTTP 文件上传变量

$_ENV— 环境变量

$_COOKIE— HTTP Cookies

$_SESSION— Session 变量

官方文档

可变变量

可变变量是一种独特的变量，它允许动态改变一个变量名称。其工作原理是，该变量的名称由另外一个变量的值来确定。
例：

<?php

$a = 'hello';

$$a = 'world';

?>

以上代码定义了两个变量，$a='hello',$hello='world'。
官方文档

输出

在 PHP 中，有两种基本的输出方法：echo 和 print。

echo - 能够输出一个以上的字符串
print - 只能输出一个字符串，并始终返回 1
echo 比 print 稍快，因为它不返回任何值

echo & print

echo 是一个语言结构，有无括号均可使用：echo 或 echo()。
print 也是语言结构，有无括号均可使用：print 或 print()。

数据类型

字符串、整数、浮点数、布尔、数组、对象、NULL。

字符串

PHP字符串可以用单引号也可以用双引号。
单引号和双引号的区别是：双引号会解析里面的变量和转义字符，而单引号不会，单引号里的字符仅仅只有\（反斜杠）和'（单引号本身）需要转义：



$str='Hello';

echo 'I\'ll say $str\n';

// 输出 I'll say $str\n

echo "I\'ll say $str\n";

// 输出 I'll say Hello 

?>

建议使用单引号表示字符串，除非需要解析里面的变量。

heredoc & nowdoc
需要表示特别长的字符串的时候，可以使用heredoc和nowdoc语法，heredoc和nowdoc语法的区别相当于双引号和单引号的区别。



/*heredoc 语法

 1. 由<<<标记名......标记名包围组成

 2. 开始标记和结束标记名称要一致

 3. 结束标记必须顶格写

 4. 主体部分，会自动解析变量和转义字符

 5. 但是函数、操作符和引号则不会被解析

*/

$str = 'hello world';

echo <<<HTML
    <html>
    <head>
    <title>Hello World</title>
    </head>
    <body>
        <p>$str</p>
    </body>
    </html>     
HTML;

?>

<?php

/*nowdoc 语法

 1. 区别就是开始标记名要加单引号，但结束标记名不要加单引号

 2. 主体部分的变量和转义字符不会被解析

*/

echo <<<'HTML'

    <html>

    <head>

    <title>Hello World</title>

    </head>

    <body>

        <p>hello world</p>

    </body>

    </html>

HTML;

?>

heredoc和nowdoc特别适合输出很长的HTML文档，比直接以字符串的形式输出要容易阅读得多。

数组

PHP数组其实一组键值对(key/value)。
创建数组：

$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");

或

$age['Peter']="35";

$age['Ben']="37";

$age['Joe']="43";

也可以不指定键值（key），那么默认的索引就是从0开始的有序数字：

$cars=array("Volvo","BMW","SAAB",6=>"Audi","Daewoo");

相当于：

$cars[0]="Volvo";

$cars[1]="BMW";

$cars[2]="SAAB";

$cars[6]="Audi";

$cars[7]="Daewoo";

遍历数组：

<?php

$age=array("Bill"=>"35","Steve"=>"37","Peter"=>"43");

foreach($age as $x=>$x_value) {

  echo "Key=" . $x . ", Value=" . $x_value;

  echo "<br>";

}

?>

当然也可以用for循环，count()返回数组元素个数：

<?php

$cars = array("Volvo", "BMW", "Toyota");

$arrlength = count($cars);

for($x = 0; $x < $arrlength; $x++) {

    echo $cars[$x];

    echo "<br>";

}

?>

常量

常量是一个固定值的标识符。
有效的常量名以字符或下划线开头（常量名称前面没有 $ 符号）。
常量默认是大小写敏感的。
通常，常量全部使用大写字母。
与变量不同，常量贯穿整个脚本是自动全局的。
使用 define() 函数设置常量：

首个参数定义常量的名称
第二个参数定义常量的值
可选的第三个参数规定常量名是否对大小写敏感。默认是 false，大小写敏感。
例：

<?php

define("FOO","something");

echo FOO;

?>

运算符

加减乘除取余，自加自减和C语言一样。
连接两个字符串用“.”。

$str='and';

$str='something'.$str;  // somethingand

比较运算符

和C语言基本相同，不同之处：

== 是相等，值相等类型可以不同，比如'1'==1，为真。
===是全等，不仅值相等，类型也要相同，比如'1'===1，为假。
!=和<>都是不等于。
!==不全等，类型不同就是不全等。
$a <=> $b，$a小于$b时，等于-1，等于$b时，等于0，大于$b时，大于0. 这是PHP７加入的运算符。



// Integers

echo 1 <=> 1; // 0

echo 1 <=> 2; // -1

echo 2 <=> 1; // 1

// Floats

echo 1.5 <=> 1.5; // 0

echo 1.5 <=> 2.5; // -1

echo 2.5 <=> 1.5; // 1

// Strings

echo "a" <=> "a"; // 0

echo "a" <=> "b"; // -1

echo "b" <=> "a"; // 1

echo "a" <=> "aa"; // -1

echo "zz" <=> "aa"; // 1

// Arrays

echo [] <=> []; // 0

echo [1, 2, 3] <=> [1, 2, 3]; // 0

echo [1, 2, 3] <=> []; // 1

echo [1, 2, 3] <=> [1, 2, 1]; // 1

echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects

$a = (object) ["a" => "b"];

$b = (object) ["a" => "b"];

echo $a <=> $b; // 0

$a = (object) ["a" => "b"];

$b = (object) ["a" => "c"];

echo $a <=> $b; // -1

$a = (object) ["a" => "c"];

$b = (object) ["a" => "b"];

echo $a <=> $b; // 1

// only values are compared

$a = (object) ["a" => "b"];

$b = (object) ["b" => "b"];

echo $a <=> $b; // 1

?>

逻辑运算符

基本和C语言一样，不同之处：

多了xor异或。
$x xor $y,如果 $x 和 $y 有且仅有一个为 true，则返回 true。

流程控制

for循环
while循环
do while循环
switch开关
if else条件语句
和C语言一样，不同的是elseif连起来写而不是写作else if

函数

和弱类型语言JavaScript语法差不多，以function关键字开头，执行可以在定义的前面：

function function_name(){

// TODO:

}

参数可以有默认值



function setHeight($minheight=50) {

  echo "The height is : $minheight ";

}

setHeight(350);

setHeight(); // 将使用默认值 50

setHeight(135);

setHeight(80);

?>

参数可以使用引用传递，从而形参和实参指向同一块内存：



$x=1;

$y=2;

function exchange(&$x,&$y){

    $temp=$x;

    $x=$y;

    $y=$temp;

}

exchange($x,$y);

// $x,$y的值被交换了

// 调用函数的时候参数前面不要加&

?>

函数可以返回引用，如果要返回引用，函数声明时要加&，将返回的引用赋值给一个变量时也要加&：



function &test()

{

    static $b=0;//申明一个静态变量

    $b=$b+1;

    echo $b;

    return $b;

}

$a=test();//这条语句会输出　$b的值　为１

$a=5;

$a=test();//这条语句会输出　$b的值　为2

$a=&test();//这条语句会输出　$b的值　为3

$a=5;

$a=test();//这条语句会输出　$b的值　为6

?>

文件包含

require和include可以将 PHP 文件的内容插入另一个 PHP 文件（在服务器执行它之前）。
包含可用于创建可在多个页面重复使用的函数、页眉、页脚或元素。
语法，加上文件名即可，或者加上括号：

require 'file.php';

require ('file.txt');

include 'file.txt';

include ('file.php');

区别：

错误处理不同，require 会生成致命错误（E_COMPILE_ERROR）并停止脚本，include 只生成警告（E_WARNING），并且脚本会继续
使用弹性不同，require通常放在PHP程序的最前面，PHP程序在执行前会先读入require所指定引入的档案，使它变成程序网页的一部分；include通常放在流程控制处理中，PHP程序读到include的档案时，才将它读进来。

require_once()和include_once()

和require、include的区别就是：如果该文件中的代码已经被包括了，则不会再次包括。

面向对象



class phpClass {

  var $var1;

  var $var2 = "constant string";

  function myfunc ($arg1, $arg2) {

     [..]

  }

  [..]

}

?>

类使用 class 关键字后加上类名定义。
类名后的一对大括号({})内可以定义变量和方法。
类的变量使用 var 来声明, 变量也可以初始化值。
函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。
栗子：



/**

 * Define MyClass

 */

class MyClass

{

    // 声明一个公有的构造函数

    public function __construct() { }

    // 声明一个公有的方法

    public function MyPublic() { }

    // 声明一个受保护的方法

    protected function MyProtected() { }

    // 声明一个私有的方法

    private function MyPrivate() { }

    // 此方法为公有

    function Foo()

    {

        $this->MyPublic();

        $this->MyProtected();

        $this->MyPrivate();

    }

}

$myclass = new MyClass;

$myclass->MyPublic(); // 这行能被正常执行

$myclass->MyProtected(); // 这行会产生一个致命错误

$myclass->MyPrivate(); // 这行会产生一个致命错误

$myclass->Foo(); // 公有，受保护，私有都可以执行

/**

 * Define MyClass2

 */

class MyClass2 extends MyClass

{

    // 此方法为公有

    function Foo2()

    {

        $this->MyPublic();

        $this->MyProtected();

        $this->MyPrivate(); // 这行会产生一个致命错误

    }

}

$myclass2 = new MyClass2;

$myclass2->MyPublic(); // 这行能被正常执行

$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行

class Bar

{

    public function test() {

        $this->testPrivate();

        $this->testPublic();

    }

    public function testPublic() {

        echo "Bar::testPublic\n";

    }

    private function testPrivate() {

        echo "Bar::testPrivate\n";

    }

}

class Foo extends Bar

{

    public function testPublic() {

        echo "Foo::testPublic\n";

    }

    private function testPrivate() {

        echo "Foo::testPrivate\n";

    }

}

$myFoo = new foo();

$myFoo->test(); // Bar::testPrivate

                // Foo::testPublic

?>

构造函数是名为__construct的函数，它有两个下划线。
析构函数是名为__destruct的函数，它有两个下划线。
默认访问权限是public。
使用->访问类的成员。
parent关键字表示父类。
final关键字表示该函数不能重载。
static修饰的方法和属性可以不实例化就访问。
abstract关键字修饰抽象类，抽象类不能实例化。

实战与提高

这部分以后再写吧。
读到这里语法基本就已掌握，可以进行一些实战了。