PH常用函数汇总

<?php
/**
 *  array_change_key_case() 把数组中所有键更改为小写或大写
 *  array_chunk() 把一个数组分割为新的数组块
 *  array_column() 返回输入数组中某个单一列的值
 *  array_combine() 通过合并两个数组来创建一个新数组
 *  array_count_values() 用于统计数组中所有值出现的次数
 *  array_diff() 比较数组，返回差集（只比较键值）
 *  array_diff_assoc() 比较数组，返回差集（比较键名和键值）
 *  array_diff_key() 比较数组，返回差集（只比较键名）
 *  array_fill() 用给定的键值填充数组
 *  array_fill_keys() 用指定键名的给定键值填充数组
 *  array_filter() 用回调函数过滤数组中的元素
 *  array_flip() 交换数组中的键和值
 *  array_intersect() 比较数组，返回交集（只比较键值）
 *  array_intersect_assoc() 比较数组，返回交集（比较键名和键值）
 *  array_intersect_key() 比较数组，返回交集（只比较键名）
 *  array_key_exists() 检查指定的键名是否存在于数组中
 *  array_keys() 返回数组中所有的键名
 *  array_map() 把数组中的每个值发送到用户自定义函数，返回新的值
 *  array_merge() 把一个或多个数组合并为一个数组
 *  array_merge_recursive() 递归地合并一个或多个数组
 *  array_multisort() 对多个数组或多维数组进行排序
 *  array_pad() 用值将数组填补到指定长度
 *  array_pop() 删除数组的最后一个元素（出栈）
 *  array_product() 计算数组中所有值的乘积
 *  array_push() 将一个或多个元素插入数组的末尾（入栈）
 *  array_rand() 返回数组中一个或多个随机的键
 *  array_reduce() 通过使用用户自定义函数，以字符串返回数组
 *  array_replace() 使用后面数组的值替换第一个数组的值
 *  array_replace_recursive() 递归地使用后面数组的值替换第一个数组的值
 *  array_reverse() 以相反的顺序返回数组
 *  array_search() 搜索数组中给定的值并返回键名
 *  array_shift() 删除数组中首个元素，并返回被删除元素的值
 *  array_slice() 返回数组中被选定的部分
 *  array_splice() 删除并替换数组中指定的元素
 *  array_sum() 返回数组中值的和
 *  array_udiff() 比较数组，返回差集（只比较值，使用一个用户自定义的键名比较函数）
 *  array_udiff_assoc() 比较数组，返回差集（比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）
 *  array_udiff_uassoc() 比较数组，返回差集（比较键和值，使用两个用户自定义的键名比较函数）
 *  array_uintersect() 比较数组，返回交集（只比较值，使用一个用户自定义的键名比较函数）
 *  array_uintersect_assoc() 比较数组，返回交集（比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）
 *  array_uintersect_uassoc() 比较数组，返回交集（比较键和值，使用两个用户自定义的键名比较函数）
 *  array_unique() 删除数组中的重复值
 *  array_unshift() 在数组开头插入一个或多个元素
 *  array_values() 返回数组中所有的值
 *  array_walk() 对数组中的每个成员应用用户函数
 *  array_walk_recursive() 对数组中的每个成员递归地应用用户函数
 *  arsort() 对关联数组按照键值进行降序排序
 *  asort() 对关联数组按照键值进行升序排序
 *  compact() 创建包含变量名和它们的值的数组
 *  count() 返回数组中元素的数目
 *  current() 返回数组中的当前元素
 *  each() 返回数组中当前的键／值对
 *  end() 将数组的内部指针指向最后一个元素
 *  extract() 从数组中将变量导入到当前的符号表
 *  in_array() 检查数组中是否存在指定的值
 *  key() 从关联数组中取得键名
 *  krsort() 对数组按照键名逆向排序
 *  ksort() 对数组按照键名排序
 *  list() 把数组中的值赋给一些变量
 *  natcasesort() 用“自然排序”算法对数组进行不区分大小写字母的排序
 *  natsort() 用“自然排序”算法对数组排序
 *  next() 将数组中的内部指针向前移动一位
 *  pos()current() 的别名
 *  prev() 将数组的内部指针倒回一位
 *  range() 创建包含指定范围单元的数组
 *  reset() 将数组的内部指针指向第一个元素
 *  rsort() 对数组逆向排序
 *  shuffle() 将数组打乱
 *  sizeof()    count() 的别名
 *  sort() 对数组排序
 */
// array_change_key_case() 把数组中所有键更改为小写或大写(CASE_UPPER),默认为小写(CASE_LOWER)
$age=array("Bill"=>"Bill","Steve"=>"56","Mark"=>"31");
// print_r(array_change_key_case($age,CASE_UPPER));

// array_chunk($arr,$num) 把一个数组分割为新的数组块，一般用于一维数组，分割时重置键，针对二维及以上数组，不存在递归分割
$cars = array(array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
		array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
		array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
		array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45)
	);
$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
// print_r(array_chunk($cars,2));

// array_column($arr,'column','index_key') 返回数组中某一个单列的值
$arr = array(
    'dasd' =>array(
        'id' => 5698,
        'first_name' => 'Bill',
        'last_name' => 'Gates',
    ),
    'dassadasdasd' =>array(
        'id' => 4767,
        'first_name' => 'Steve',
        'last_name' => 'Jobs',
    ),
    'ddasdasdasasd' =>array(
        'id' => 3809,
        'first_name' => 'Mark',
        'last_name' => 'Zuckerberg',
    )
);
// 返回$arr中last_name的值并形成一个新数组
// print_r(array_column($arr,'last_name')); Array ( [0] => Gates [1] => Jobs [2] => Zuckerberg )


// 返回$arr中last_name的值并形成一个以id为键的新数组
// print_r(array_column($arr,'last_name','id')); Array ( [5698] => Gates [4767] => Jobs [3809] => Zuckerberg )

// 第二个参数为null时，返回原数组，重置数组键
// print_r(array_column($arr,null));
/*Array
(
    [0] => Array
        (
            [id] => 5698
            [first_name] => Bill
            [last_name] => Gates
        )

    [1] => Array
        (
            [id] => 4767
            [first_name] => Steve
            [last_name] => Jobs
        )

    [2] => Array
        (
            [id] => 3809
            [first_name] => Mark
            [last_name] => Zuckerberg
        )
)*/
// 第二个参数为null时，返回原数组，可配合第三个参数来重置数组键
// print_r(array_column($arr,null,'first_name'));
/*Array
(
    [Bill] => Array
        (
            [id] => 5698
            [first_name] => Bill
            [last_name] => Gates
        )

    [Steve] => Array
        (
            [id] => 4767
            [first_name] => Steve
            [last_name] => Jobs
        )

    [Mark] => Array
        (
            [id] => 3809
            [first_name] => Mark
            [last_name] => Zuckerberg
        )

)
*/

// array_combine($arr1,$arr2)   
// 合并两个数组来创建一个新的数组，第一个数组为键，第二个数组为值 若数组个数不同，返回false
$fname=array("Bill","Steve","Mark");
$age=array("60","56","31");

$c=array_combine($fname,$age);
// print_r($c);                         // Array ( [Bill] => 60 [Steve] => 56 [Mark] => 31 )

// array_count_values($arr) 对数组中所有的值进行计数
$a=array("A","Cat","Dog","A","Dog");
// print_r(array_count_values($a));     // Array ( [A] => 2 [Cat] => 1 [Dog] => 2 ) 

// array_diff($arr1,$arr2[,$arr3]) 返回两个或以上数组的差集数组（其他数组与第一数组进行仅有值的比较）
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");

// 比较a1与a2，返回a1中与a2不匹配的部分，结果不包括a2中的键值
// print_r(array_diff($a1,$a2));        // Array ( [b] => green [c] => blue [d] => yellow ) 
// 比较a1,a2与a3，返回a1中与a2,a3同时不匹配的部分，结果不包括a2,a3中的键值
// print_r(array_diff($a1,$a2,$a3));    // Array ( [b] => green [c] => blue )


// array_diff_assoc($a1,$a2,$a3...) 比较2个或以上数组的键与值并返回差集
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");

// 条件：当键与值同时匹配
// print_r(array_diff_assoc($a1,$a2)); // Array ( [a] => red [b] => green [c] => blue [d] => yellow )


// array_diff_key($a1,$a2,$a3...) 比较两个或以上的数组的键，并返回差集
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");

// print_r(array_diff_key($a1,$a2));   // Array ( [b] => green )

$a1=array("red","green","blue","yellow");
$a2=array("red","green","blue");

// print_r(array_diff_key($a1,$a2));   // Array ( [3] => yellow )
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");

// print_r(array_diff_key($a1,$a2,$a3)); // Array ( [a] => red [b] => green )


// array_fill(start_index, num, value) 從start_index索引開始，填充num條值為value形成新數組
// print_r(array_fill(5,3,'value'));   // Array ( [5] => value [6] => value [7] => value )


// array_fill_keys(keys, value) 用指定鍵、值填充數組
$keys=array("a","b","c","d");
// print_r(array_fill_keys($keys,'blue')); // Array ( [a] => blue [b] => blue [c] => blue [d] => blue )

// array_filter($array[,'myfunction']) 使用自定义函数过滤数组中的元素，数组键名保持不变。若无自定义函数，则取出数组中为空、null的值
$a = [1,2,3,4,5,6,7,8,9,10];
// print_r(array_filter($a,function($a){ if($a > 5) { return $a; } }));

// array_flip(arr)  反转数组的键值，如果同一值出现了多次，则最后一个键名将作为它的值，所有其他的键名都将丢失。 如果原数组中的值的数据类型不是字符串或整数，函数将报错。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
// print_r(array_flip($a1));    // Array ( [red] => a [green] => b [blue] => c [yellow] => d )


// array_intersect(array1, array2) 比较两个或以上的数组的值，并返回交集
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
// print_r(array_intersect($a1, $a2));    // Array ( [a] => red [b] => green [c] => blue )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");
// print_r(array_intersect($a1,$a2,$a3)); // Array ( [a] => red )

// array_intersect_assoc(array1, array2)  比较两个或以上的数组的键、值，并返回交集
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
// print_r(array_intersect_assoc($a1,$a2)); // Array ( [a] => red [b] => green [c] => blue )

// array_intersect_key($a1,$a2,$a3) 比较两个或以上的数组的键，并返回交集
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
// print_r(array_intersect_key($a1,$a2));
/*Array
(
    [a] => red
    [c] => blue
)
*/

// array_key_exists(key, array) 检查键是否存在于数组中，区分大小写
$a=array("Volvo"=>"XC90","BMW"=>"X5");
/*if (array_key_exists('Volvo',$a)) {
    echo '键存在';
}else{
    echo '键不存在';
}*/

/*$a=array("Volvo","BMW");
if (array_key_exists(0,$a))
{
    echo "键存在！";
}
else
{
    echo "键不存在！";
}*/

// array_keys(array,value,strict) 返回包含数组中所有键的一个新数组
$a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
// print_r(array_keys($a));
/*Array
(
    [0] => Volvo
    [1] => BMW
    [2] => Toyota
)*/

// 如果提供了第二个参数，则只返回键值为该值的键名,不存在返回空数组
// print_r(array_keys($a,'Highlander'));
/*Array
(
    [0] => Toyota
)
*/
// 如果 strict 参数指定为 true，则 PHP 会使用全等比较 (===) 来严格检查键值的数据类型，默认false
$a=array(10,20,30,"10");
// print_r(array_keys($a,"10",false));
/*Array
(
    [0] => 0
    [1] => 3
)
*/
$a=array(10,20,30,"10");
// print_r(array_keys($a,"10",true));
/*Array
(
    [0] => 3
)
*/

// array_map('function',arr) 函数将用户自定义函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新值的数组
// 回调函数接受的参数数目应该和传递给 array_map() 函数的数组数目一致
$arr = ['20180000001/3.55','20180000044/3.55','20180005501/3.55','20144000001/3.55'];
// print_r(array_map(function($v){ return substr($v,0,11); },$arr));
/*Array
(
    [0] => 20180000001
    [1] => 20180000044
    [2] => 20180005501
    [3] => 20144000001
)
*/
$a1=array("Horse","Dog","Cat");
$a2=array("Cow","Dog","Rat");
// print_r(array_map(function($k,$v){ if($k === $v){ return 'same'; }else{ return 'diff'; } },$a1,$a2));
/*Array
(
    [0] => diff
    [1] => same
    [2] => diff
)
*/

// print_r(array_map(function($v){ return strtoupper($v); }, $a1));
/*Array
(
    [0] => HORSE
    [1] => DOG
    [2] => CAT
)
*/
// print_r(array_map(null,$a1,$a2)); 函数名赋值为null时，返回包含a1，a2的数组

// array_merge(array1,array2) 将两个数组或多个数组合并为一个数组
// 如果元素有相同的键，则最后的元素会覆盖其他元素
$a1=array("red","green");
$a2=array("blue","yellow");
// print_r(array_merge($a1,$a2));
/*Array
(
    [0] => red
    [1] => green
    [2] => blue
    [3] => yellow
)
*/
// 如果仅向函数输入一个数组，且键名是整数，将返回带有整数键名的新数组，键名以0开始进行重新索引
$a=array(3=>"red",4=>"green");
// print_r(array_merge($a));
/*Array
(
    [0] => red
    [1] => green
)
*/

// array_merge_recursive(array1,array2) 把一个或多个数组合并为一个数组
// 该函数与 array_merge() 函数的区别在于处理两个或更多个数组元素有相同的键名时,array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。
$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
// print_r(array_merge_recursive($a1,$a2));
/*Array
(
    [a] => red
    [b] => Array
        (
            [0] => green
            [1] => yellow
        )

    [c] => blue
)
*/
// 如果仅向 array_merge_recursive() 函数输入一个数组，结果与 array_merge() 相同，函数将返回带有整数键名的新数组，键名以 0 开始进行重新索引

// array_multisort(arr) 函数返回排序数组，输入一个或多个数组，函数先对第一个数组进行排序，接着是其他数组，如果两个或多个值相同，它将对下一个数组进行排序
// 字符串键名将被保留，但是数字键名将被重新索引，从 0 开始，并以 1 递增
$a=array("Dog","Cat","Horse","Bear","Zebra");
array_multisort($a);
// print_r($a);
/*Array
(
    [0] => Bear
    [1] => Cat
    [2] => Dog
    [3] => Horse
    [4] => Zebra
)
*/

// array_multisort(array1,sorting order,sorting type,array2,array3...)
/**
 * array1        必需,规定数组
 * sorting order 可选,规定排列顺序,SORT_ASC 默认，升序(A-Z);SORT_DESC 降序(Z-A)
 * sorting type  可选,规定排序类型
 *               SORT_REGULAR - 默认,把每一项按常规顺序排列（Standard ASCII，不改变类型）
 *               SORT_NUMERIC - 把每一项作为数字来处理。
 *               SORT_STRING - 把每一项作为字符串来处理。
 *               SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
 *               SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
 *               SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * 
 */
// 合并两个数组，并按数字降序排列
$a1=array(1,30,15,7,25);
$a2=array(4,30,20,41,66);
$num=array_merge($a1,$a2);
array_multisort($num,SORT_DESC,SORT_NUMERIC);
// print_r($num);

// 多维数组的排序
$arr = array(
    array('name'=>'lisi','order'=>1),
    array('name'=>'zhangsan','order'=>11),
    array('name'=>'wangwu','order'=>111),
);
$arr1 = array_map(create_function('$n', 'return $n["order"];'), $arr);
array_multisort($arr1,SORT_DESC,$arr );
// print_r($arr);
/*Array
(
    [0] => Array
        (
            [name] => wangwu
            [order] => 13
        )

    [1] => Array
        (
            [name] => lisi
            [order] => 12
        )

    [2] => Array
        (
            [name] => zhangsan
            [order] => 4
        )
)
*/

// array_pad(array,size,value) 向array中插入值为value直至array数组个数为size
$a=array("red","green");
// print_r(array_pad($a,5,"blue"));
/* Array
(
    [0] => red
    [1] => green
    [2] => blue
    [3] => blue
    [4] => blue
)
*/
// size设置为负数，函数会在原始数组之前插入新的元素，小于原始数组的长度，函数不会删除任何元素
// print_r(array_pad($a,-5,"blue"));
/*Array
(
    [0] => blue
    [1] => blue
    [2] => blue
    [3] => red
    [4] => green
)
*/

// array_pop(array) 删除数组中的最后一个元素
$a=array("red","green","blue");
array_pop($a);  // 返回数组的最后一个值,如果数组是空的，或者非数组，将返回 NULL
// print_r($a);
/*Array
(
    [0] => red
    [1] => green
)
*/

// array_product(array) 计算并返回数组的乘积
$a=array(5,5,2,10);
// echo(array_product($a));    //500

// array_push(array, var) 向第一个参数的数组尾部添加一个或多个元素，然后返回新数组的长度
$a=array("red","green");
// 如果用 array_push() 来给数组增加一个单元，还不如用 $array[] =，因为这样没有调用函数的额外负担
$a[] = '';
// print_r($a);
/*Array
(
    [0] => red
    [1] => green
    [2] => 
)*/

array_push($a,"blue","yellow");
// print_r($a);
/*Array
(
    [0] => red
    [1] => green
    [2] => 
    [3] => blue
    [4] => yellow
)*/
// 即使数组中有字符串键名，添加的元素也始终是数字键
$a=array("a"=>"red","b"=>"green");
array_push($a,"blue","yellow");
// print_r($a);
// Array ( [a] => red [b] => green [0] => blue [1] => yellow ) 

// array_rand(arr,num);
$a=array("red","green","blue","yellow","brown");
$random_keys=array_rand($a,3);
// print_r($random_keys);
/*Array ([0] => 0 [1] => 2 [2] => 3 )
Array ([0] => 0 [1] => 1 [2] => 3 )
Array ([0] => 1 [1] => 2 [2] => 4 )*/

// ** array_reduce(arr, function,initial) 向用户自定义函数发送数组中的值，并返回一个字符串
function myfunction($v1,$v2)
{
    // $v1 上次的值     $v2 本次的值
    return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
// print_r(array_reduce($a,"myfunction"));                             //-Dog-Cat-Horse

// initial 规定发送到函数的初始值
$a=array("Dog","Cat","Horse");
// print_r(array_reduce($a,"myfunction",5));                           //5-Dog-Cat-Horse


$a=array(10,15,20);
// print_r(array_sum($a));                                             // 45
// print_r(array_reduce($a,function($v1,$v2){ return $v1+$v2; },5));   // 50
// print_r(array_reduce($a,function($v1,$v2){ return $v1*$v2; },5));   // 15000
// print_r(array_product($a));                                         // 3000

// 2种方法:返回array('id'=>name)
$user = array(
    0 => array(
        'id' => 1,
        'name' => '张三',
        'email' => 'zhangsan@sina.com',
    ),
    1 => array(
        'id' => 2,
        'name' => '李四',
        'email' => 'lisi@163.com',
    ),
    2 => array(
        'id' => 5,
        'name' => '王五',
        'email' => '10000@qq.com',
    )
);

foreach($user as $k=>$v){
     $name2[$v['id']] = $v['name'];
}
// print_r($name2);
/*Array
(
    [1] => 张三
    [2] => 李四
    [5] => 王五
)
*/

// print_r(array_reduce($user,function($v,$w){ $v[$w['id']] = $w['name'];return $v; }));
/*Array
(
    [1] => 张三
    [2] => 李四
    [5] => 王五
)*/

// 将id作为键，重组数组
// print_r(array_column($user,null,'id'));
/*Array
(
    [1] => Array
        (
            [id] => 1
            [name] => 张三
            [email] => zhangsan@sina.com
        )
    [2] => Array
        (
            [id] => 2
            [name] => 李四
            [email] => lisi@163.com
        )
    [5] => Array
        (
            [id] => 5
            [name] => 王五
            [email] => 10000@qq.com
        )
)
*/

// array_replace(array, array1) 使用第二个数组的值替换第一个数组的值
$a1=array("red","green");
$a2=array("blue","yellow");
// print_r(array_replace($a1,$a2));
/*Array
(
    [0] => blue
    [1] => yellow
)*/

// 如果一个键存在于 array1 中同时也存在于 array2 中，第一个数组的值将被第二个数组中的值替换、新增
$a1=array("a"=>"red","b"=>"green");
$a2=array("a"=>"orange","burgundy");
// print_r(array_replace($a1,$a2));
/*Array
(
    [a] => orange
    [b] => green
    [0] => burgundy
)
*/

// 如果一个键存在于第二个数组 array2，但是不存在于第一个数组 array1，则会在第一个数组 array1 中创建这个元素
$a1=array("a"=>"red","green");
$a2=array("a"=>"orange","b"=>"burgundy");
// print_r(array_replace($a1,$a2));
/*Array
(
    [a] => orange
    [0] => green
    [b] => burgundy
)
*/

// 使用三个数组 - 最后一个数组（$a3）会覆盖之前的数组（$a1 和 $a2）
$a1=array("red","green");
$a2=array("blue","yellow");
$a3=array("orange","burgundy");
// print_r(array_replace($a1,$a2,$a3));
/*Array
(
    [0] => orange
    [1] => burgundy
)
*/

// 使用数值键 - 如果一个键存在于第二个数组中但不在第一个数组中
$a1=array("red","green","blue","yellow");
$a2=array(0=>"orange",3=>"burgundy");
// print_r(array_replace($a1,$a2));
/*Array
(
    [0] => orange
    [1] => green
    [2] => blue
    [3] => burgundy
)
*/

// array_replace_recursive(a1,a2) 递归地使用a2的值替换$a1的值
$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
// print_r(array_replace_recursive($a1,$a2));
/*Array
(
    [a] => Array
        (
            [0] => yellow
        )

    [b] => Array
        (
            [0] => black
            [1] => blue
        )

)*/

$a1=array("a"=>array("red"),"b"=>array("green","blue"));
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$a3=array("a"=>array("orange"),"b"=>array("burgundy"));
// print_r(array_replace_recursive($a1,$a2,$a3));
/*Array
(
    [a] => Array
        (
            [0] => orange
        )

    [b] => Array
        (
            [0] => burgundy
            [1] => blue
        )

)
*/

// array_replace() 与 array_replace_recursive() 的差别
$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));

$result=array_replace_recursive($a1,$a2);
// print_r($result);
/*Array
(
    [a] => Array
        (
            [0] => yellow
        )

    [b] => Array
        (
            [0] => black
            [1] => blue
        )

)
*/
$result=array_replace($a1,$a2);
// print_r($result); // Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black ) )  

// array_reverse(array1) 以相反的元素顺序返回数组
$a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
// print_r(array_reverse($a)); //  Array ( [c] => Toyota [b] => BMW [a] => Volvo )


$a=array("Volvo","XC90",array("BMW","Toyota"));
// print_r($a);
// Array ( [0] => Volvo [1] => XC90 [2] => Array ( [0] => BMW [1] => Toyota ) )
$reverse=array_reverse($a);
// print_r($reverse);
// Array ([0] => Array ([0] => BMW [1] => Toyota ) [1] => XC90 [2] => Volvo )

$preserve=array_reverse($a,true);
// 第二个参数为true，保留原始键名
// print_r($preserve);
// Array ([2] => Array ([0] => BMW [1] => Toyota ) [1] => XC90 [0] => Volvo )

// array_search(needle, arr, strict) 函数在数组中搜索某个键值，并返回对应的键名
$a=array("a"=>"5","b"=>5,"c"=>"5");
// echo array_search(5,$a);        // a
// echo array_search(5,$a,true);   // b

// array_shift(arr) 函数删除数组中第一个元素，并返回被删除元素的值
$a=array("a"=>"red","b"=>"green","c"=>"blue");
// echo array_shift($a);   // red
// print_r ($a);           // Array ( [b] => green [c] => blue ) 

// array_slice(array,start,length,preserve)   在数组中根据条件取出一段值，并返回
/**
 * array     必需,规定数组
 * start     必需,数值,规定取出元素的开始位置, 0 = 第一个元素
 *           如果该值设置为正数，则从前往后开始取
 *           如果该值设置为负数，则从后向前取 start 绝对值, -2 意味着从数组的倒数第二个元素开始
 *           
 * length    可选,数值,规定被返回数组的长度
 *           如果该值设置为整数，则返回该数量的元素
 *           如果该值设置为负数，则函数将在数组末端length远的地方终止取出
 *           如果该值未设置，则返回从 start 参数设置的位置开始直到数组末端的所有元素
 *           
 * preserve  可选,规定函数是保留键名还是重置键名,可能的值：
 *           true  -   保留键名
 *           false -   默认,重置键名
 * return    返回数组中的选定部分
 */
$a=array("red","green","blue","yellow","brown");
// print_r(array_slice($a,2));          //Array ([0] => blue [1] => yellow [2] => brown )

// print_r(array_slice($a,1,2));        // Array ([0] => green [1] => blue )

// print_r(array_slice($a,-2,1));       //Array ([0] => yellow )

// print_r(array_slice($a,1,2,true));   // Array ([1] => green [2] => blue )

// 如果数组有字符串键，所返回的数组将保留键名
$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"brown");
// print_r(array_slice($a,1,2));        // Array ([b] => green [c] => blue )

$a=array("0"=>"red","1"=>"green","2"=>"blue","3"=>"yellow","4"=>"brown");
// print_r(array_slice($a,1,2));        //Array ([0] => green [1] => blue )

// array_splice(array,start,length,array) 从数组中移除元素，并用新元素取代它
/**
 * array    必需,规定数组
 * start    必需,数值,规定删除元素的开始位置
 *          0 = 第一个元素
 *          如果该值设置为正数，则从数组中该值指定的偏移量开始移除
 *          如果该值设置为负数，则从数组末端倒数该值指定的偏移量开始移除
 *          -2 意味着从数组的倒数第二个元素开始
 * length   可选,数值,规定被移除的元素个数，也是被返回数组的长度
 *          如果该值设置为正数，则移除该数量的元素
 *          如果该值设置为负数，则移除从 start 到数组末端倒数 length 为止中间所有的元素
 *          如果该值未设置，则移除从 start 参数设置的位置开始直到数组末端的所有元素
 * array    可选,规定带有要插入原始数组中元素的数组
 *          如果只有一个元素，则可以设置为字符串，不需要设置为数组
 * return   返回由被提取元素组成的数组
 */

// 返回由被提取元素组成的数组
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
// print_r(array_splice($a1,0,2,$a2)); // Array ([a] => red [b] => green )
array_splice($a1,0,2,$a2);
// print_r($a1); // Array ([0] => purple [1] => orange [c] => blue [d] => yellow )
array_splice($a1,1,0,$a2);
// print_r($a1); 
// Array ([a] => red [0] => purple [1] => orange [b] => green [c] => blue [d] => yellow )

// array_sum($arr) // 返回数组中所有值的和

// array_unique($a1)    删除数组中的重复值。
$a=array("a"=>"red","b"=>"green","c"=>"red");
// print_r(array_unique($a));   // Array ([a] => red [b] => green )

// array_unshift(array, var)   将var插入到array开头
array_unshift($a, 'blue');
// print_r($a);                 // Array ([0] => blue [a] => red [b] => green [c] => red )

// array_values(arr)    返回数组的所有值
$a=array("Name"=>"Bill","Age"=>"60","Country"=>"USA");
// print_r(array_values($a));   // Array ([0] => Bill [1] => 60 [2] => USA )

// array_walk(array,myfunction,userdata...) 对数组中的每个元素应用用户自定义函数

$a=array("a"=>"red","b"=>"green","c"=>"blue");
// array_walk($a,function($v,$k){ echo "The key $k has the value $v \n"; });
/*The key a has the value red 
The key b has the value green 
The key c has the value blue*/

// 设置一个参数
// array_walk($a,function($v,$k,$p){ echo "$k $p $v \n"; },'has the value');
/*a has the value red 
b has the value green 
c has the value blue 
*/

// 更改一个数组元素的值（请注意 &$value）
array_walk($a,function(&$v){ $v='555'; });
// print_r($a);         Array ([a] => 555 [b] => 555 [c] => 555 )

// array_walk_recursive(input, funcname) 对数组中的每个元素应用用户自定义函数
function myfunctions($value,$key)
{
echo "键 $key 的值是 $value 。\n";
}
$a1=array("a"=>"red","b"=>"green");
$a2=array($a1,"1"=>"blue","2"=>"yellow");
// array_walk_recursive($a2,"myfunctions");
/*键 a 的值是 red 。
键 b 的值是 green 。
键 1 的值是 blue 。
键 2 的值是 yellow 。
*/

$age=array("Steve"=>"56","Bill"=>"60","Mark"=>"31");
sort($age);     // 按照值对关联数组进行升序排序,不保持索引关系
// print_r($age);  Array ([0] => 31 [1] => 56 [2] => 60 )

asort($age);    // 按照值对关联数组进行升序排序,保持索引关系
// print_r($age);   Array ([Mark] => 31 [Steve] => 56 [Bill] => 60 )

rsort($age);    // 按照值对关联数组进行降序排序,不保持索引关系
// print_r($age);  Array ([0] => 60 [1] => 56 [2] => 31 )

arsort($age);   // 按照值对关联数组进行降序排序,保持索引关系
// print_r($age);Array ([Bill] => 60 [Steve] => 56 [Mark] => 31 )

ksort($age);    // 按照键对关联数组进行升序排序,保持索引关系
// print_r($age);  Array ([Bill] => 60 [Mark] => 31 [Steve] => 56 )

krsort($age);   // 按照键对关联数组进行降序排序,保持索引关系
// print_r($age);  Array ([Steve] => 56 [Mark] => 31 [Bill] => 60 )

// compact(var1,var2...)    创建一个包含变量名和它们的值的数组
$firstname = "Bill";
$lastname = "Gates";
$age = "60";
$result = compact("firstname", "lastname", "age");

// print_r($result);Array ([firstname] => Bill [lastname] => Gates [age] => 60 )

// 使用不匹配变量的字符串，以及一个变量名数组：
$name = array("firstname", "lastname");
$result = compact($name, "location", "age");

// print_r($result);Array ([firstname] => Bill [lastname] => Gates [age] => 60 )

// count(array,mode)       // 返回数组中元素的数目,mode为1时计算多维数组中的所有元素
$cars=array("Volvo","BMW","Toyota");
// echo count($cars);   //3

$people = array("Bill", "Steve", "Mark", "David");

// echo current($people) . "\n";    // 当前元素是 Bill
// echo next($people) . "\n";       // Bill 的下一个元素是 Steve
// echo current($people) . "\n";    // 现在当前元素是 Steve
// echo prev($people) . "\n";       // Steve 的上一个元素是 Bill
// echo end($people) . "\n";        // 最后一个元素是 David
// echo prev($people) . "\n";       // David 之前的元素是 Mark
// echo current($people) . "\n";    // 目前的当前元素是 Mark
// echo reset($people) . "\n";      // 把内部指针移动到数组的首个元素，即 Bill
// echo next($people) . "\n";       // Bill 的下一个元素是 Steve

// print_r (each($people)); // 返回当前元素的键名和键值（目前是 Steve），并向前移动内部指针

$a = "Original";
$my_array = array("a" => "Cat", "b" => "Dog", "c" => "Horse");

extract($my_array, EXTR_PREFIX_SAME, "dup");

// echo "\$a = $a; \$b = $b; \$c = $c; \$dup_a = $dup_a \n";

// in_array(search,array,type) 搜索数组中是否存在指定的值
/*search 必需,规定要在数组搜索的值
array 必需,规定要搜索的数组
type 可选,如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同*/

// list()  将数组中的值赋给一些变量
$my_array = array("Dog","Cat","Horse");

list($a, $b, $c) = $my_array;
// echo "I have several animals, a $a, a $b and a $c.";
// I have several animals, a Dog, a Cat and a Horse.
list($a, , $c) = $my_array;
// echo "我在这里只用了 $a 和 $c 变量。";
// 我在这里只用了 Dog 和 Horse 变量。


// natcasesort() 函数用"自然排序"算法对数组进行排序，键值保留它们原始的键名
$temp_files = array("temp15.txt","Temp10.txt", "temp1.txt","Temp22.txt","temp2.txt");

natsort($temp_files);
// echo "自然排序："; print_r($temp_files); echo "\n";
// 自然排序：Array ([1] => Temp10.txt [3] => Temp22.txt [2] => temp1.txt [4] => temp2.txt [0] => temp15.txt )

natcasesort($temp_files);
// echo "不区分大小写的自然排序："; print_r($temp_files);echo "\n";
// 不区分大小写的自然排序：Array ([2] => temp1.txt [4] => temp2.txt [1] => Temp10.txt [0] => temp15.txt [3] => Temp22.txt )

// range(low,high,step)    返回包含从 low 到 high , step步长的元素的数组
$letter = range("a","d");
// print_r ($letter);  Array ([0] => a [1] => b [2] => c [3] => d )
$number = range(1,50,10);
// print_r ($number);  Array ([0] => 1 [1] => 11 [2] => 21 [3] => 31 [4] => 41 )

// shuffle() 把数组中的元素按随机顺序重新排列
$my_array = array("red","green","blue","yellow","purple");

shuffle($my_array);
// print_r($my_array); Array ([0] => yellow [1] => purple [2] => red [3] => green [4] => blue )

$my_array = array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"purple");
shuffle($my_array);
// print_r($my_array); Array ([0] => yellow [1] => red [2] => blue [3] => purple [4] => green )

// sizeof()    count() 的别名


// 重置数组键的几种方法：
array_column($arr,null);

// 配合first_name的值重置数组键
array_column($arr,null,'first_name');

// 键名是整数,重置数组键
array_merge($arr);
array_merge_recursive($arr);