变量和常量区分大小写
$a =10;
$A =20;
以上变量名是区分大小写的.
 echo Echo 不区分大小写


可变变量
php1.jpg



变量赋值[传递赋值(独立)，引用赋值（关联)]
$one=10;  //10赋值跟one
$two=$one //one赋值给two,即使改变one的值，two的值不会变

$two=&$one //引用赋值  改变one或者two就是等于改变了另一个变量。

PHP变量类型和JS一样都是不用去声明指定的类型，只要看值来判断变量的类型。


变量类型
php2.jpg

查看类型var_dump($a);

单引号 和 双引号  的区别，
如果只是单纯的输出字符串和转义\' \\就使用单引号，否则就是用双引号，
双引号可以同时输出字符串里面的变量和多个转义字符为什么不使用呢？因为会占用资源。


数据类型之间转换
setType(变量,类型)
例如：
$str="100.234abc";
setType($str,int);  //输出的值是100，这个函数是在原类型上改变。

$a=(int)$str; //这个方法将字符串重新转型赋值给$a,原类型$str不会变。

$a=intval($str);  // 此方法跟第二个一样。
以上都是强制转换


因为PHP是弱类型的语言不考虑类型转化就可以相加例如
$a=10;
$b="100abc";
$c=true;
$d=12.34;
$sum=$a+$b+$c+$d; //相加的话PHP会将其他类型自动转换成数字型，这就是PHP开发快的原因。


跟变量有关的PHP内置函数，如下
isset() //判断一个变量是否存在，不管变量是不是空都算存在。（null也算变量不存在）
empty() //判断一个变量是不是为空，必须是变量存在的时候才能判断。（null也算变量为空）
unset();//删除变量。
setType()//类型之间强制转换 
var_dump()//查看类型（缩写），这个既能看到类型也能看到值
getType()//查看类型（扩写），只能看出类型。 


判断变量类型函数（PHP强大就在于内置函数太多使用起来方便）
is_bool();
is_int() is_integer() is_long()
is_string()
is_float() is_double() is_real()
is_array()
is_object()
is_resource() //判断变量是否是资源类型
is_null()

is_scalar() //判断是否是 整形 浮点型 字符串
is_callable()//判断是否是有效的函数名
is_numberic()//判断一个变量是不是数字型


定义一个常量的方法
define("常量名","常量值");

判断一个常量是否存在用defined("常量名");

常量值永远不会变，也不能被unset()删除是全局变量，赋值只能是标量（int,float,bool,string）
常量的值一旦声明了也不能改。




运算符------

%取余数

.在PHP中字符串连接用的是.而在js中用的是+。


+= -= *= /= %= //例如 $a+=10; $a=$a+10;

.=  //例如 $a.="abc"  $a=$a."abc";

$str='<table>';
$str.='</table>';  //输出结果就是<table></table>


位运算符 在JS 和PHP 几乎很少用到

``符号可以里面可以执行系统命令然后将结果赋值给一个变量
例如
$str=`ipconfig /all`;







范围判断使用if else
单个值判断使用switch





循环





函数


函数中末尾加上return $str,函数的值就会返回给调用处，调用就成了一个值,这样可以输入数据库。
例如
function table(){
   $str='<table></table>';
   return $str;
   echo '1111';  //在return后面写代码无效,同时也可以使用return当作函数的结束语句。
}

echo table();  //table()就是一个值了。
echo table().'你好'; //如果是值数字也可以参与运算


函数中要使用函数以外的全局变量就要使用global,例如。
$a=10;
function table(){
  global $a;  //这样才能使用上全局的$a
  $a+=10;
}




static 在函数中变量中声明此时的变量就相当于这个函数的全局变量，此变量会共用。
例如，
function test(){
   static $a=0;
   $a++;
   echo $a."<br>";
}

test();  // a=1
test();  // a=2
test();  // a=3





变量函数，就是把函数赋值给一个变量，然后变量括号里面穿参数。
例如，
function one($a,$b){
   return $a+$b;
}

function two($a,$b){
   return $a*$b;
}

$var=one;  //自动寻找 函数名是one的函数
$var="two"; //自动寻找 函数名是two的函数

echo $var(3,4); //可以这样穿参数







数组

数组的一些特性
php3.jpg
1，如果数组索引0自定义在后面，那么索引0前面的数组元素都没忽略。
2，自定义数组索引，数组后面的索引默认接着最大一个索引开始。


php4.jpg

可以自定义索引，如果其他没有自定义的索引就默认是0开始


数组中加入数组
$user =array(array(),array(),array());





数组遍历

1,for循环（数组的索引必须是数字和有规律，PHP中不推荐使用）


2，foreach  php中推荐使用
   foreach(数组变量 as 自定义变量){   
      循环次数由数组的元素个数确定；
      每次循环都会将属性值赋值给自定义变量；
   }
   
   foreach(数组变量 as 自定义索引变量=>自定义属性值变量){
      每次循环都会自动将数组的索引和属性值 赋值给自定义索引变量 和 自定义属性值变量
   }

3，while()  list()  each() 组合使用

  each(数组)
  第一次调用返回数组的第一个属性和属性值，结果是数组，固定是属性是0，1，key，value，
  0,key是属性
  1,value是属性值
  第二次调用返回数组第二个属性和属性值，以此类推。如果继续调用返回的就是false。
  
  打印结果//Array([1]=>值 [value]=>值 [0]=>索引 [key]=>索引 );



  list(数组)
  list()=数组    //将数组赋值给list()函数
  list($name,,$age)=array('zhangsan',10,'男');  //要一一对应  *list()只能接受索引是数字的，并且按数字小到大赋值
  例子一：
  $user=array("id"=1,"name"=>"zhangsan","age"=>10,"sex"=>"nan");
  list($key,$value)=each($user);  //打印出 Array([1]=>1 [value]=>1 [0]=>id [key]=>id );  
                                  //但是list()的参数只能接受数字，虽然先打印出[1]=>1在到[0]=>id，
                                    赋值顺序是[0]=>id先赋值给$key，[1]=>1在赋值给$value

  例子二：
  $ip="192.168.1.128";
  $ips=explode(".",$ip); //将IP以点分割成为一个数组。 
  list(,,,)=explode(".",$ip);


  3个函数组合使用例子：
   $user=array("id"=1,"name"=>"zhangsan","age"=>10,"sex"=>"nan");
   while(list($key,$value)=each($user)){    //利用while一直循环直到each执行到false的时候跳出while循环,
      echo $key."-----".$valu;              //each逐个调用赋值给list,思路在例子一。
   } 

  控制数组执行步骤
   next(数组)
   prev(数组)
   reset(数组)
   end(数组)
   current(数组) //获取当前数组的属性值
   key(数组)   //获取当前数组的索引








  数组的相关处理函数

  索引/属性值  的操作
1，array_values(); //将数组的属性值取出来从新排列一个索引从0开始的新数组。

2，array_keys(); //取出数组的索引重新排列成一个数组索引又是从0开始。
   array_keys(数组,"属性值",true)  //这里的填写属性值就获取到此属性值的索引排列成一个数组
                                   //第3个参数默认是false，如果写true意思是是否严格按照类型判断

3，in_array("属性值",数组,true)  //判读这个属性值在不在这个数组里面，在返回true 不在返回false
                                 //第三个参数为true,属性值的类型就必须严格匹配

4，array_key_exists("索引",数组)  //判断索引在不在数组中

5，array_flip  //将数组中的 索引和属性值 交换

6，array_reverse(数组) //数组里的元素顺序颠倒



  统计数组元素个数 和  属性值的唯一性
1，count(数组,1)  //统计数组里面的元素个数，如果加上1，就会将元素为数组的元素一样统计出来。  

2，array_count_values  //分类统计数组里面的属性值出现的重复次数，返回结果是数组。
  例如返回 array( [linux]=>2,[apache]=>2 );   //属性值成了索引，重复个数成了属性值。

3，array_unique //移除数组中重复的属性值，保留之前的移除后来出现的。


  数组元素过滤
1，array_filter(数组,"函数")
 例子：  
   $arr=array(1,2,3,-4,4,5,-5,-12);
   $arr1=array_filter($arr,"myfun"); //将数组中的元素一个个带入函数中，true就重新返回数组false就删除。
   function myfun($n){     
      if($n>0){
        return true;
      }else{
        return false;
      }
   }
    返回 //=array(1,2,3,4,5,-12);


2，array_walk()  例子说明
   $arr=array("os"=>"linux","wb"=>"apache");
   array_walk($arr,"myfun1","========");
   function myfun1($value,$key,$p){
      echo $key.$p.$value."<br>";
   }
   返回 //  os========linux
            wb========apache

   array_walk($arr,"myfun1");
   function myfun1(&$value,$key){  //属性值处加了&符号
       $value="ffffff";            //统一将全部的属性值都重新赋值成为ffffff
   }
    返回 //  array("os"=>"ffffff","wb"=>"ffffff");



3,array_map()  //统一在原来属性值上添加相同内容
   $arr=array("os"=>"linux","wb"=>"apache");
   $arr1=array_map("myfun1",$arr);  //将数组中的属性值带入函数中
   function myfun1($n){
      return "==".$n."==";
   }
   返回 //  array("os"=>"==linux==","wb"=>"==apache==");


   $arr=array("os"=>"linux","wb"=>"apache");
   $arrr=array("os"=>"win","wb"=>"iis");
   $arr1=array_map("myfun1",$arr,$arrr);  //两个数组长度要一样
   function myfun1($n,$t){
      if($n==$t){
         return "same";
      } 
         return "diff";
   }

  返回 //  array([0]=>diff,[1]=>diff);


  







数组的排序函数

sort()  //根据值小到大排序  (索引被改变成从0，1..)

rsort() //根据值大到小排序  (索引被改变成从0，1..)

ksort() //根据索引值小到大排序  并保留原来的索引和值的关系

krsort() //根据索引值大到小排序  并保留原来的索引和值的关系

asort()  //根据值小到大排序 并保留原来的索引和值的关系

arsort() //根据值大到小排序 并保留原来的索引和值的关系


自然数排序
natsort()  区分大小写
natcasesort() 不区分大小写

例如
$data=array("file1.txt","file11","file2.txt","file22.txt");
如果使用普通的排序例如是sort()结果是
("file1.txt","file11","file2.txt","file22.txt")
file11排在了file2后面显然不是我们想要的
如果使用natsort()，排序结果会正常。
("file1.txt","file2","file11.txt","file22.txt")
如果区分大小写那么大写的会排在前面
("File2.txt","file1","file11.txt","file22.txt")



用户自定义排序
usort()  uasort()  uksort()


例如usort()  //小到大排序  索引会重新赋值0 开始

$arr = array("Peter", "glenn","Cleveland","peter","cleveland", "Glenn");
usort($arr, "my_sort");

function my_sort($a, $b)
  {
  if ($a == $b) return 0;      //0 排序不变
  return ($a > $b) ? -1 : 1;   //a>b,a赋值1向后退 否则赋值-1前进 
  }
print_r ($arr);



uasort()  // 跟usort功能一样但是索引值不变


uksort()  // 大到小排序  但是索引值不变







数组拆分 合并
$a=array(0=>"Dog",1=>"Cat",2=>"Horse",3=>"Bird");
array_slice()  //过滤数组，选指定数组中的元素
print_r(array_slice($a,1,2));   //[0] => Cat [1] => Horse
print_r(array_slice($a,-2,1));  //[0] => Horse

array_splice()  //过滤数组，跟上面差不多


array_combine($a1,$a2); //合并数组，  $a1数组是索引，$a2数组为值，两数组合并成一个数组


array_merge($a,$b,$c,....); //合并数组，前面的数组如何后面的数组索引重复，就会被后面的覆盖。
array_merge($a)  //输入单个数组，索引从默认从0开始。
参考http://www.w3school.com.cn/php/func_array_merge.asp


array_intersect($a1,$a2); //选出数组公共的部分，选出的数组索引以$a1的为准


array_diff($a1,$a2);//选出不同的部分排列为数组，选出的数组索引以$a1的为准







栈（最后进的最先出，就像上子弹一样）



例如在数组中入栈（向数组添加元素）
$a1=array('php','word');
$a1[]='one';   //数组末尾增加元素，入栈推荐使用这种方法
$a1[]='two';

array_push($a1,'one'，'two'); //数组末尾增加元素

array_pop($a1);//出栈默认删除最后一个，最后进的最先出




堆（先进先出，就像吸管一样）


array_unshift($a1,'one','two');   //数组最前面添加元素。

array_shift($a1,'one','two');   //删除数组最前面元素。


unset() //可以删除变量，数组中的元素，对象中的成员。
unset($a1[5]);







其他操作数组函数

array_rand($a1);  //随机取数组的索引

shuffle($a1);    //随机排列数组。

array_sum($a1);  //数组中的元素求和

range()//创建简单有规律的数组。
range('a','k')  //索引是0，创建a到k的数组
range(0,50,10) //索引是0，创建一个数组值是0到50并且数值差为10









php对象


class Person{   //类
    var $name;
    var $age;
    var $sex;

    function say(){
        $(this)   //代表“我” 就是  $p1
    }

    function run(){
    }

    function eat(){
    }
    
}


$p1=new Person();  //创建对象

外部访问对象里面

$p1->name;
$p1->name='张三';

$p2->say();





构造方法（其实就是创建好对象之后就会自动调用类里面的函数）

例如：
class Person{
   var $name; 
   var $sex; 
   var $age; 

   function Person($value1='',$value2='女'){   //构造方法（就是跟类同名的函数会被自动调用） 传的参数一般都是默认参数
        $this->name=$value1;   //*构造方法作用，就是初始化。
        $this->sex=$value2;    //传进来的参数就默认赋值给了变量。
   }

}

$p1=new Person('陈格','男');




魔术方法中的__construct()就是构造方法，好处是如果修改类名，构造方法不需要名。

function __construct(){

}



析构方法：
就是对象把该执行完的功能都执行完了，为了节省内存，需要把之前的变量和其他类删除,而最后自动执行的函数。

function __destruct(){

}






php面向对象的封装


private 私有只给类内部方法访问

例如：

function run(){
   $this->left();
   $this->right();
}

private function left(){
   echo 'left';
}

private function right(){
   echo 'right';
}









对封装后的成员进行操作的方法：
__get
__set
__isset
__unset


批量获取对象私用变量、修改私有变量值、判断私有变量是否存在或者删除私有变量，使用魔术方法。（公用变量不能调用到这些方法）

__get   //外部一旦调用 私有变量，就自动调用的魔术方法。

例如：

private function __get($name){
   echo'--$name---';    //得到变量的属性名，有了属性名就能得到属性值。
}

echo $p1->name;   //一旦外部调用就触发到魔术方法__get.
echo $p1->age;





__set  //外部修改 私用变量值，就会自动调用到的魔术方法。

private function __set($name,$value){
   $this->$name=$value;
}





__isset //  只能判断私用变量是否存在

private function __isset($name){
   return isset($this->$name);
}


if(isset($p1->name)){  //外部一旦使用isset就会自动调用_isset魔术
   
}




__unset()  //删除私用变量

private function __unset($name){
   return unset($this->$name);

}

unset($p1->name);   //外部删除就会调用 __unset