<?php
echo "Hello World!"; //PHP 中的每个代码行都必须以分号结束。分号是一种分隔符，用于把指令集区分开来。
?>
1.PHP 脚本在服务器上执行，然后将纯 HTML 结果发送回浏览器。
2.PHP 脚本可以放在文档中的任何位置。
3.PHP 脚本以 <?php 开始，以 ?> 结束：
4.PHP 文件的默认文件扩展名是 ".php"。
5.PHP 文件通常包含 HTML 标签和一些 PHP 脚本代码。
6.注释：
// 这是 PHP 单行注释
/
这是
PHP 多行
注释 /
复制代码
<?php
$x=5; // 全局变量
define("GREETING","欢迎加入PHP");//定义常量GREETING，区分大小写
const constant = '常量值';//在定义和使用常量的时候不需要使用 $ 符号。
//代码效果参考：http://www.zidongmutanji.com/zsjx/256413.html
function myTest() {
$y=10; // 局部变量
echo "<p>测试函数内变量:<p>";
echo "变量 x 为: $x";
}
$y=10;
function myTest01()
{
global $x,$y;
$y=$x+$y;//等效：$GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];
}
myTest01(); //调用后,$y赋值成了15;
echo "变量 y 为: $y"; //注意在php7环境下，输出的$y的值却是$y=10，而不是15，此时global变量只能直接引用原有的简单变量$y。
function myTest02()
static $x=0;//当static存在时,执行第二次myTest02()会保留改变的$x进行计算,即:0,1;否则为:0,0
echo $x;//注意:该变量$x，仍然是函数的局部变量。
$x++;
myTest02();//0
myTest02();//？
?>
PHP变量是什么？
1、在PHP中变量是用于储存信息的容器，类似于数学中的集合。
2、赋值方法与数学中的代数相类似。
变量是用于存储值的，我们命令服务器去干活的时候，往往需要产生一些数据，需要临时性存放起来，方便取用。
我们也可以理解为，变量就像一个购物袋，我们可以用来装苹果、榴莲（当然也可以用来装玫瑰），
需要注意的是，一般情况下一个变量只能装一个（不要太贪心）值，除非是复合变量（后面变量类型时会介绍），
当我们放进去一个苹果后，再放进榴莲的时候，苹果就被替换掉，再放入香蕉，那么榴莲就被替换了。
3.声明：PHP 没有声明变量的命令。变量在您第一次赋值给它的时候被创建：
我们注意到，不必向 PHP 声明该变量的数据类型。
在强类型的编程语言中，我们必须在使用变量前先声明（定义）变量的类型和名称。
4.局部和全局作用域：访问机制，在 PHP 函数内部声明的变量是局部变量，仅能在函数内部访问：
但可以使用global 关键字用于函数内访问全局变量
PHP 将所有全局变量存储在一个名为 $GLOBALS[index] 的数组中。 index 保存变量的名称。这个数组可以在函数内部访问，也可以直接用来更新全局变量。
5.Static 作用域
当一个函数完成时，它的所有变量通常都会被删除。然而，有时候您希望某个局部变量不要被删除。
要做到这一点，请在您第一次声明变量时使用 static 关键字：
6.超级全局变量（superglobals）
$GLOBALS //*组合数组：变量的名字就是数组的键。例如：
$x = 75;
$y = 25;
function addition() {
$GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y'];
}
addition(); //$z = 100
$_SERVER //* Web服务器创建:包含头部(header)、路径(path)、以及脚本位置(script locations)等【24个】重要元素信息的数组。
echo $_SERVER['PHP_SELF'];
echo $_SERVER['SERVER_NAME'];
echo $_SERVER['HTTP_HOST'];
echo $_SERVER['HTTP_REFERER'];
echo $_SERVER['HTTP_USER_AGENT'];
echo $_SERVER['SCRIPT_NAME'];
$_REQUEST //*收集HTML表单提交的数据,method="post"
$_POST
$_GET
$_FILES
$_ENV
$_COOKIE
$_SESSION
有八个【魔术常量】它们的值随着它们在代码中的位置改变而改变。特殊的常量不区分大小写
1【LINE】.文件中的当前行号：echo '这是第 “ ' . LINE . ' ” 行';
2【FILE】文件的完整路径和文件名：echo '该文件位于 “ ' . FILE . ' ” ';
3【DIR】.文件所在的目录：echo '该文件位于 “ ' . DIR . ' ” ';
4【FUNCTION】返回该函数被定义时的名字（区分大小写）：echo '函数名为：' . FUNCTION ;
function test() {
echo '函数名为：' . METHOD ;//对比：该方法被定义时的名字 【METHOD】
5【CLASS】.返回该类被定义时的名字
class test {
function _print() {
echo '类名为：' . CLASS . "
";//返回名称
echo '函数名为：' . FUNCTION ;
$t = new test();
$t->_print();
6【trait】.代码复用
class Base {
public function sayHello() {//初始化
echo 'Hello ';
trait SayWorld { //代码复用
public function sayHello() {
parent::sayHello();
echo 'World!';
class MyHelloWorld extends Base {//函数继承
use SayWorld;
$o = new MyHelloWorld();
$o->sayHello();//Hello World! 当前类中的方法会覆盖 trait 方法，而 trait 方法又覆盖了基类中的方法。
7【NAMESPACE】命名空间：在编译时定义的名字
namespace MyProject;//最明确的目的就是解决重名问题
echo '命名空间为："', NAMESPACE, '"'; // 输出 "MyProject"
从广义上来说，命名空间是一种封装事物的方法。在很多地方都可以见到这种抽象概念。
例如，在操作系统中目录用来将相关文件分组，对于目录中的文件来说，它就扮演了命名空间的角色。
具体举个例子，文件 foo.txt 可以同时在目录/home/greg 和 /home/other 中存在，但在同一个目录中不能存在两个 foo.txt 文件。
另外，在目录 /home/greg 外访问 foo.txt 文件时，我们必须将目录名以及目录分隔符放在文件名之前得到 /home/greg/foo.txt。
这个原理应用到程序设计领域就是命名空间的概念。
declare(encoding='UTF-8'); //定义多个命名空间和【不包含】在命名空间中的代码
//**命名空间前出现了“
namespace MyProject\Sub\Level; //声明分层次的单个命名空间
警告：如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。
<?php
echo "
PHP is fun!
";print "Hello world!
";
print "I'm about to learn PHP!
";
echo "This", " string", " was", " made", " with multiple parameters.";
$txt1="Learn PHP";
$txt2="www.php.cn";
$cars=array("Volvo","BMW","Toyota");
echo $txt1;
print "
";
print "Study PHP at $txt2";
echo "My car is a {$cars[0]}";
相同点：
语言结构：使用的时候可以不用加括号，也可以加上括号： echo 或 echo()。
不同点：
echo - 可以输出一个或多个字符串，echo 输出的速度比 print 快， echo 没有返回值
print - 只允许输出一个字符串，返回值总为 1
//字符串:并置运算符 (.) 用于把两个字符串值连接起来。字符串函数包括:返回字符串的长度:strlen();返回第一个匹配的字符位置:strpos(),未找到返回 FALSE
$txt1 = "a5678";
$txt2 = "b4321";
var_dump($x);
echo $txt1 . " " . $txt2; "
"; //a5678b4321
echo strlen("Hello world!"); //12
echo strpos("Hello world!","world"); //6,从0开始计算,不是7
//整数
$x = -345; // 负数:int(-345)
echo "
";
$x = 0x8C; // 十六进制数:int(140)
echo "
";
$x = 047; // 八进制数:int(39)
//浮点数
$x = 10.365;
var_dump($x);//float(10.365)
$x = 2.4e3;
var_dump($x);//float(2400)
$x = 8E-5;
var_dump($x);//float(8.0E-5)
//布尔值
$x=true;
$y=false;
//数组
var_dump($cars);//array(3) { [0]=> string(5) "Volvo"....[2]=> string(6) "Toyota" }
echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . ".";
//【对象】:在 PHP 中，对象必须必须使用class关键字声明。类是可以包含属性和方法的结构。
class Car {
var $color;
function Car($color="green") {//设置属性为color（$this指代自己）:$this->color
$this->color = $color;
}
function what_color() {//设置属性的值:$color
return $this->color;
function print_vars($obj) {
foreach (get_object_vars($obj) as $prop => $val) {//代码效果参考： http://www.zidongmutanji.com/bxxx/344248.html
echo "$prop = $val";
}
//声明对象
$herbie = new Car("white");
//调用对象的的方法
print_vars($herbie);
//常量
define("GREETING", "欢迎访问 php.cn", true);// 设为true，不区分大小写的常量名
echo greeting; // 不设置true,输出的是自身,即字符串"greeting"
echo GREETING; // 输出 "欢迎访问 php.cn"
var_dump() 函数返回变量：数据类型（长度）和值
以上实例中PHP关键字this就是指向【当前对象实例的指针】，不指向任何其他对象或类。
设置常量，使用 define() 函数，常量在定义后，默认是全局变量，可以在整个运行的脚本的任何地方使用。
php数据类型包括：没有Number
1.String（字符串）,
2.Integer（整型）,
3.Float（浮点型）,
4.Boolean（布尔型）,
5.Array（数组）,
6.Object（对象）,
7.NULL（空值）。
$t=date("H");
if ($t<"10"){
echo "Have a good morning!";
}elseif ($t<"20"){
echo "Have a good day!";
}else{
echo "Have a good night!";
$favcolor="red";
switch ($favcolor){
case "red":
echo "你喜欢的颜色是红色!";
break;
case "blue":
echo "你喜欢的颜色是蓝色!";
case "green":
echo "你喜欢的颜色是绿色!";
default:
echo "你喜欢的颜色不是 红, 蓝, 或绿色!";
判断语句：
if...else...
if (条件){
条件成立时执行的代码;
}else{
条件不成立时执行的代码;
switch 语句 - 在若干条件之一成立时执行一个代码块
$x=10;
$y=6;
echo ($x + $y); // 输出16
echo ($x - $y); // 输出4
echo ($x * $y); // 输出60
echo ($x / $y); // 输出1.6666666666667
echo ($x % $y); // 输出4：模（除法的余数)
echo (-$y); // -6,取反
echo ($x . " " . $y);; // 输出"106",拼接后变成字符串
echo ++$x; // 输出11,预递增
$y=10;
echo $y++; // 输出10,后递增,不输出递增后的结果,类似for循环
$z=5;
echo --$z; // 输出4,预递减
$i=5;
echo $i--; // 输出5,后递减，不输出递减后的结果
$x=100;
$y="100";
var_dump($x == $y);//等于
var_dump($x === $y);//恒等于
var_dump($x != $y);//不等于
var_dump($x !== $y);//不恒等于
$a=50;
$b=90;
var_dump($a >= $b);//false
var_dump($a < $b);//true
$x = array("a" => "red", "b" => "green");
$y = array("c" => "blue", "d" => "yellow");
$z = $x + $y; // $x 和 $y 数组合并
三元运算：(expr1) ? (expr2) : (expr3)
PHP7+ 支持组合比较符（运算符），实例如下：
// 整型：-1，0，1
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// 浮点型：-1，0，1
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// 字符串：-1，0，1
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
//1.数组取值与拼接(英文句号.)
$cars=array("Volvo","BMW","Toyota");//创建普通数组
//2.数组长度:3
echo count($cars);
//3.数组遍历
$arrlength=count($cars);
for($x=0;$x<$arrlength;$x++){
echo $cars[$x];//"Volvo" ...
echo "
";
//4.遍历关联数组
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");////创建关联数组
foreach($age as $x=>$x_value){
echo "Key=" . $x . ", Value=" . $x_value;//Key=Peter, Value=35
// $age['Peter']="35";
// $age['Ben']="37";
// $age['Joe']="43";
//多维数组
$sites = array (
);
print("<pre>"); // 格式化输出数组
print_r($sites);
print("</pre>");
echo $sites['php'][0] . '地址为：' . $sites['php'][1];
//5.数组函数:排序
sort($cars);//"BMW","Toyota"，"Volvo"
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43"，);
ksort($age);//根据key升序:"Ben"=>"37","Joe"=>"43","Peter"=>"35",
echo "Key=" . $x . ", Value=" . $x_value;
echo "<br />";
PHP中数组的key可以是字符串（js数组的key均指下标：数字），而values可以是任意类型。
//多维数组输出格式：单箭头->指代方法；双箭头=>指代取值key，如Array[0][php]
Array(
[php] => Array(
//函数：排序
sort() - 对数组进行【升序】排列
asort() - 根据关联数组的【值】，对数组进行升序排列
ksort() - 根据关联数组的【键】，对数组进行升序排列
rsort() - 对数组进行【降序】排列
arsort() - 根据关联数组的【值】，对数组进行降序排列
krsort() - 根据关联数组的【键】，对数组进行降序排列
//【函数原理】：循环、遍历，PHP提供了超过 1000 个内建的函数
1.函数的名称应该提示出它的功能
2.函数名称以字母或下划线开头（不能以数字开头）
3.为了给函数添加更多的功能，我们可以添加参数。参数类似变量。
4.参数就在函数名称后面有一个括号内指定。
5.如需让函数返回一个值，请使用 return 语句。
while - 只要指定的条件成立，则循环执行代码块
$i=1;
while($i<=5){
echo "The number is " . $i . "
";//1,2,3,4,5
$i++;
do...while - 首先执行一次代码块，然后在指定的条件成立时重复这个循环
do{
echo "The number is " . $i . "
";//2,3,4,5,6
while ($i<=5);
for - 循环执行代码块指定的次数
for (初始值; 条件; 增量){
要执行的代码;
foreach - 根据数组中每个元素来循环代码块
每进行一次循环，当前数组元素的值就会被赋值给 $value 变量（数组指针会逐一地移动）
在进行下一次循环时，您将看到数组中的下一个值。
foreach ($array as $value){
要执行代码;
$x=array("one","two","three");
foreach ($x as $value){
echo $value . "
";//"one","two","three"
namespace Foo\Bar\subnamespace; // 命名空间唯一
const FOO = 1;
function foo() {
class foo{
static function staticmethod() {}
/* 非限定名称 */
foo(); // 解析为 Foo\Bar\foo resolves to function Foo\Bar\foo
foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod。resolves to class Foo\Bar\foo, method staticmethod
echo FOO; // resolves to constant Foo\Bar\FOO
/ 限定名称 /
subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,
// 以及类的方法 staticmethod
echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO
/ 完全限定名称 /
\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO
echo '"', NAMESPACE, '"'; // 输出 "Foo\Bar\subnamespace"
//注意:在访问系统内部或不包含在命名空间中的类名称时，必须使用完全限定名称
namespace A\B\C;
class Exception extends \Exception {}
$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象
$c = new ArrayObject; // 【致命错误】, 找不到 A\B\C\ArrayObject 类//代码效果参考：http://www.zidongmutanji.com/bxxx/376376.html
class Site {
/* 成员变量 */
var $url;
var $title;
/* 构造函数 */
function __construct( $par1, $par2 ) {
$this->url = $par1;
$this->title = $par2;
}
/* 成员函数1 */
function setUrl($par){
$this->url = $par;
/* 成员函数2 */
function getUrl(){
echo $this->url . PHP_EOL;
/* 成员函数3 */
function setTitle($par){
$this->title = $par;
/* 成员函数4：方法重写可以覆盖之前的设置 */
function getTitle(){
echo $this->title . PHP_EOL;
/* 实例化对象：php+taobao+google */
$php = new Site('www.php.cn', 'php中文网');
$taobao = new Site('www.taobao.com', '淘宝');
$google = new Site('www.google.com', 'Google 搜索');
// 调用成员函数，获取标题和URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();
//调用成员函数，设置标题和URL
$php->getUrl();
$taobao->getUrl();
$google->getUrl();
什么是PHP面向对象?
在面向对象的程序设计（英语：Object-oriented programming，缩写：OOP）中，
对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象。
在现实世界里我们所面对的事情都是对象，如计算机、电视机、自行车等。
【对象的主要三个特性】：
对象的行为：可以对 对象施加那些操作，开灯，关灯就是行为。
对象的形态：当施加那些方法是对象如何响应，颜色，尺寸，外型。
对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。
【类】 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
1.类使用 class 关键字后加上类名定义。
2.类名后的一对大括号({})内可以定义变量和方法。
3.类的变量使用 var 来声明, 变量也可以初始化值。
4.函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。
5.定义为【抽象的类】不能被实例化。
/ 类的定义 /
class phpClass {
/ 成员变量 /
var $var1;
var $var2 = "constant string";
/ 成员函数 /
function myfunc ($arg1, $arg2) {
[..]
[..] //设置或获取成员变量，调用成员函数！
/ 调用成员函数，【设置】、【获取】标题和URL：$php->setTitle( "php中文网" ) /
【对象】 − 是类的实例。如：人的标签实例【高富帅】、车的标签实例【宝马】
【成员变量】 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可称为对象的属性。
【成员函数】 − 定义在类的内部，可用于访问对象的数据。
【继承】 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承
class Child extends Parent {
// 代码部分
【父类】 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
1.如果父类中的方法被声明为 【final】，则子类无法覆盖
class BaseClass {
public function test() {
echo "BaseClass::test() called" . PHP_EOL;
final public function moreTesting() { //不可覆盖moreTesting！！！
echo "BaseClass::moreTesting() called" . PHP_EOL;
class ChildClass extends BaseClass {
public function moreTesting() {
echo "ChildClass::moreTesting() called" . PHP_EOL;//报错！！！
【子类】 − 一个类继承其他类称为子类，也可称为派生类。
1.子类要执行父类的构造方法，需要在子类的构造方法中调用 parent::construct() 。
function construct() {
print "BaseClass 类中构造方法" . PHP_EOL;
class SubClass extends BaseClass {
parent::construct(); // 【子类构造方法不能自动调用父类的构造方法，类似surper()】
print "SubClass 类中构造方法" . PHP_EOL;
class OtherSubClass extends BaseClass {
// 继承 BaseClass 的构造方法
// 调用 BaseClass 构造方法
$obj = new BaseClass();
// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
$obj = new OtherSubClass();
【多态】 − 多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
【重载】 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
【抽象性】 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
【封装】 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
【构造函数】 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
void construct ([ mixed $args [, $... ]] )
function construct( $par1, $par2 ) {
$this->url = $par1;//不需要再调用 setTitle 和 setUrl 方法了：
$this->title = $par2;//即为对象成员变量赋初始值
【析构函数】 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。
void destruct ( void )
class MyDestructableClass {
print "构造函数\n";
$this->name = "MyDestructableClass";
function destruct() {
print "销毁 " . $this->name . "\n";//销毁 MyDestructableClass
$obj = new MyDestructableClass();
【访问控制】对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。如果没有设置这些关键字，则该方法默认为公有。
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(); // 公有，受保护，私有都可以执行
【接口】使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
接口是通过 【interface】关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是【公有】，这是接口的特性。
要实现一个接口，使用 【implements】 操作符。类中必须【实现接口中定义的所有方法】，否则会报一个致命错误。类可以实现多个接口，用【逗号】来分隔多个接口的名称。
// 声明一个'iTemplate'接口
interface iTemplate{
public function setVariable($name, $var);
public function getHtml($template);
// 实现接口
class Template implements iTemplate{
private $vars = array();
public function setVariable($name, $var){
$this->vars[$name] = $var;
public function getHtml($template){
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
return $template;
【Static 关键字】：“静态的”，由于静态方法不需要通过对象即可调用
1.伪变量 $this 在静态方法中不可用。
2.静态属性不可以由对象通过 -> 操作符来访问，可以使用域运算符【：：】,一般用于在B类对象中使用A类对象的属性/方法!
3.可以用一个变量来动态调用类。但该变量的值不能为关键字 self，parent 或 static。
class Foo {
public static $my_static = 'foo';//静态变量：$my_stati
public function staticValue() {
return self::$my_static;//访问静态变量
print Foo::$my_static . PHP_EOL;//访问静态变量
$foo = new Foo();
print $foo->staticValue() . PHP_EOL;
<!DOCTYPE html>
