数组函数解析

// count
// array_key_exists  检查给定的键名或索引是否存在于数组中
// array_flip        交换数组中的键和值
// in_array          检查数组中是否存在某个值
// range             建立一个包含指定范围单元的数组 
// shuffle          打乱数组
// array_unique     移除数组中重复的值
// array_reverse    返回一个单元顺序相反的数组 
/* array_push       将一个或多个单元压入数组的末尾 还不如用 $array[] =（入栈） 
 * array_pop        将数组最后一个单元弹出（出栈）
 * array_shift      将数组开头的单元移出数组
 * array_unshift    在数组开头插入一个或多个单元，所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变。返回 array 数组新的单元数目。
 */
// sort              对数组排序
// asort             对数组进行排序并保持索引关系
// ksort             对数组按照键名排序
// array_values     返回数组中所有的值
// natsort —       用“自然排序”算法对数组排序
// natcasesort  —  用“自然排序”算法对数组进行不区分大小写字母的排序
// uasort —        使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
// usort            使用用户自定义的比较函数对数组中的值进行排序
// array_multisort  对多个数组或多维数组进行排序
// array_slice —   从数组中取出一段
// array_splice —  把数组中的一部分去掉并用其它值取代
// array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
// array_merge —   合并一个或多个数组如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。 如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引

// array_intersect  计算数组的交集
// array_diff —     计算数组的差集
// array_rand —     从数组中随机取出一个或多个单元
// array_sum —      计算数组中所有值的和
// array array_keys ( array $input [, mixed $search_value [, bool $strict ]] 如果指定了可选参数  search_value，则只返回该值的键名。否则 input 数组中的所有键名都会被返回。
// 自 PHP 5 起，可以用  trict 参数来进行全等比较（===）。
// array_search —       在数组中搜索给定的值，如果成功则返回相应的键名
// array_count_values    统计数组中所有的值出现的次数
// array_filter —       用回调函数过滤数组中的单元
// array_walk            对数组中的每个成员应用用户函数(一般情况用户函数接受两个参数如用户函数有第三个参数可以用第三个函数传递)
// array_map —          将回调函数作用到给定数组的单元上 array_map() 返回一个数组，该数组包含了 arr1 中的所有单元经过 callback 作用过之后的单元。
// callback               接受的参数数目应该和传递给 array_map() 函数的数组数目一致。 


/*
 * count 函数
 * 作用:计算数组的单元个数[或对象的属性个数]
 *
 * 注:count函数的参数,可以是数组,也可以是"非数组"
 * 返回值分3种情况讨论
 * 1: 数组/对象, 返回数组的单元个数/对象的属性个数
 * 2: NULL ,返回0
 * 3: 非数组,也非NULL,通通返回1
 * 4.第二个参数代表是否递归计算多维数组的个数。
 */


$arr = array("a", "b", "c", "d");
echo count($arr), "<br />";
//输出：4


$arr = array("a", "b", "c", array("d", "e", array("g")));
echo count($arr) . "<br/>";
//输出：4
//第二个参数设为以下几种类型，将递归地对数组计数。对计算多维数组的所有单元尤其有用。
echo count($arr, COUNT_RECURSIVE) . "<br/>";
echo count($arr, true) . "<br/>";
echo count($arr, 1) . "<br/>";
//输出：6


/* array_key_exists 与 isset 区别
 * array_key_exists 是对数组键的一个检查。
 * isset 当值为 null 是返回 false
 */
$search_array = array("first" => null, "second" => 4);
var_dump(isset($search_array['first']));
//输出：bool(false)
var_dump(array_key_exists("first", $search_array));
//输出：bool(true)


// array_flip 交换键值, 即值做键，键做值
$arr = array(0 => "a", 1 => "b", 2 => "b", 3 => "c");
//当后面键名重复，后面会覆盖前面的
print_r(array_flip($arr));
//输出：Array ( [a] => 0 [b] => 2 [c] => 3 )

//写一个函数判断某个值在不在数组中
function inarr($arr, $val) {
    $find = false;
    foreach ($arr as $v) {
        if ($val === $v) {
            $find = true;
        }
        return $find;
    }
}
$val = "a";
var_dump(inarr($arr, $val));
//也可以用 in_array
var_dump(in_array($val, $arr));
//输出：bool(true)


/*
 * range() : 生成一个指定范围的数组
 * 第三个参数是步长
 */
$arr = range(1, 10);
$arr = range(1, 10, 1);
print_r($arr);
//输出：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 [7] => 8 [8] => 9 [9] => 10 )
$arr = range(1, 10, 2);
print_r($arr);
//输出：Array ( [0] => 1 [1] => 3 [2] => 5 [3] => 7 [4] => 9 )
$arr = range(1, 10, 3);
print_r($arr);
//输出：Array ( [0] => 1 [1] => 4 [2] => 7 [3] => 10 )
//对数组中所有值求和
echo array_sum($arr);
/*
 * shuffle 打乱数组
 * 数组本身被打乱了,因为 shuffle 函数,是引用传值
 */
if (shuffle($arr)) {
    echo "打乱成功-----";
    print_r($arr);
}


//写一个函数去重复的值
$arr = array("a", "b", "a", "c", "d", "e", "f", "f", "f");
function uni($arr) {
    $temp = array();
    foreach ($arr as $v) {
        if (!in_array($v, $temp)) {
            $temp[] = $v;
        } else {
            continue;
        }
    }
    return $temp;
}
print_r(uni($arr));
//系统函数
print_r(array_unique($arr));
//输出：Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f )


$arr = array("a" => "春", "b" => "夏", "c" => "秋", "d" => "冬");
//此时,对于索引数组,索引没调过来,只调换的值
print_r(array_reverse($arr));
//输出：Array ( [d] => 冬 [c] => 秋 [b] => 夏 [a] => 春 )
//索引也调换了
print_r(array_reverse($arr), true);


/* 队列,就像人排队来新人,站队伍的后面  先进先出
 * 栈: 就像从枪口上子弹，后进先出
 * 数组完全可以达到队列和栈的效果
 * 需要用到以下几个函数
 * array_push
 * array_pop
 * array_shift
 * array_unshift
 * 从后往前读数组,读出来的单元,追加到一个备用数组里
 */
function rev($arr) {
    $rev = array();
    while (count($arr)) {
        //弹出
        $v = array_pop($arr);
        //最加
        array_push($rev, $v);
    }
    return $rev;
}
$arr = array("a" => "春", "b" => "夏", "c" => "秋", "d" => "冬");
print_r(rev($arr));
//输出：Array ( [0] => 冬 [1] => 秋 [2] => 夏 [3] => 春 )


//把 "1234567" 转换成 "1,234,567"
function formatstr($str) {
    $bak = array();
    //将字符串转换为数组 Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 )
    $arr = str_split($str);
    $i = 1;
    //!!$cnt = $cnt（不为空）
    while (!!$cnt = count($arr)) {
        //将 $arr 数组末尾弹出加入到 $bak 数组中
        array_unshift($bak, array_pop($arr));
        $i++;
        //$cnt! = 1 防止出现第一个字符就是，号
        if ($i % 4 == 0 && $cnt != 1) {
            array_push($arr, ",");
        }
    }
    return implode($bak);
}
$str = "1234567";
print_r(formatstr($str));
//用系统函数
print_r(number_format($str));
//输出：1,234,567


/*
 * array_key
 * 第三个参数匹配
 * 第二个参数类型要相同
 */
$lamp = array("a" => "Linux", "b" => "Apache", "c" => "MySQL", "d" => "PHP");
print_r(array_keys($lamp));
//输出：Array ( [0] => a [1] => b [2] => c )
print_r(array_keys($lamp, "Apache"));
//使用第二个可选参数输出：Array ( [0] => b)

//声明一个数组，其中元素的值有整数10和字符串”10”
$a = array(10, 20, 30, "10");
print_r(array_keys($a, "10", false));
//使用第三个参数 false 输出：Array ( [0] => 0 [1] => 3 )

//声明一个数组，其中元素的值有整数 10 和字符串”10”
$a = array(10, 20, 30, "10");
print_r(array_keys($a, "10", true));
//使用第三个参数 true 输出：Array ( [0] => 3)


//声明一个带有重复值的数组
$array = array(1, "php", 1, "mysql", "php");
//统计数组 $array 中所有值出现的次数
$newArray = array_count_values($array);
print_r($newArray);
//输出：Array([1] => 2 [php] => 2 [mysql] => 1)


/*
 * 回调数组函数
 * 自定义函数 myFun，为数组过滤设置条件
 * @param   int $var   数组中的一个元素值
 * @return  bool        如果参数能被2整除则返回真
 */
function myFun($var) {
    //过滤条件函数
    if ($var % 2 == 0)
        return true;
}
$array = array("a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5);
print_r(array_filter($array, "myFun"));
//输出：Array ( [b] => 2 [d] => 4 )


/*
 * 定义一个可以作为回调的函数，名称为 myfun1
 * @param   string  $key   一个字符串参数，接收数组的键
 * @param   string  $value 一个字符串参数，接收数组的值
 */
//函数要两个参数
function myfun1($value, $key) {
    echo "The key $key has the value $value<br>";
}
//定义一个数组 $lamp
$lamp = array("a" => "Linux", "b" => "Apache", "c" => "Mysql", "d" => "PHP");
array_walk($lamp, "myfun1");
print_r($lamp);
/*
 * 输出：The key a has the value Linux
 * The key b has the value Apache
 * The key c has the value Mysql
 * The key d has the value PHP
 * Array ( [a] => Linux [b] => Apache [c] => Mysql [d] => PHP )
 */


/*
 * 定义一个可以作为回调的函数，名称为 myfun2
 * @param   string  $key   一个字符串参数，接收数组的键
 * @param   string  $value 一个字符串参数，接收数组的值
 * @param   string  $p 一个字符串参数，接收一个自定义的连接符号字符串
 */
function myfun2($value, $key, $p) {
    echo "$key $p $value <br>";
}
//使用 array_walk 函数传入三个参数
array_walk($lamp, "myfun2", "has the value");
/* 输出：
 * a has the value Linux
 * b has the value Apache
 * c has the value MySQL
 * d has the value PHP
 */


/*
 * 定义一个可以作为回调的函数，名称为 myfun3，改变数组元素的值
 * @param   string  $value	一个引用参数，接收数组变量，请注意 &$value 传入引用
 * @param   string  $key   一个字符串参数，接收数组的键
 */
function myfun3(&$value, $key) {
    //将改变原数组中每个元素的值
    $value = "Web";
}
//使用 array_walk 函数传入两个参数，其中第一个参数为引用
array_walk($lamp, "myfun3");
print_r($lamp);
//输出：Array ( [a] => Web [b] => Web [c] => Web [d] => Web )


function myfun4($v) {
    //如果数组中元素的值恒等于 MySQL 条件成功
    if ($v === "MySQL") {
        //返回 Oracle
        return "Oracle";
    }
    //不等于 MySQL 的元素都返回传入的值，即原型返回
    return $v;
}
//声明一个有 4 个元素的数组 $lamp
$lamp = array("Linux", "Apache", "MySQL", "PHP");
//使用 array_map() 函数传入一个函数名和一个数组参数
print_r(array_map("myfun4", $lamp));
//输出Array ( [0] => Linux [1] => Apache [2] => Oracle [3] => PHP )


/*
 * 声明一个函数使用多个参数, 回调函数接受的参数数目应该和传递给 array_map() 函数的数组数目一致
 * 自定义一个函数需要两个参数，两个数组中的元素依次传入
 * @param   mixed   $v1    数组中前一个元素的值
 * @param   mixed   $v2    数组中下一个元素的值
 * @return  string      提示字符串
 */
function myfun5($v1, $v2) {
    //如果两个数组中的元素值相同则条件成功
    if ($v1 === $v2) {
        //返回 same, 说明两个数组中对应的元素值相同
        return "same";
    }
    //如果两个数组中对应的元素值不同，返回 different
    return "different";
}
//声明数组 $a1,有三个元素
$a1 = array("Linux", "PHP", "MySQL");
//数组 $a1 第二个元素值和 $a2 中第二个元素的值相同
$a2 = array("Unix", "PHP", "Oracle");
//使用 array_map() 函数传入多个数组
print_r(array_map("myfun5", $a1, $a2));
//输出：Array ( [0] => different [1] => same [2] => different )


//当自定义函数名设置为 null 时的情况
//声明一个数组 $a1, 有两个元素
$a1 = array("Linux", "Apache");
//声明另一个数组 $a2,也有两个元素
$a2 = array("MySQL", "PHP");
//通过第一个参数设置为 NULL，构造一个数组的数组
print_r(array_map(null, $a1, $a2));
/* 输出：Array (
 *           [0] => Array (
 *                      [0] => Linux
 *                      [1] => MySQL
 *                  )
 *           [1] => Array (
 *                      [0] => Apache
 *                      [1] => PHP
 *                  )
 *      )
 */


$input = array("Linux", "Apache", "MySQL", "PHP");
//原数组中的第二个元素后到数组结尾都被删除
array_splice($input, 2);
print_r($input);
//输出：Array ( [0] => Linux [1] => Apache )


$input = array("Linux", "Apache", "MySQL", "PHP");
//从第二个开始移除直到数组末尾倒数第一个为止中间所有的元素
array_splice($input, 1, -1);
print_r($input);
//输出：Array ( [0] => Linux [1] => PHP )


//声明第一个数组作为参数1
$a1 = array("OS", "WebServer", "DataBase", "Language");
//声明第二个数组作为参数2
$a2 = array("Linux", "Apache", "MySQL", "PHP");
//使用 arrray_combine() 将两个数组合并
print_r(array_combine($a1, $a2));
//输出：Array ( [OS] => Linux [WebServer] => Apache [DataBase] => MySQL [Language] => PHP )


$a1 = array("a" => "Linux", "b" => "Apache");
$a2 = array("c" => "MySQL", "b" => "PHP");
print_r(array_merge($a1, $a2));
//输出： Array ( [a] => Linux [b] => PHP [c] => MySQL )


//仅使用一个数组参数则键名以 0 开始进行重新索引
$a = array(3 => "PHP", 4 => "MySQL");
print_r(array_merge($a));
//输出：Array ( [0] => PHP [1] => MySQL )


$lamp = array("a" => "Linux", "b" => "Apache", "c" => "MySQL", "d" => "PHP");
//随机从数组 $lamp 中取一个元素的键值，例如 b
echo array_rand($lamp, 1);
//通过随机的一个元素的键值获取数组中一个元素的值
echo $lamp[array_rand($lamp)] . "<br>";
//随机从数组 $lamp 中取两个元素的键值赋给数组 $key
$key = array_rand($lamp, 2);
//通过数组$key中第一个值获取数组 $lamp 中一个元素的值
echo $lamp[$key[0]] . "<br>";
//通过数组 $key 中第二个值获取数组 $lamp 中另一个元素的值
echo $lamp[$key[1]] . "<br>";