1、php中局部变量和全局变量
（1）局部变量：除了在函数外，全局变量可以被脚本中的任何部分访问，要在一个函数中访问一个全局变量，需要使用 global 关键字。
（2）局部变量：在 PHP 函数内部声明的变量是局部变量，仅能在函数内部访问。
即：
（1）在不同函数中使用相同的变量名称，因为这些函数内定义的变量名是局部变量，只作用于该函数内
（2）要想在函数中访问全局变量，必须使用global关键字，否则访问不到。
2、global关键字
（1）功能如1所示
（2）PHP 将所有全局变量存储在一个名为 $GLOBALS[index] 的数组中。 index 保存变量的名称。这个数组可以在函数内部访问，也可以直接用来更新全局变量。
$x=5;
$y=10;
function myTest()
{
$GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];
}
3、static关键字
（1）当一个函数完成时，它的所有变量通常都会被删除。然而，有时候您希望某个局部变量不要被删除。
要做到这一点，请在您第一次声明变量时使用 static 关键字
（2）每次调用该函数时，该变量将会保留着函数前一次被调用时的值，但该变量仍然是局部变量。
<?php
function myTest()
{
static $x=0;
echo $x;
$x++;
echo PHP_EOL; // 换行符
}
myTest();
myTest();
myTest();
?>
结果为：0 1 2
4、echo和print输出区别：
（1） echo - 可以输出一个或多个字符串
（2）print - 只允许输出一个字符串，返回值总为 1
（3）两者都是可以使用括号，也可以不使用括号：，如print 或 print()。
注：字符串可以包含 HTML 标签
<?php
echo "<h2>PHP 很有趣!</h2>";
echo "Hello world!<br>";
echo "我要学 PHP!<br>";
echo "这是一个", "字符串，", "使用了", "多个", "参数。";
?>
输出：
Hello world!
我要学 PHP!
这是一个字符串，使用了多个参数。
<?php
$txt1="学习 PHP";
$txt2="RUNOOB.COM";
$cars=array("Volvo","BMW","Toyota");
echo $txt1;
echo "<br>";
echo "在 $txt2 学习 PHP ";
echo "<br>";
echo "我车的品牌是 {$cars[0]}";
?>
输出：
学习 PHP
在 RUNOOB.COM 学习 PHP
我车的品牌是 Volvo
5、PHP EOF(heredoc) :定义字符串的一种新方法
（1） 必须后接分号，否则编译通不过。
（2） EOF 可以用任意其它字符代替，只需保证结束标识与开始标识一致。
（3）结束标识必须顶格独自占一行(即必须从行首开始，前后不能衔接任何空白和字符)。
（4）开始标识可以不带引号或带单双引号，不带引号与带双引号效果一致，解释内嵌的变量和转义符号，带单引号则不解释内嵌的变量和转义符号。
（5）当内容需要内嵌引号（单引号或双引号）时，不需要加转义符，本身对单双引号转义，此处相当与q和qq的用法。
（6）位于开始标记和结束标记之间的变量可以被正常解析，但是函数则不可以。在 heredoc 中，变量不需要用连接符 . 或 , 来拼接
<?php
$name="runoob";
$a= <<<EOF
"abc"$name
"123"
EOF;
// 结束需要独立一行且前后不能空格
echo $a;
?>
变量：
使用php，使用变量之前不需要声明，且变量可以销毁，使用的是：
unset（$变量名）来销毁变量。
（1）可变变量（特殊的，不经常使用，了解一下即可）
$abc='test'
$$abc='孙胜利'
echo $test //输出孙胜利
（2）赋值变量
相当于值传递
$a=1000
$b=$a //相当于把值复制一份给b
$b=20
echo $a //输出1000
（3）变量引用赋值（相当于引用）
引用赋值可以简单的理解为给变量起了个别名。
$a=1000
$b=&$a //相当于给$a给了一个别名
$b=20
echo $a //输出20
（4）变量类型
变量或常量的数据类型由程序上下文决定，不需要事先声明类型。
1、bool(布尔类型)
$a=true
var_dump($a) //该函数用来得到变量的类型
2、int型、float型
3、字符串
可以使用单引号、双引号和定界符三种方法来定义。
单引号：
（1）单引号中不能在包括单引号，如果实在要用单引号需要使用转义字符（\）进行转义
（2）单引号字符串中出现的变量不会被变量的值替代，即php不会解析单引号中的变量。
双引号：
（1）双引号中的变量名会被变量值所替代，即PHP会解析双引号中的变量。
$b=100;
$a="test$bst.."
echo $a //会报错，原因是不能区分变量名，还以为是$bst...
因此需要使用{}将变量名包含起来
$b=100;
$a="test{$b}st.."
echo $a //输出：test100st..
定界符：
（1）<<<之后提供一个标示符表示开始，然后是字符串的内容，最后是相同的标示符表示结束。
（2）注：结束标示符之后必须接;且必须和开始标示符相同。
（3）也可以解析变量，用法和双引号的相同。
$a=<<<aaa
dhgjksadhjkcskdjck
aaa;
echo $a //输出：dhgjksadhjkcskdjck
4、数组（array）
5、object(对象)
6、resource(资源)
7、NULL
(1)将变量直接赋值为null
(2)声明的变量尚未被赋值
(3)被unset函数销毁的变量。
（5）常量（一般常量名称都用全体大写）
1、常量一旦被定义就不能被取消或改变，常量的作用于是全局，常量只能包含bool、int、float、string类型的数据。
2、常量是用于临时（只有在我们程序运行过程中才存在）存储值（数据）的容器。
3、定义：
使用define()来定义常量：define(‘常量名称’,常量值)，常量名称必须使用引号括起来，单货双引号都可。
define('MY_NAME','孙胜利')；
echo MY_NAME
4、defind()函数来检查是否定义了某个常量。
5、常量和变量的区别：
常量前面没有美元符号$;
常量只能用define()函数定义，不能通过赋值语句；
常量不用理会变量范围的规则而在任何地方定义和使用；
常量一旦定义就不能被重新定义或取消定义；
常量类型只能是bool、int、float、和string 类型
（5）预定义常量
预定义常量就是PHP内核已经帮我们定义好的常量，其中有的预定义常量是以_开头的，这些又被称为魔术常量。比如 _FILE_表示输出当前代码的位置。
echo _FILE_ //输出当前代码所在的位置
预定义常量不区分大小写，但自己定义的常量是严格要区分大小写。
（6）字符串运算符
字符串之后连接符"."。
$a='aa';
$b='bb';
echo $a.$b; //aabb
echo $a.'cc'; //aacc
(7)赋值运算符
有=、-=、+=等，其中比较特殊的是.=，属于字符串连接赋值运算符。
（8）比较运算符
注：
使用echo输出bool类型时:
echo true; //它在页面会输出1
echo false；//它在页面什么都不输出
因此在测试的时候如果需要输出布尔类型最好使用var_dump()来输出更明了。
1、==：值是否相等
$a=11;
$b='11';
var_dump($a==$b) //true
2、===：全等（值要相等，类型也要相等）
$a=11;
$b='11';
var_dump($a==$b) //true
var_dump($a===$b) //false
3、!=：值是否不相等
判断的是值是否不相等
$a=11;
$b=1;
var_dump($a！=$b) //true
4、<>，作用同上，判断值是否不相等
5、!== ：全不等
判断两边操作数是否是不全等
$a=11;
$b='11';
var_dump($a!=$b) //false
var_dump($a!==$b) //true
（9）逻辑运算符
and(逻辑与，或写成&&，也会有短路问题)、or(逻辑或，或写成||)、xor(逻辑异或)、!(逻辑非)、
（10）exit()或exit或exit(想要写的字符串)，die函数和exit用法和作用完全一样。
作用：结束当前php脚本的执行，即结束当前整个程序的执行。
（11）自定义函数
1、定义：
function 函数名（参数1，参数2，参数n）{
函数体；
return 表达式；
}
2、不管是自己定义的函数还是系统自有的，必须调用才会运行，否则不会执行。
3、函数调用可以放在函数定义的前面
test(); //输出‘你好’
function test(){
echo '你好'；
}
test(); //输出‘你好’
test(); //输出‘你好’
4、函数中的return除了返回值，还可以结束这个函数的运行
function add($a,$b){
return $a+$b; //结束函数
echo "aa" // 不输出了，因为在return那就结束了
}
（12）变量范围
1、局部变量：
局部变量是在函数内部定义的，其作用域仅限于函数内部，离开该函数在使用这种变量就是非法错误的。
2、全局变量：
全局变量是在函数外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。在php函数中无法直接使用全局变量，如需使用必须使用global声明变量。
3、静态变量：
静态变量指的是在函数内部定义变量时使用static关键字来定义的变量，特点是：函数执行完毕之后该变量不会立即消失，当再次调用函数时，静态变量保存的值依然存在，并且仅在第一次执行函数的时候会初始化。
（13）参数的传递
1、按值传递参数（默认的）：
该方式是默认的参数传递方式。
2、按引用传递参数：
按引用传递参数，实参和形参指的是同一个人，只是名字不一样而已，对于形参的操作会直接影响到实参。
function test(&$a){ //在参数之前加一个取址符 （形参）
echo ++$a
}
$i=10;
test($i); //实参没有取址符
echo $i //输出11
3、函数的默认参数：
给形参加默认值得时候是从右往左加的，右边的必须有，才能够给左边加。
function test($a=10){
echo ++$a;
}
test(); //如果不传参数，就按照默认的参数来计算
test(20); //如果传递的话按照实际参数的值来
function test($a=10,$b){ //这种写法是错误的，应该从右往左加，即($a,$b=10)
echo $a+$b;
}
test(,10); //这种写法是错误的
4、可变长度参数列表:
PHP提供给我们的，可以直接使用。
func_get_args()、
func_get_arg()、
func_num_args()
这三个函数可以使用在我们自定义函数内部，能够返回给我们一些关于参数的信息。
function test(){
}
test(21,11,1111) //因为形参没有参数，所以传递的值是不能在函数中显示出来的。注：实参只要比形参数目多就可以，但是不能少。
//要想使上述传递的参数显示出来，可以用以列出的函数
function test(){
func_get_agrs() //该函数返回的是一个数组，因为还没学到数组，因此先这样写。该数组中存储的是收到传递的参数：21，11，1111
func_get_arg(0) //获取第0个实际参数，输出21
func_num_args(); //返回传入实际参数的个数，输出3
}
test(21,11,1111)
（14）可变函数(或称为变量函数)
就是：把一个函数赋值给一个变量。
把函数名称加上引号（单双都可），然后赋值给变量即可。
function test(){
echo '我是test'
}
$a='test' //将函数名赋值给一个变量，注：可用单引号，也可用双引号
$a(); //输出：我是test；相当于直接test()
（15）内置函数
比如echo()等
这些内置函数他们可以省略括号使用，严格上讲不是函数，所以这些不可以赋值给另外的变量。
（16）数组
1、php中的数组在创建时不需要指定数组的大小，甚至不需要在使用数组之前声明，也可以在同一个数组中存储不同类型的数据。
2、可以直接为数组元素赋值即可创建数组：
$变量名[索引值]=数据内容；
索引值可以是整数也可以是字符串，也可以不写（默认为索引数组）
（数组的索引值为整型的为索引数组；数组的索引值为字符串类型的为关联数组）
//创建数组
$student[0]=10;
$student[1]='孙胜利'；
$student[2]=true;
echo $student //错误的，直接使用echo不能输出数组
print_r($student) //正确的，可以直接使用此函数输出数组
//如果省略索引值不写，默认索引值就是整数，并且从0开始依次增加。
$student[]=10;
$student[]='孙胜利'；
$student[]=true;
2、使用array()语言结构创建数组
$变量名=array(key1=>value1,…)
$student=array(10,'孙审理',true,60.5) //没写索引值，默认还是整型，且从0开始依次增加。
$student=array(
0=>10,
1=>'孙胜利',
2=>true,
3=>60.5
); //和上面是一样的
$student=array(
‘num’=>10,
'name'=>'孙胜利',
'sex'=>true,
'grade'=>60.5
10=>'aaa' //索引值也可以类型混合，不只全是字符串
);
3、数组中再放数组（二维数组）
$students=array(
0=>array(1,'孙胜利'，true,60.5),
1=>array(1,'李雷'，true,60.5)
);
4、使用count($s数组名)来获取数组中元素的个数。
echo count($student);
该函数还可以获取多维数组的个数
$array=array(
array(1,2,3),
array(4,5,6)
);
echo count($array) //输出2,默认获取第一维数组的个数
5、遍历数组
1）使用for循环（用的不多）：
$arr=array('a','b','c','d','e');
for($i=0;$i<count($arr);$i++){
echo Sarr[$i];
}
但是如果数组是使用=>定义的话，使用上述for循环的方式遍历数组就是有问题的。
2）使用foreach遍历数组（比较常用）
foreach(数组变量名 as 变量1){ //变量1是自己命名的，用在循环中的，表示正在访问变量的数据（而不是索引）
每次循环执行的语句。
}
foreach(数组变量名 as 变量1=>变量2){
//变量1是自己命名的，用在循环中的，表示正在访问变量的索引值
//变量2 表示正在访问变量的数据
每次循环执行的语句。
}
$arr=array(
'name'=>'孙胜利'，
‘num’=>10
);
foreach($arr as $value){
echo $value; //依次输出 孙胜利 10，只输出值，不输出键
}
foreach($arr as $key=>$value){
echo $key.'=>'.$value; //依次输出 name=>孙胜利, num=>10
}
6、预定义超全局数组变量(系统自定义好的)
已经定义好（存在）的变量（存放的数据类型是数组）；
超全局：超级全局变量，作用域是超全局的，函数内外都可直接使用，不需要使用global。
$_GET:
索引值是参数名，索引值对应参数值，指的是url后面跟随的参数。
如果是通过get方式传递的参数，在服务端可以通过$_GET来获取的到参数数组
$_POST:
比如通过表单发送来的数据，在服务端可以通过使用$_POST来获取参数数组
7、处理数组的相关函数
1）array_count_values函数：
返回数组中值处出现的次数
2）
（17）字符串处理（只列出函数名，具体使用自己现用现查）
1）trim()函数：去除字符串首尾处的空白字符
2）substr_count():计算字串出现的次数
3）strpos():查找字符串首次出现的位置,返回出现的位置
4)strstr():查找字符串首次出现，然后返回从第一次出现到结尾的字符串。
5）strlen(字符串):返回所给字符串的长度
6）str_replace()字符串替换函数
7）substr()字符串截取函数
8）explode()：字符串分割函数
9）str_split():字符串分割函数
(18)类和对象
1、使用->来调用对象的成员方法和成员属性：
class Site {
/* 成员变量 */
var $url;
var $title;
/* 成员函数 */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url . PHP_EOL;
}
}
$runoob = new Site; //没有构造函数，可能就不需要使用()了
$runoob->setUrl( 'www.runoob.com' ); //使用->来调用成员方法
$runoob->getUrl();
2、构造函数：
主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值
function __construct( $par1, $par2 ) {
$this->url = $par1;
$this->title = $par2;
}
3、析构函数：
析构函数(_destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。
class MyDestructableClass {
function __construct() {
print "构造函数\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "销毁 " . $this->name . "\n";
}
}
4、继承：
PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承。
5、方法重写：
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写
6、访问控制：
public（公有）：公有的类成员可以在任何地方被访问。
protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
private（私有）：私有的类成员则只能被其定义所在的类访问。
1）属性的访问控制：
类属性必须定义为公有，受保护，私有之一。如果用 var 定义，则被视为公有。
class MyClass
{
public $public = 'Public';
protected $protected = 'Protected';
private $private = 'Private';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj = new MyClass();
echo $obj->public; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private
继承的类可以对 public 和 protected 进行重定义，但 private 而不能。
class MyClass2 extends MyClass
{
// 可以对 public 和 protected 进行重定义，但 private 而不能
protected $protected = 'Protected2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined
2）方法的控制访问：
类中的方法可以被定义为公有，私有或受保护。如果没有设置这些关键字，则该方法默认为公有。
一般的就不举例了。
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
?>
3）php中self和$this的区别：
·self代表类，$this代表对象(self是引用静态类的类名，而$this是引用非静态类的实例名)
·能用$this的地方一定使用self，能用self的地方不一定能用$this。
4)php中的::
在PHP中“::”这个叫范围解析操作符，又名域运算符。
php调用类的内部静态成员，或者是类之间调用就要用::。也可以使用::来调用一个常量。
class A
{
static $count = 0;
static function haha()
{
//
}
function diaoyoug()
{
self::haha();
self::$count;
}
}
<?php
class MyClass
{
const constant = '常量值';
function showConstant() {
echo self::constant . PHP_EOL;
}
}
echo MyClass::constant . PHP_EOL; //输出：常量值
$classname = "MyClass";
echo $classname::constant . PHP_EOL; // 自 5.3.0 起，输出：常量值
$class = new MyClass();
$class->showConstant();
echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起 输出：常量值
?>
(5)static关键字
声明类属性或方法为 static(静态)，就可以不实例化类而直接访问。
静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
静态属性不可以由对象通过 -> 操作符来访问。
自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字 self，parent 或 static。
<?php
class Foo {
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;
}
}
print Foo::$my_static . PHP_EOL;
$foo = new Foo();
print $foo->staticValue() . PHP_EOL;
?>
以上程序的输出结果为：
foo
foo
（6）final关键字
PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。
（7）构造方法
PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。
<?php
class BaseClass {
function __construct() {
print "BaseClass 类中构造方法" . PHP_EOL;
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // 子类构造方法不能自动调用父类的构造方法
print "SubClass 类中构造方法" . PHP_EOL;
}
}
class OtherSubClass extends BaseClass {
// 继承 BaseClass 的构造方法
}
// 调用 BaseClass 构造方法
$obj = new BaseClass();
// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>
以上程序输出结果为：
BaseClass 类中构造方法
BaseClass 类中构造方法
SubClass 类中构造方法
BaseClass 类中构造方法
（8）注：说下继承，子类继承父类的属性和方法，也就是说子类拥有父类所有的东西，包括 public(公有)、protected(保护)和private(私有)的。但是父类私有的属性和方法不能让子类直接调用，并不是说没有继承过来，而是继承过来了，但是要调用父类的私有属性和方法的话还是需要通过父类的 public、protected 方法调用。