内置函数整合

return
* 函数体遇到 return 就终止函数体内部执行 控制权交回函数调用处
* 省略return 返回值为NULL

引用返回
* 必须在函数声明和指派返回值给一个变量时都使用引用运算符&

//举例子
function &myFunc(){
    static $a = 10;//静态
    return $a;
}
$b= &myFunc();// $b与函数的静态变量$a互为引用
echo $b;//输出10
$b=100;
echo myFunc();//输出100

外部文件的导入
include/require 语句包含并执行指定文件
如果给出路径名：按照路径查找 否则从include_path中查找文件 如果include_path中也没有，则从调用脚本文件所在的目录和当前工作目录中寻找
当一个文件被包含时，其中所包含的代码继承了include所在行的变量范围

加载过程中未找到文件：
      include 发出一条警告          E_WARNING
      require 发出一个致命错误      E_COMPITE_ERROR

require（include）/require_once(include_once)区别：
PHP会检查该文件是否已经被包含过，如果是则不会再次包含。

时间日期函数

     * date()                       //时间格式化
     * strtotime()                  //时间转化时间戳
     * mktime()                     //创造一个时间戳 时分秒月日年
     * time()                       //当前时间戳
     * microtime()                  //返回当前 Unix 时间戳的微秒数：
     * date_default_timezone_set()  //设置时区

IP处理函数
ip2long()//将一个数字格式的IPv4地址转换成字符串格式(192.168.0.1)
long2ip()//将一个字符串格式 的IPv4地址转换成数字格式

打印处理函数

 print()      //只打印一个
 echo         //逗号隔开打印多个

 printf()     //根据格式输出
 sprintf()    //返回无输出

 print_r()    //数组对象 格式化好打印  对于布尔值不同
 var_dump()   //数组对象 格式化好打印（每个值的类型 长度） 对于布尔值不同

 var_export() //内容格式化输出 符合php的语法结构 第二个参数为true时 该函数返回不输入

序列化和反序列化
将一个变量所代表的 “内存数据”转换为“字符串”的形式，并持久保存在硬盘（写入文件中保存）上的一种做法，即，把“内存数据”转换为“字符串”然后保存到文件中

  //* serialize()//

  $arr = array(
    'name'=>'zhangsan',
    'bag'=>array(
        'book'=>'English',
        'fruit'=>'apple'
    ),
     'age'=>8,
     'sex'=>'boy'

  //查看数组初始状态的打印
 print_r($arr);
/**
Array
(
    [name] => zhangsan
    [bag] => Array
        (
            [book] => English
            [fruit] => apple
        )

    [age] => 8
    [sex] => boy
)
*/
 //序列化并打印
 $str = serialize($arr);
 echo "<br>";
 print_r($str);
 /*
 a:4:{s:4:"name";s:8:"zhangsan";s:3:"bag";a:2:{s:4:"book";s:7:"English";s:5:"fruit";s:5:"apple";}s:3:"age";i:8;s:3:"sex";s:3:"boy";}
*/

 //反序列化并打印
 $bak_arr = unserialize($str);
 print_r($bak_arr);
/*
Array
(
    [name] => zhangsan
    [bag] => Array
        (
            [book] => English
            [fruit] => apple
        )

    [age] => 8
    [sex] => boy
)
*/

字符串处理函数

   implode()
   //把数组元素组合为一个字符串
    $arr = array('Hello','World!','Beautiful','Day!');
    echo implode(" ",$arr);
    //得到
    Hello World! Beautiful Day!
   join()//是 implode() 函数的别名

   explode()//把字符串打散为数组
    $str = "Hello world. I love Shanghai!";
    $arr = explode(" ",$str);
    print_r ($arr);
    //得到
    Array
    (
        [0] => Hello
        [1] => world.
        [2] => I
        [3] => love
        [4] => Shanghai!
    )

   strrev()
    //反转字符串
    $str = "Hello world. I love Shanghai!";
    $str1 = strrev($str);
    echo $str1;
     //得到
     !iahgnahS evol I .dlrow olleH

   trim()//移除字符串两侧的空白字符或其他预定义字符
   ltrim()//移除字符串左侧的空白字符或其他预定义字符
   rtrim()//移除字符串右侧的空白字符或其他预定义字符

   strstr()
   //查找 "world" 在 "Hello world!" 中是否存在，如果是，返回该字符串及后面剩余部分
   echo strstr("Hello world!","world"); 
    //得到
    lo world!

   number_format('格式化数组','小数位数','小数点','千分位符')//函数通过千位分组来格式化数字
   echo number_format("1000000.12345",2,"@","&");
   //得到
   1&000&000@12

   substr()//截取字符串
   //substr(string,start,length)

数组的处理函数

  * array_keys()        //返回包含数组中所有键名的一个新数组
  * array_values()      //返回数组中所有的值（不保留键名）

  * array_diff()        // 比较两个数组的键值，并返回差集 同名建 返回第一个数组的值 

        $a1=array("a"=>"red1","b"=>"green","c"=>"blue","d"=>"yellow");
        $a2=array("e"=>"red","f"=>"green","g"=>"blue");
        $result=array_diff($a1,$a2);
        print_r($result); 
        //得到
        Array
        (
            [a] => red1
            [d] => yellow
        )

  * array_intersect()   //比较两个数组的键值，并返回交集： 

        $a1=array("a"=>"red1","b"=>"green","c"=>"blue","d"=>"yellow");
        $a2=array("e"=>"red","f"=>"green","g"=>"blue");
        $result=array_intersect($a1,$a2);
        print_r($result);
        //得到
        Array
        (
            [b] => green
            [c] => blue
        )

  * array_merge()       //把两个数组合并为一个数组 同名建 返回二个数组的值
        $a1=array("a"=>"red","b"=>"green");
        $a2=array("c"=>"blue","b"=>"yellow");
        print_r(array_merge($a1,$a2));
        //得到
        Array
        (
            [a] => red
            [b] => yellow
            [c] => blue
        )

  * array_shift()       //删除数组中的第一个元素，并返回被删除元素的值 

        $a=array("a"=>"red","b"=>"green","c"=>"blue");
        echo array_shift($a),'<br>';
        print_r ($a);
        //得到
        red
        Array
        (
            [b] => green
            [c] => blue
        )

  * array_unshift()     //函数用于向数组插入新元素。新数组的值将被插入到数组的开头。

    $a=array("a"=>"red","b"=>"green");
    array_unshift($a,"blue");
    print_r($a);
    //得到
    Array ( [0] => blue [a] => red [b] => green )


  * array_pop()         //删除数组中的最后一个元素，并返回被删除元素的值

        $a=array("a"=>"red","b"=>"green","c"=>"blue");
        echo array_pop($a),'<br>';
        print_r ($a);
        //得到
        blue
        Array
        (
            [a] => red
            [b] => green
        )


  * array_push()        //向数组尾部插入 一个或者多个元素
  * 
        $a=array("red","green");
        array_push($a,"blue","yellow");
        print_r($a);
        //得到
        Array ( [0] => red [1] => green [2] => blue [3] => yellow )

  * array_rand()        //返回包含随机键名的数组 第二个参数默认1 小于数组长度

        $a=array('a'=>"red",'b'=>"green",'c'=>"blue",'d'=>"yellow",'e'=>"brown");
        $random_keys=array_rand($a,3);
        print_r($random_keys); 

  * sort()              // 函数对索引数组进行升序排序 成功则返回 TRUE，否则返回 FALSE

$cars=array("Volvo","BMW","Toyota");
sort($cars);
print_r($cars);
Array
(
    [0] => BMW
    [1] => Toyota
    [2] => Volvo
)
    //rsort() 函数行为与 sort() 相反
    sort() 函数用于对数组单元从低到高进行排序。 键被打乱
　　rsort() 函数用于对数组单元从高到低进行排序。键被打乱 
    $arr = array("b", "a", "c");
    sort($arr);
    print_r($arr);
    Array ( [0] => a [1] => b [2] => c )



　　asort() 函数用于对数组单元从低到高进行排序并保持索引关系。 保持原键值
　　arsort() 函数用于对数组单元从高到低进行排序并保持索引关系。 保持原键值
    $arr = array("b", "a", "c");
    asort($arr);
    print_r($arr);
    Array ( [1] => a [0] => b [2] => c )　



　　ksort() 函数用于对数组单元按照键名从低到高进行排序。
　　krsort() 函数用于对数组单元按照键名从高到低进行排序。
　　$arr = array("b"=>18, "a"=>20, "c"=>25);
　　ksort($arr);
    Array ( [a] => 20 [b] => 18 [c] => 25 )