php中数组函数的应用

最新推荐文章于 2022-10-20 23:30:45 发布
最新推荐文章于 2022-10-20 23:30:45 发布
阅读量1.4k 收藏 6
点赞数 1
分类专栏： PHP学习之旅 文章标签： PHP 数组函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27511945/article/details/88119152
版权

说到PHP数组，作为一个写PHP有着5年经验的程序员，觉得每一次都要靠度娘来去想起该用什么函数，会特别麻烦，于是下定决心去了解每一个常见的数组函数。
这一章节主要归结函数的基础用法：

array_change_key_case

/**
 * array_change_key_case($input, $case)
 * 将数组的所有的键转换为大写字母或者小写字母
 * @param $input 必须|数组
 * @param $case  可选|默认值，CASE_LOWER(小写字母)| CASE_UPPER(大写字母)
 * @return  键为大写或者小写的数组|false(当array传进来是非数组时）
 */
  1. 将数组的所有的键转换为小写字母
$input = ['Name' => 'Susunma', 'hobby' => 'Music', 'AGE' => 18];
print_r(array_change_key_case($input, CASE_LOWER));
//Array ( [name] => Susunma [hobby] => Music [age] => 18 )
  1. 将数组的所有的键转换为大写字母
$input = ['Name' => 'Susunma', 'hobby' => 'Music', 'AGE' => 18];
print_r(array_change_key_case($input, CASE_UPPER));
//Array ( [NAME] => Susunma [HOBBY] => Music [AGE] => 18 )
  1. 当$input中有数字索引时，数字索引不变，但仍会转变数组当中的字符串索引
$input = ['Susunma', 'Loves', 'Music', 'Age' => 18];
print_r(array_change_key_case($input));
//Array ( [0] => Susunma [1] => Loves [2] => Music [age] => 18 )
  1. 当函数执行后，有两个或两个以上相等的键，则前面的元素会被最后一个覆盖
$input = ['Name' => 'Susunma', 'hobby' => 'Music', 'AGE' => 18, 'Age' => 28];
print_r(array_change_key_case($input));
//Array ( [name] => Susunma [hobby] => Music [age] => 28 )

array_count_values

/**
 * array_count_values($input)
 * 对数组中所有的值进行计数
 * @param $input 必需|数组
 * @return array 数组, 键为原数组中去重后的值, 值为该值在原数组中出现的次数
 */
  1. 计数时，区分大小写
$input = ['Apple', 'Banana', 'APPLE', 'PEAR', 'Banana'];
print_r(array_count_values($input));
//Array ( [Apple] => 1 [Banana] => 2 [APPLE] => 1 [PEAR] => 1 )
  1. 对于二维以及二维以上的数组无法计数,将返回空数组
$input = [ ['Apple'], ['Banana'], ['APPLE'], ['PEAR'], ['Banana']];
print_r(array_count_values($input));
//Array ( ) 这里会出现Warning: array_count_values(): Can only count STRING and INTEGER values!

array_column

/**
 * array_column($input, $column_key, $index_key)
 * 返回数组中某一列的值
 * @param $input 必需|数组
 * @param $column_key 必需|需要返回值的列, 可以是整数索引，也可以是字符串索引
 * @param $index_key  可选|选择的列的值将作为结果数组的新索引
 * @return array 数组
 */
$input = [
    ['Name' => 'Susunma', 'Job' => 'Programmer', 'age' => 28],
    ['Name' => 'Winnie', 'Job' => 'Foreign Sales', 'age' => 25],
    ['Name' => 'Peng', 'Job' => 'Operater', 'age' => 24],
];
  1. 返回数组中的name列
print_r(array_column($input, 'Name')); echo "</br>";
//Array ( [0] => Susunma [1] => Winnie [2] => Peng )
  1. 当$column_key为空时，将返回整个数组
print_r(array_column($input, null)); echo "</br>";
//Array ( [0] => Array ( [Name] => Susunma [Job] => Programmer [age] => 28 )
//        [1] => Array ( [Name] => Winnie [Job] => Foreign Sales [age] => 25 )
//        [2] => Array ( [Name] => Peng [Job] => Operater [age] => 24 ) )
  1. 把Name列的值作为整个数组的键
print_r(array_column($input, null, 'Name')); echo "</br>";
//Array ( [Susunma] => Array ( [Name] => Susunma [Job] => Programmer [age] => 28 )
//        [Winnie] => Array ( [Name] => Winnie [Job] => Foreign Sales [age] => 25 )
//        [Peng] => Array ( [Name] => Peng [Job] => Operater [age] => 24 ) )
  1. 返回一个以数组中的age的值列为值，以Name列的值为对应键的新数组
print_r(array_column($input, 'age', 'Name')); echo "</br>";
// Array ( [Susunma] => 28 [Winnie] => 25 [Peng] => 24 )
  1. 返回数组中索引值为0的列
$input = [
    ['Susunma', 'Programmer', 28],
    ['Winnie', 'Foreign Sales', 25],
    ['Peng', 'Operater', 24],
];
print_r(array_column($input, 0)); echo "</br>";
//Array ( [0] => Susunma [1] => Winnie [2] => Peng )

array_chunk

/**
 * array_chunk($input, $size, $preserve_key)
 * 把数组分割为新的数组块
 * @param $input 必需|数组
 * @param $size  必需|规定每个新数组包含的元素个数
 * @param $preserve_key 可选|bool值|默认值,false,表示结果数组使用从零开始的整数索引|true,表示保留原数组里的键名
 * @return array 数组
 */
$input = ['flavor1' => ['sour', 'sweet'], 'falvor2' => ['bitter', 'hot'], 'yeah'];
  1. 把数组分割为带有两个元素的数组
print_r(array_chunk($input, 2)); echo "</br>";
//Array ( [0] => Array ( 
//			[0] => Array ( [0] => sour [1] => sweet ) 
//			[1] => Array ( [0] => bitter [1] => hot ) 
//         )
//        [1] => Array ( [0] => yeah ) 
//       )
  1. 把数组分割为带有两个元素的数组,并且保留原数组的键
print_r(array_chunk($input, 2, true)); echo "</br>";
//Array ( [0] => Array ( 
//		[flavor1] => Array ( [0] => sour [1] => sweet
//		[falvor2] => Array ( [0] => bitter [1] => hot ) )
//       [1] => Array ( [0] => yeah ) 
//      )

array_combine

/**
 * array_combine($input1, $input2)
 * 合并两个数组，第一个数组的值为键名， 第二个数组的值为键值
 * @param $input1 必需|数组
 * @param $input2  必需|数组
 * @return array 数组
 */
  1. 合并数组, 不管两个数组中的键是什么，都不影响合成的结果数组
$input1 = ['Susunma', 'Winnie', 'Peng'];
$input2 = [28, 25, 24];
$input3 = ['age' => 28, 25, 24];
print_r(array_combine($input1, $input2)); echo "</br>";
//Array ( [Susunma] => 28 [Winnie] => 25 [Peng] => 24 )

print_r(array_combine($input1, $input3)); echo "</br>";
//Array ( [Susunma] => 28 [Winnie] => 25 [Peng] => 24 )
  1. 当合并的两个数组中，有元素的类型是数组的话, 会强制转成string
$input4 = [['Sing', 'Dance'], 'Dance', 'Game'];
print_r(array_combine($input4, $input1)); echo "</br>";
//Array ( [Array] => Susunma [Dance] => Winnie [Game] => Peng ) 这里会出现Notice: Array to string conversion
  1. 当两个数组的元素个数不相同时，不能合成
$input4 = ['Susunma', 'Winnie', 'Peng', 'Ally'];
print_r(array_combine($input4, $input2)); echo "</br>";
//Warning: array_combine(): Both parameters should have an equal number of elements

array_diff

/**
 * array_diff($input1, $input2, $input3...)
 * 比较多个数组，只比较键值
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，但是不在其他任何数组中的键名和键值
 */
  1. 只比较数组的值，不管键是否一样
$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['e' => 'Susunma', 'f' => 'Winnie'];

print_r(array_diff($input1, $input2)); echo "</br>";
//Array ( [c] => Peng )

array_diff_assoc

/**
 * array_diff_assoc($input1, $input2, $input3...)
 * 比较多个数组，比较键名与键值
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，但是不在其他任何数组中的键名和键值
 */
  1. 比较数组的键名与键值
$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['e' => 'Susunma', 'f' => 'Winnie'];

print_r(array_diff_assoc($input1, $input2)); echo "</br>";
//Array ( [a] => Susunma [b] => Winnie [c] => Peng )

array_diff_key

/**
 * array_diff_key($input1, $input2, $input3...)
 * 比较多个数组，只比较键名
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，但是不在其他任何数组中的键名和键值
 */
  1. 比较数组的键名
$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['e' => 'Susunma', 'c' => 'Winnie'];

print_r(array_diff_key($input1, $input2)); echo "</br>";
//Array ( [a] => Susunma [b] => Winnie)

array_diff_uassoc

/**
 * array_diff_uassoc($input1, $input2, $input3...)
 * 比较多个数组，比较键名和键值，其中键名使用用户自定义函数来比较
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，但是不在其他任何数组中的键名和键值
 */
  1. 比较数组的键名与键值，其中键名使用用户自定义函数来比较
$i = 1;
function key_compare_func($a, $b)
{
    global $i;
    var_dump($a);
    var_dump($b);
    echo "=====$i".PHP_EOL;
    if ($a === $b) {
        return 0;
    }
    $i += 1;
    return ($a > $b)? 1:-1;
}

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['e' => 'Susunma', 'c' => 'Winnie'];
print_r(array_diff_uassoc($input1, $input2, "key_compare_func")); echo "</br>";
//string(1) "a"
//string(1) "b"
//=====1
//string(1) "b"
//string(1) "c"
//=====2
//string(1) "e"
//string(1) "c"
//---上面几次是数组自身的排序
//=====3
//string(1) "a"
//string(1) "c"
//=====4
//string(1) "a"
//string(1) "e"
//=====5
//string(1) "b"
//string(1) "c"
//=====6
//string(1) "b"
//string(1) "e"
//=====7
//string(1) "c"
//string(1) "c"
//=====8
//Array
//(
//    [a] => Susunma
//    [b] => Winnie
//    [c] => Peng
//)

array_diff_ukey

/**
 * array_diff_ukey($input1, $input2, $input3...)
 * 比较多个数组，只比较键名, 使用用户自定义函数来比较
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，但是不在其他任何数组中的键名和键值
 */
  1. 比较数组的键名，其中键名使用用户自定义函数来比较
$i = 1;
function key_compare_func1($a, $b)
{
    global $i;
    var_dump($a);
    var_dump($b);
    echo "=====$i".PHP_EOL;
    if ($a === $b) {
        return 0;
    }
    $i += 1;
    return ($a > $b)? 1:-1;
}

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['e' => 'Susunma', 'c' => 'Winnie'];

//比较数组的键名与键值，其中键名使用用户自定义函数来比较
print_r(array_diff_ukey($input1, $input2, "key_compare_func1")); echo "</br>";
//string(1) "a"
//string(1) "b"
//=====1
//string(1) "b"
//string(1) "c"
//=====2
//string(1) "e"
//string(1) "c"
//---上面几次是数组自身的排序
//=====3
//string(1) "a"
//string(1) "c"
//=====4
//string(1) "a"
//string(1) "e"
//=====5
//string(1) "b"
//string(1) "c"
//=====6
//string(1) "b"
//string(1) "e"
//=====7
//string(1) "c"
//string(1) "c"
//=====8
//Array
//(
//    [a] => Susunma
//    [b] => Winnie
//)

array_fill

/**
 * array_fill($index, $number, $value)
 * 生成一个用指定值填充的数组
 * @param $index 必需|表示从第几个索引开始填充
 * @param $number  必需|表示总共填充几个
 * @param $value  必需|要填充的值
 * @return array 数组
 */
  1. 生成一个从索引3开始，元素个数为4，值为Susunma的数组
print_r(array_fill(3, 4, 'Susunma'));echo "</br>";
//Array ( [3] => Susunma [4] => Susunma [5] => Susunma [6] => Susunma )
  1. 生成一个从索引3开始，元素个数为4，值为[‘Susunma’]的数组
print_r(array_fill(3, 4, ['Susunma']));echo "</br>";
//Array ( [3] => Array ( [0] => Susunma ) [4] => Array ( [0] => Susunma )
// [5] => Array ( [0] => Susunma ) [6] => Array ( [0] => Susunma ) )
  1. 当起始的索引值$index小于0时，第二个索引值默认从0开始。
print_r(array_fill(-3, 4, 'Susunma'));echo "</br>";
//Array ( [-3] => Susunma [0] => Susunma [1] => Susunma [2] => Susunma )
  1. 当要生成的个数$number小于0时,无法生成
print_r(array_fill(1, -1, 'Susunma'));
//Warning: array_fill(): Number of elements can't be negative

array_fill_keys

/**
 * array_fill_keys($keys, $value)
 * 使用指定数组的值来当键，并使用指定值来填充数组
 * @param $keys 必需|指定数组
 * @param $value  必需|填充值
 * @return array 数组
 */
$keys = ['name', 'alias_name', 'real_name'];
  1. 使用数组$keys的值作为键，并用Susunma字符串来填充值
print_r(array_fill_keys($keys, 'Susunma'));echo "</br>";
//Array ( [name] => Susunma [alias_name] => Susunma [real_name] => Susunma )
  1. 使用数组$keys的值作为键，并用[‘Susunma’]数组来填充值
print_r(array_fill_keys($keys, ['Susunma']));echo "</br>";
//Array ( [name] => Array ( [0] => Susunma ) [alias_name] => Array ( [0] => Susunma )
//        [real_name] => Array ( [0] => Susunma ) )
  1. 当$keys是关联数组时,不影响结果数组
$keys = ['a' => 'name', 'b' =>'alias_name', 'c' =>'real_name'];
print_r(array_fill_keys($keys, 'Susunma'));echo "</br>";
//Array ( [name] => Susunma [alias_name] => Susunma [real_name] => Susunma )

array_filter

/**
 * array_filter($input, $callback)
 * 用回调函数来过滤数组中的值, 当回调函数返回true,键值保留,返回false时，去掉该键值
 * @param $input 必需|指定数组
 * @param $callback  必需|填充值
 * @return array 数组
 */
  1. 过滤掉数组中的偶数,保留的键值不变
function test_odd($var)
{
    return($var & 1);
}
$a1=array(-1, -2, 0, 2, 3, 4, 5, 6, 7, 8, 9);
print_r(array_filter($a1,"test_odd"));echo "</br>";
//Array ( [0] => -1 [4] => 3 [6] => 5 [8] => 7 [10] => 9 )
  1. 过滤掉数组中的负数
function test($var){
    return $var > 0;
}
print_r(array_filter($a1, 'test'));
//Array ( [3] => 2 [4] => 3 [5] => 4 [6] => 5 [7] => 6 [8] => 7 [9] => 8 [10] => 9 )

array_flip

/**
 * array_flip($input)
 * 交换数组中的键和值
 * @param $input 必需|指定数组
 * @return array 数组
 */
  1. 交换字符串关联数组,当交换后有多个键相同，则保留最后一个
$input = ['warm' => 'spring', 'hot' => 'summer', 'cool' => 'autumn', 'cold' => 'winter', 'colder' => 'winter'];
print_r(array_flip($input));
//Array ( [spring] => warm [summer] => hot [autumn] => cool [winter] => colder )
  1. 当要交换的数组的值不是字符串或者整数时，无法交换
$input = ['warm' => ['spring'], 'hot' => ['summer'], 'cool' => ['autumn'], 'cold' => ['winter']];
print_r(array_flip($input));
//Warning: array_flip(): Can only flip STRING and INTEGER values!

array_intersect

/**
 * array_intersect($input1, $input2, $input3...)
 * 比较多个数组，只比较键值
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，同时也在其他任何数组中的键名和键值
 */

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['e' => 'Susunma', 'f' => 'Winnie'];

//只比较数组的值，不管键是否一样
print_r(array_intersect($input1, $input2)); echo "</br>";
//Array ( [a] => Susunma [b] => Winnie )

array_intersect_assoc

/**
 * array_intersect_assoc($input1, $input2, $input3...)
 * 比较多个数组，比较键名与键值
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，同时也在其他任何数组中的键名和键值
 */

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['a' => 'Susunma', 'f' => 'Winnie'];

//比较数组的键名与键值
print_r(array_intersect_assoc($input1, $input2)); echo "</br>";
//Array ( [a] => Susunma )

array_intersect_key

/**
 * array_intersect_key($input1, $input2, $input3...)
 * 比较多个数组，只比较键名
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，同时也在其他任何数组中的键名和键值
 */

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['e' => 'Susunma', 'c' => 'Winnie'];

//比较数组的键名
print_r(array_intersect_key($input1, $input2)); echo "</br>";
//Array ( [c] => Peng )

array_intersect_uassoc

/**
 * array_intersect_uassoc($input1, $input2, $input3...)
 * 比较多个数组，比较键名和键值，其中键名使用用户自定义函数来比较
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，同时也在其他任何数组中的键名和键值
 */

$i = 1;
function key_compare_func2($a, $b)
{
    global $i;
    var_dump($a);
    var_dump($b);
    echo "=====$i".PHP_EOL;
    if ($a === $b) {
        return 0;
    }
    $i += 1;
    return ($a > $b)? 1:-1;
}

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['a' => 'Susunma', 'c' => 'Winnie'];

//比较数组的键名与键值，其中键名使用用户自定义函数来比较
print_r(array_intersect_uassoc($input1, $input2, "key_compare_func2")); echo "</br>";
//string(1) "a"
//string(1) "b"
//=====1
//string(1) "b"
//string(1) "c"
//=====2
//string(1) "a"
//string(1) "c"
//---上面几次是数组自身的排序
//=====3
//string(1) "a"
//string(1) "a"
//=====4
//string(1) "b"
//string(1) "c"
//=====4
//string(1) "c"
//string(1) "c"
//=====5
//Array
//(
//    [a] => Susunma
//)

array_intersect_ukey

/**
 * array_intersect_ukey($input1, $input2, $input3...)
 * 比较多个数组，只比较键名, 使用用户自定义函数来比较
 * @param $input1 必需|数组
 * @param $input2  必需|与第一个数组比较的数组
 * @param $input3...  可选|与第一个数组比较的其他数组
 * @return array 返回的数组包含所有在第一个数组里面，同时也在其他任何数组中的键名和键值
 */

$i = 1;
function key_compare_func3($a, $b)
{
    global $i;
    var_dump($a);
    var_dump($b);
    echo "=====$i".PHP_EOL;
    if ($a === $b) {
        return 0;
    }
    $i += 1;
    return ($a > $b)? 1:-1;
}

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['a' => 'Susunma', 'c' => 'Winnie'];

//比较数组的键名，其中键名使用用户自定义函数来比较
print_r(array_intersect_ukey($input1, $input2, "key_compare_func3")); echo "</br>";
//string(1) "a"
//string(1) "b"
//=====1
//string(1) "b"
//string(1) "c"
//=====2
//string(1) "a"
//string(1) "c"
//---上面几次是数组自身的排序
//=====3
//string(1) "a"
//string(1) "a"
//=====4
//string(1) "b"
//string(1) "c"
//=====4
//string(1) "c"
//string(1) "c"
//=====5
//Array
//(
//    [a] => Susunma
//    [c] => Peng
//)

array_key_exists

/**
 * array_key_exists($key, $input)
 * 判断某个键名是否存在于数组中
 * @param $key 必需|要判断的键名
 * @param $input  必需|数组
 * @return array bool|true:存在|false:不存在
 */

$input1 = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
$input2 = ['Susunma', 'Winnie', 'Peng'];
print_r(array_key_exists('a', $input1)); echo "</br>"; //true
print_r(array_key_exists(1, $input2)); echo "</br>"; //true

array_keys

/**
 * array_keys($input)
 * 返回一个包含原数组中所有键名的新数组
 * @param $input  必需|数组
 * @return array 数组
 */

$input = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
print_r(array_keys($input)); echo "</br>";
//Array ( [0] => a [1] => b [2] => c )

array_map

/**
 * array_map($func, $input1, $input2, $input3...)
 * 把$func函数作用到$input数组里面的每个值，并且返回一个包含函数作用后的新值的数组
 * @param $func 必需|回调函数名,回调函数接受的参数数目应该和要作用的数组数目一致
 * @param $input1  必需|数组
 * @param $input2  可选|数组
 * @param $input3...  可选|多个数组
 * @return array 数组
 */
  1. 使用自定义函数来改变数组
function test_map($v){
    return $v == 'Winnie'?'Nice':$v;
}
$input = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
print_r(array_map("test_map", $input)); echo "</br>";
//Array ( [a] => Susunma [b] => Nice [c] => Peng )
  1. 作用于多个数组，当两个或两个以上数组时，结果数组将使用整数索引
function test_map1($v, $v1, $v2){
    return $v == $v1 && $v1 ==$v2?'Nice':$v2;
}
$input1 = ['d' => 'Jack', 'e' => 'Winnie', 'f' =>'Zlly'];
$input3 = ['d' => 'Ally', 'e' => 'Tenny', 'f' =>'Tom'];
print_r(array_map("test_map1", $input, $input1, $input3)); echo "</br>";
//Array ( [0] => Ally [1] => Tenny [2] => Tom )
  1. 将函数名赋值为null时,相当于重新用整数索引了多个数组，并且在对应元素上面合并了数组
$input1 = ["a" => "Dog",0 => "Cat"];
$input2 = ["Puppy","Kitten", "Sheep"];
$input3 = ["Mummy", "Daddy"];
print_r(array_map(null, $input1, $input2, $input3)); echo "</br>";
//Array ( [0] => Array ( [0] => Dog [1] => Puppy [2] => Mummy )
//        [1] => Array ( [0] => Cat [1] => Kitten [2] => Daddy )
//        [2] => Array ( [0] => [1] => Sheep [2] => ) )

array_merge

/**
 * array_merge($input, $input1...)
 * 合并多少个数组
 * @param $input  必需|数组
 * @param $input1  可选|多个数组
 * @return array 数组
 */
//1.如果合并后两个或更多个数组元素有相同的键名，则最后的元素会覆盖其他元素
$input = ["Puppy", "Kitten", "a" => "Sheep"];
$input1 = ["Mummy", "a" =>"Daddy"];
print_r(array_merge($input, $input1)); echo "</br>";
//Array ( [0] => Puppy [1] => Kitten [a] => Daddy [2] => Mummy )

array_merge_recursive

/**
 * array_merge_recursive($input, $input1...)
 * 合并多少个数组
 * @param $input  必需|数组
 * @param $input1  可选|多个数组
 * @return array 数组
 */
//1.如果两个或更多个数组元素有相同的键名，则将多个相同键名的值递归组成一个数组
$input = ["Puppy", "Kitten", "a" => "Sheep"];
$input1 = ["Mummy", "a" =>"Daddy"];
print_r(array_merge_recursive($input, $input1)); echo "</br>";
//Array ( [0] => Puppy [1] => Kitten
//        [a] => Array ( [0] => Sheep [1] => Daddy )
//        [2] => Mummy )

array_multisort

/**
 * array_multisort($input, $sorting_order, $sorting_type, $input1...)
 * 对数组排序
 * @param $input  必需|数组
 * @param $sorting_order  可选|默认,SORT_ASC,升序排列|SORT_DESC,降序排列
 * @param $sorting_type   可选|默认,SORT_REGULAR,每一项按常规顺序排列|SORT_NUMERIC, 将每一项按数字顺序排列
 *                          |SORT_STRING,将每一项按字母顺序排列|SORT_LOCALE_STRING,把每一项作为字符串来处理，基于当前区域设置
 *                          |SORT_NATURAL,把每一项作为字符串来处理，使用类似 natsort() 的自然排序
 *                          |SORT_FLAG_CASE,可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * @param $input1...  可选|多个数组
 * @return 无
 */
  1. 字符串键名被保留，数字键名将被重新索引，从0开始
$input = ["a" => "Puppy", "b" => "Kitten", "c" => "Sheep", "d" =>"Mummy", 3 => "Daddy"];
array_multisort($input);
print_r($input);echo "</br>";
//Array ( [0] => Daddy [b] => Kitten [d] => Mummy [a] => Puppy [c] => Sheep )
  1. 对多个数组排序，第一个数组是要排序的主要数组。数组中的行（值）比较为相同的话，就会按照下一个输入数组中相应值的大小进行排序
$input1 = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
$input2 = ["daughter", "son", "mother", "father"];
array_multisort($input1, SORT_DESC, $input2, SORT_ASC);
print_r($input1);echo "</br>";
//Array ( [0] => Peppa Pig [1] => Mummy Pig [2] => George [3] => Daddy Pig )
print_r($input2);echo "</br>";
//Array ( [0] => daughter [1] => mother [2] => son [3] => father ) 这里只交换了son跟mother的位置，是因为，$input1是主要排序数组，进行降序排序的时候，只交换了George跟Mummy pig的位置，就完成了降序排序，所以$input2就无须再进行另外的升序步骤，只有当主要排序数组有相同项时，才会参考其他数组的排序来定位置，这一点可以参考例子3
  1. 先按年龄从大到小排列，如果年龄相同就按照名字的顺序排序
$array[] = ["age"=>20,"name"=>"li"];
$array[] = ["age"=>21,"name"=>"ai"];
$array[] = ["age"=>20,"name"=>"ci"];
$array[] = ["age"=>22,"name"=>"di"];

foreach ($array as $key=>$value){
    $age[$key] = $value['age'];
    $name[$key] = $value['name'];
}

array_multisort($age,SORT_NUMERIC,SORT_DESC,$name,SORT_STRING,SORT_ASC,$array);
print_r($array);
//Array (   [0] => Array ( [age] => 22 [name] => di )
//          [1] => Array ( [age] => 21 [name] => ai )
//          [2] => Array ( [age] => 20 [name] => ci )
//          [3] => Array ( [age] => 20 [name] => li ) )

array_pad

/**
 * array_pad($input, $size, $value)
 * 合并多少个数组
 * @param $input 必需|数组
 * @param $size  必需|规定结果数组的元素的个数
 * @param $value 必需|规定结果数组的新元素的值
 * @return array 数组
 */
//1.当$size为负时，将在原始数组所有元素前插入新元素
$input = ["Pig", "Sheep"];
print_r(array_pad($input, -4, "Snake"));echo "</br>";
//Array ( [0] => Snake [1] => Snake [2] => Pig [3] => Sheep )

//2.当$size小于原数组的长度,原数组不变
print_r(array_pad($input, 1, "Snake"));echo "</br>";
//Array ( [0] => Pig [1] => Sheep )

array_pop

/**
 * array_pop($input)
 * 删除数组中的最后一个元素
 * @param $input 必需|数组
 * @return 数组的最后一个元素
 */

$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
print_r(array_pop($input));echo "</br>";
//Daddy Pig

$input = [['Susunma'], ['Zlly']];
print_r(array_pop($input));echo "</br>";
//Array ( [0] => Zlly )

array_product

/**
 * array_product($input)
 * 计算数组中所有元素的乘积
 * @param $input 必需|数组
 * @return integer
 */
$input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
print_r(array_product($input));echo "</br>"; //3628800

$input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 's'];
print_r(array_product($input));echo "</br>"; //0, 这里是因为数组里面存在着字符串，进行乘积运算时，会把字符串强制转成整数，即为0，所以乘积结果也为0

array_push

/**
 * array_push($input, $value1, $value2...)
 * 在数组尾部添加多个元素
 * @param $input 必需|数组
 * @param $value1 必需|要添加的值
 * @param $value12... 可选|要添加的多个值
 * @return 结果数组的长度
 */
$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
print_r(array_push($input, "Kitty", "Kate"));echo "</br>";  //6
print_r($input);echo "</br>";
//Array ( [0] => Peppa Pig [1] => George [2] => Mummy Pig [3] => Daddy Pig [4] => Kitty [5] => Kate )

array_rand

/**
 * array_rand($input, $number)
 * 随即返回一个或者多个元素的键名
 * @param $input 必需|数组
 * @param $number 可选|要随机返回的个数，默认一个
 * @return 单个键名|键名数组
 */
$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
print_r(array_rand($input));echo "</br>";  //2
print_r(array_rand($input, 2));echo "</br>"; //Array ( [0] => 2 [1] => 3 )

array_reduce

/**
 * array_reduce($input, $callback, $initial)
 * 向用户自定义函数发送数组中的值，并返回一个字符串
 * @param $input 必需|数组
 * @param $callback 必需|迭代函数名
 * @param $initial 可选|发送到函数的初始值,当成数组中的第一个值，数组为空时，作为返回值返回
 * @return 单个键名|键名数组
 */
function test_love($v1, $v2){
    return $v1.'-'.$v2;
}
$input = ['I', 'love', 'singing'];
print_r(array_reduce($input, "test_love", 'Hey'));echo "</br>";
//Hey-I-love-singing

array_replace

/**
 * array_replace($input, $input1...)
 * 使用后面的数组来替换第一个数组的值
 * @param $input 必需|数组
 * @param $input1... 可选|指定要替换$input的值的数组
 * @return 数组
 */
//1.如果一个键存在于input1中同时也存在于 input2 中，第一个数组的值将被第二个数组中的值替换
//    如果一个键只存在于后面的数组，那么会在第一个数组中创建这对键值
$input = ["a" => "Puppy", "b" => ["Peppa", "George"], "Kitten"];
$input1 = ["a" => "Mary", "b" => ["Tom"], "Jack"];
print_r(array_replace($input, $input1));echo "</br>";
//Array ( [a] => Mary [b] => Array ( [0] => Tom ) [0] => Jack )

array_replace_recursive

/**
 * array_replace_recursive($input, $input1...)
 * 递归地使用后面的数组来替换第一个数组的值
 * @param $input 必需|数组
 * @param $input1... 可选|指定要替换$input的值的数组
 * @return 数组
 */
//1.如果一个键存在于input1中同时也存在于 input2 中，第一个数组的值将被第二个数组中的值递归替换
//    如果一个键只存在于后面的数组，那么会在第一个数组中创建这对键值
$input = ["a" => "Puppy", "b" => ["Peppa", "George"], "Kitten"];
$input1 = ["a" => "Mary", "b" => ["Tom"], "Jack"];
print_r(array_replace_recursive($input, $input1));echo "</br>";
//Array ( [a] => Mary [b] => Array ( [0] => Tom [1] => George ) [0] => Jack )

array_reverse

/**
 * array_reverse($input, $preserve)
 * 以相反的元素顺序返回数组
 * @param $input 必需|数组
 * @param $preserve 可选|是否保留数字键名，非数字的键不受这个设置影响|默认，false,不保留数字键名|true, 保留数字键名
 * @return 数组
 */
$input = ["a" => "Puppy", "b" => ["Peppa", "George"], "Kitten", 2 => 'Ally'];
print_r(array_reverse($input));echo "</br>";
//Array ( [0] => Ally [1] => Kitten [b] => Array ( [0] => Peppa [1] => George ) [a] => Puppy )
print_r(array_reverse($input, true));echo "</br>";
//Array ( [2] => Ally [0] => Kitten [b] => Array ( [0] => Peppa [1] => George ) [a] => Puppy )

array_search

/**
 * array_search($value, $input, $strict)
 * 在数组$input中查找值为$value的元素，并返回对应的键名
 * @param $value 必需|要查找的值
 * @param $input 必需|数组
 * @param $strict 可选|是否要求搜索的数据类型和值都一致|默认，false,不要求一致|true, 要求一致
 * @return 键名|false
 */
// 1.如果在数组中找到键值超过一次，则返回第一次找到的键值所匹配的键名
$input = ["a" => 10, "b" => '10', "c" => '10'];
echo array_search('10', $input);echo "</br>";  //a
echo array_search('10', $input, true);echo "</br>"; //b

array_shift

/**
 * array_shift($input)
 * 删除数组中的第一个元素，并返回被删除元素的值
 * @param $input 必需|数组
 * @return 被删除元素的值
 */
//1.原数组剩余的字符串键名保持不变，剩余的数字索引将从0开始
$input = ['I', 'love', 'singing'];
echo array_shift($input);echo "</br>"; //I
print_r($input);echo "</br>";   //Array ( [0] => love [1] => singing )

$input1 = ["a" => 10, "b" => '10', "c" => '10'];
echo array_shift($input1);echo "</br>"; //10
print_r($input1);echo "</br>"; //Array ( [b] => 10 [c] => 10 )

array_slice

/**
 * array_slice($input, $start, $length, $preserve)
 * 在数组中根据条件取出一段值
 * @param $input 必需|数组
 * @param $start 必需|取出元素的开始位置, 0代表第一个元素，大于0时表示从前往后开始取，小于0时表示从后向前取start绝对值
 * @param $length 可选|规定被返回数组的长度|默认返回从start到末端的所有元素|大于0时表示返回该数量的元素，小于0时表示从start取到末端往前数length绝对值的位置
 * @param $preserve 可选|是否保留数字键名，非数字的键不受这个设置影响|默认，false,不保留数字键名|true, 保留数字键名
 * @return 数组
 */
$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
//1.从数组的第三个元素开始取出，并且返回两个元素
print_r(array_slice($input, 2, 2));echo "</br>";
//Array ( [0] => Mummy Pig [1] => Daddy Pig )

//2.从倒数第二个元素开始往后取两个元素
print_r(array_slice($input, -2, 2));echo "</br>";
//Array ( [0] => Mummy Pig [1] => Daddy Pig )

//3.取从倒数第三个元素开始到倒数第一个为止中间的所有元素
print_r(array_slice($input, -3, -1));echo "</br>";
//Array ( [0] => George [1] => Mummy Pig )

//4.字符串键名保留，整数键名从0开始索引
$input = ["Peppa Pig", "George", "b" => "Mummy Pig", "Daddy Pig"];
print_r(array_slice($input, 1, 3));echo "</br>";
//Array ( [0] => George [b] => Mummy Pig [1] => Daddy Pig )

array_splice

/**
 * array_splice($input, $start, $length, $input1)
 * 从数组中根据条件移除一段值，并用新元素取代它
 * @param $input 必需|数组
 * @param $start 必需|删除元素的开始位置, 0代表第一个元素，大于0时表示从前往后开始取，小于0时表示从后向前取start绝对值
 * @param $length 可选|规定被移除的元素个数|默认返回从start到末端的所有元素|大于0时表示返回该数量的元素，小于0时表示从start取到末端往前数length绝对值的位置
 * @param $input1 可选|规定要插入原始数组中的新数组
 * @return 被删除的元素数组
 */
//1.从数组的第三个元素开始移出两个元素,并插入新数组的元素
$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
print_r(array_splice($input, 2, 2, ['Jack']));echo "</br>";
//Array ( [0] => Mummy Pig [1] => Daddy Pig )
print_r($input);echo "</br>";
//Array ( [0] => Peppa Pig [1] => George [2] => Jack )

//2.从倒数第二个元素开始往后取两个元素
$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
print_r(array_splice($input, -2, 2));echo "</br>";
//Array ( [0] => Mummy Pig [1] => Daddy Pig )

//3.取从倒数第三个元素开始到倒数第一个为止中间的所有元素
$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
print_r(array_splice($input, -3, -1));echo "</br>";
//Array ( [0] => George [1] => Mummy Pig )

//4.字符串键名保留，整数键名从0开始索引
$input = ["Peppa Pig", "George", "b" => "Mummy Pig", "Daddy Pig"];
print_r(array_splice($input, 1, 3));echo "</br>";
//Array ( [0] => George [b] => Mummy Pig [1] => Daddy Pig )

array_sum

/**
 * array_sum($input)
 * 计算数组中所有元素的和
 * @param $input 必需|数组
 * @return integer
 */
$input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
print_r(array_sum($input));echo "</br>"; //55

$input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 's'];
print_r(array_sum($input));echo "</br>"; //55，这里是因为数组里面存在着字符串，进行求和运算时，会把字符串强制转成整数，即为0，所以求和结果还是55

array_unique

/**
 * array_unique($input, $sorting_type)
 * 移除数组中重复的值
 * @param $input 必需|数组
 * @param $sorting_type 可选|规定如何比较数组|默认 , SORT_STRING,把项目作为字符串来比较|SORT_REGULAR - 把每一项按常规顺序排列
 *                          |SORT_NUMERIC, 把每一项作为数字来处理
 *                          |SORT_LOCALE_STRING, 把每一项作为字符串来处理，基于当前区域设置
 * @return 数组
 */
//1.当几个数组元素的值相等时，只保留第一个元素，其他的元素被删除
$input = [10, 2, 3, 4, 5, 6, 7, 8, 9, 10];
print_r(array_unique($input));echo "</br>";
//Array ( [0] => 10 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 [7] => 8 [8] => 9 )

array_unshift

/**
 * array_unshift($input, $value1, $value2...)
 * 在数组开头添加多个元素
 * @param $input 必需|数组
 * @param $value1 必需|要添加的值
 * @param $value12... 可选|要添加的多个值
 * @return 结果数组的长度
 */
$input = ["Peppa Pig", "George", "Mummy Pig", "Daddy Pig"];
print_r(array_unshift($input, "Kitty", "Kate"));echo "</br>";  //6
print_r($input);echo "</br>";
//Array ( [0] => Kitty [1] => Kate [2] => Peppa Pig [3] => George [4] => Mummy Pig [5] => Daddy Pig )

array_values

/**
 * array_values($input)
 * 返回一个包含原数组中所有值的新数组
 * @param $input  必需|数组
 * @return array 数组
 */

$input = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
print_r(array_values($input)); echo "</br>";
//Array ( [0] => Susunma [1] => Winnie [2] => Peng )

array_walk

/**
 * array_walk($input, $callback, $userdata,...)
 * 对数组中的每个元素应用用户自定义函数
 * @param $input 必需|指定数组
 * @param $callback  必需|自定义函数,第一个参数接受数组元素的键值，第二个参数接受数组元素的键名
 * @param $userdata... 可选|规定用户自定义函数的参数,可以传递任意多参数
 * @return 无
 */
  1. 可以在回调函数的第一个参数指定为引用，从而改变数组元素的值
function myFunction(&$value, $key){
    $value = $value.'_'.$key;
}
$input = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
array_walk($input, 'myFunction');
print_r($input); echo "</br>"; //Array ( [a] => Susunma_a [b] => Winnie_b [c] => Peng_c )
  1. 可以使用$userdata来给回调函数传递额外的参数, 比如判断元素值是否大于10, 如果是，则值为1, 如果不是，则值为0
    //合理运用array_walk可以避免代码中的大量循环，因为array_walk已经帮我们实现这一步，所以只需要定义好回调函数即可
function judge(&$value, $key, $userdata){
    $value = $value > $userdata?1:0;
}
$input = ['Susunma' => [28, 8], 'Winnie' => 24, 'Peng' => 9];
array_walk($input, 'judge', 10);
print_r($input); echo "</br>";
//Array ( [Susunma] => 1 [Winnie] => 1 [Peng] => 0 )

array_walk_recursive

/**
 * array_walk_recursive($input, $callback, $userdata,...)
 * 对数组中的每个元素应用用户自定义函数, 与array_walk的区别在于可以操作更深的数组
 * @param $input 必需|指定数组
 * @param $callback  必需|自定义函数,第一个参数接受数组元素的键值，第二个参数接受数组元素的键名
 * @param $userdata... 可选|规定用户自定义函数的参数,可以传递任意多参数
 * @return 无
 */
  1. 可以在回调函数的第一个参数指定为引用，从而改变数组元素的值
function myFunction1(&$value, $key){
    $value = $value.'_'.$key;
}
$input = ['a' => 'Susunma', 'b' => 'Winnie', 'c' =>'Peng'];
array_walk_recursive($input, 'myFunction1');
print_r($input); echo "</br>"; //Array ( [a] => Susunma_a [b] => Winnie_b [c] => Peng_c )
  1. 与array_walk的区别在于可以操作更深的数组, 比如这个例子，注意查看结果数组中键名为Susunma的值，并与array_walk中的例子2的结果进行比对
function judge1(&$value, $key, $userdata){
    $value = $value > $userdata?1:0;
}
$input = ['Susunma' => [28, 8], 'Winnie' => 24, 'Peng' => 9];
array_walk_recursive($input, 'judge1', 10);
print_r($input); echo "</br>";
//Array ( [Susunma] => Array ( [0] => 1 [1] => 0 ) [Winnie] => 1 [Peng] => 0 )

arsort

/**
 * arsort($input, $sorting_type)
 * 对关联数组按照键值进行降序排序
 * @param $input  必需|数组
 * @param $sorting_type   可选|默认,SORT_REGULAR,每一项按常规顺序排列|SORT_NUMERIC, 将每一项按数字顺序排列
 *                          |SORT_STRING,将每一项按字母顺序排列|SORT_LOCALE_STRING,把每一项作为字符串来处理，基于当前区域设置
 *                          |SORT_NATURAL,把每一项作为字符串来处理，使用类似 natsort() 的自然排序
 *                          |SORT_FLAG_CASE,可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * @return 无
 */
$input = ['Susunma' => 28, 'Winnie' => 24, 'Peng' => 9];
arsort($input);
print_r($input);echo "</br>";
//Array ( [Susunma] => 28 [Winnie] => 24 [Peng] => 9 )

asort

/**
 * asort($input, $sorting_type)
 * 对关联数组按照键值进行升序排序
 * @param $input  必需|数组
 * @param $sorting_type   可选|默认,SORT_REGULAR,每一项按常规顺序排列|SORT_NUMERIC, 将每一项按数字顺序排列
 *                          |SORT_STRING,将每一项按字母顺序排列|SORT_LOCALE_STRING,把每一项作为字符串来处理，基于当前区域设置
 *                          |SORT_NATURAL,把每一项作为字符串来处理，使用类似 natsort() 的自然排序
 *                          |SORT_FLAG_CASE,可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * @return 无
 */
$input = ['Susunma' => 28, 'Winnie' => 24, 'Peng' => 9];
asort($input);
print_r($input);echo "</br>";
//Array ( [Peng] => 9 [Winnie] => 24 [Susunma] => 28 )

krsort

/**
 * krsort($input, $sorting_type)
 * 对关联数组按照键名进行降序排序
 * @param $input  必需|数组
 * @param $sorting_type   可选|默认,SORT_REGULAR,每一项按常规顺序排列|SORT_NUMERIC, 将每一项按数字顺序排列
 *                          |SORT_STRING,将每一项按字母顺序排列|SORT_LOCALE_STRING,把每一项作为字符串来处理，基于当前区域设置
 *                          |SORT_NATURAL,把每一项作为字符串来处理，使用类似 natsort() 的自然排序
 *                          |SORT_FLAG_CASE,可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * @return 无
 */
$input = ['Susunma' => 28, 'Winnie' => 24, 'Peng' => 9];
krsort($input);
print_r($input);echo "</br>";
//Array ( [Winnie] => 24 [Susunma] => 28 [Peng] => 9 )

ksort

/**
 * ksort($input, $sorting_type)
 * 对关联数组按照键名进行升序排序
 * @param $input  必需|数组
 * @param $sorting_type   可选|默认,SORT_REGULAR,每一项按常规顺序排列|SORT_NUMERIC, 将每一项按数字顺序排列
 *                          |SORT_STRING,将每一项按字母顺序排列|SORT_LOCALE_STRING,把每一项作为字符串来处理，基于当前区域设置
 *                          |SORT_NATURAL,把每一项作为字符串来处理，使用类似 natsort() 的自然排序
 *                          |SORT_FLAG_CASE,可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * @return 无
 */
$input = ['Susunma' => 28, 'Winnie' => 24, 'Peng' => 9];
ksort($input);
print_r($input);echo "</br>";
//Array ( [Peng] => 9 [Susunma] => 28 [Winnie] => 24 )

rsort

/**
 * rsort($input, $sorting_type)
 * 对数组按照键值进行降序排序, 不保留键名，索引将从0开始
 * @param $input  必需|数组
 * @param $sorting_type   可选|默认,SORT_REGULAR,每一项按常规顺序排列|SORT_NUMERIC, 将每一项按数字顺序排列
 *                          |SORT_STRING,将每一项按字母顺序排列|SORT_LOCALE_STRING,把每一项作为字符串来处理，基于当前区域设置
 *                          |SORT_NATURAL,把每一项作为字符串来处理，使用类似 natsort() 的自然排序
 *                          |SORT_FLAG_CASE,可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * @return 无
 */
$input = ['Susunma' => 28, 'Winnie' => 24, 'Peng' => 9];
rsort($input);
print_r($input);echo "</br>";
//Array ( [0] => 28 [1] => 24 [2] => 9 )

sort

/**
 * sort($input, $sorting_type)
 * 对数组按照键值进行升序排序, 不保留键名，索引将从0开始
 * @param $input  必需|数组
 * @param $sorting_type   可选|默认,SORT_REGULAR,每一项按常规顺序排列|SORT_NUMERIC, 将每一项按数字顺序排列
 *                          |SORT_STRING,将每一项按字母顺序排列|SORT_LOCALE_STRING,把每一项作为字符串来处理，基于当前区域设置
 *                          |SORT_NATURAL,把每一项作为字符串来处理，使用类似 natsort() 的自然排序
 *                          |SORT_FLAG_CASE,可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
 * @return 无
 */
$input = ['Susunma' => 28, 'Winnie' => 24, 'Peng' => 9];
sort($input);
print_r($input);echo "</br>";
//Array ( [0] => 9 [1] => 24 [2] => 28 )

compact

/**
 * compact($var1, $var2...)
 * 创建一个包含变量名和他们的值的数组
 * @param $var1  必需|包含变量名的字符串
 * @param $var2...  可选|包含变量名的字符串
 * @return array 数组
 */
//1.当没有匹配的变量时，将不在结果数组中出现
$real_name = 'Susunma';
$hobby = 'Singing';
$age = 28;

$ret = compact('real_name', 'hobby', 'age');
print_r($ret);
//Array ( [real_name] => Susunma [hobby] => Singing [age] => 28 )

extract

/**
 * extract($input, $extract_rules, $prefix)
 * 从数组中将变量导入到当前的符号表
 * @param $input  必需|数组
 * @param $extract_rules  可选|对不合法和冲突的键名的处理方式|默认, EXTR_OVERWRITE, 如果有冲突，则覆盖已有的变量
 *           |EXTR_SKIP,如果有冲突，不覆盖已有的变量。
 *           |EXTR_PREFIX_SAME - 如果有冲突，在变量名前加上前缀 prefix。
 *           |EXTR_PREFIX_ALL - 给所有变量名加上前缀 prefix。
 *           |EXTR_PREFIX_INVALID - 仅在不合法或数字变量名前加上前缀 prefix。
 *           |EXTR_IF_EXISTS - 仅在当前符号表中已有同名变量时，覆盖它们的值。其它的都不处理。
 *           |EXTR_PREFIX_IF_EXISTS - 仅在当前符号表中已有同名变量时，建立附加了前缀的变量名，其它的都不处理。
 *           |EXTR_REFS - 将变量作为引用提取。导入的变量仍然引用了数组参数的值
 * @param $prefix  可选|变量名前缀，和数组键名之间会自动加上一个下划线
 * @return 无
 */
$a = "Ally";
$input = ["a" => "Puppy", "b" => "Peppa", "c" => "Kitten"];

extract($input, EXTR_PREFIX_SAME, "bb");

echo "\$a = $a; \$b = $b; \$c = $c; \$bb_a = $bb_a";echo "</br>";
//$a = Ally; $b = Peppa; $c = Kitten; $bb_a = Puppy

count

/**
 * count($input, $mode)
 * 返回数组元素的个数
 * @param $input  必需|数组
 * @param $mode   可选|是否递归计算元素个数|默认，0，代表不递归|1，代表递归
 * @return integer  个数
 */
//1.计算数组
$input = ["a" => "Puppy", "b" => ["Peppa", "George"], "Kitten", 2 => 'Ally'];
print_r(count($input)); echo "</br>";   //4
print_r(count($input, 1)); echo "</br>";  //6

//2.计算非数组，值固定为1
print_r(count('Susunma'));echo "</br>";  //1
print_r(count(10));echo "</br>";  //1

//3.计算不存在的变量, 固定为0
print_r(count($not_exist));echo "</br>";  //0,这里有Notice: Undefined variable: not_exist

list

/**
 * list($var1, $var2...)
 * 用数组中的元素给一组变量赋值
 * @param $var1  必需|包含变量名的字符串
 * @param $var2...  可选|包含变量名的字符串
 * @return 无
 */
//1.该函数只能匹配到数组里面的数字索引的元素，且假定数字索引从 0 开始,否则会赋值不成功
$input = ["a" => "Puppy", "b" => "Peppa", "c" => "Kitten"];
list($var1, $var2, $var3) = $input;
//list过程中出现了一下警告
//Notice: Undefined offset: 0
//Notice: Undefined offset: 1
//Notice: Undefined offset: 2

$input1 = ["a" => "Puppy1", "b" => "Peppa1", "c" => "Kitten1", "Puppy", "Peppa", "Kitten"];
list($var4, $var5, $var6) = $input1;
echo $var4;echo "</br>";//Puppy
echo $var5;echo "</br>";//Peppa
echo $var6;echo "</br>";//Kitten

in_array

/**
 * in_array($search, $input, $type)
 * 判断数组中是否存在某个值
 * @param $search 必需|需要查找的值
 * @param $input  必需|数组
 * @param $type   可选|是否检查数据类型|当设置为true,检查，未设置时，不检查数据类型
 * @return bool|true,代表存在|false，代表不存在
 */
$input = ["a" => "Puppy", "b" => "Peppa", "Kitten", 2 => 'Ally', '10'];
var_dump(in_array('Puppy', $input));echo "</br>"; //true
var_dump( in_array(10, $input));echo "</br>"; //true
var_dump( in_array(10, $input, 1));echo "</br>"; //false

range

/**
 * range($low, $high, $step)
 * 创建一个包含指定范围的元素的数组
 * @param $low 必需|数组的最低值
 * @param $high  必需|数组的最高值
 * @param $step   可选|规定元素之间的步进制|默认值为1
 * @return 数组
 */
print_r(range(0, 50, 10));echo "</br>";
//Array ( [0] => 0 [1] => 10 [2] => 20 [3] => 30 [4] => 40 [5] => 50 )
print_r(range(50, 0, 10));echo "</br>";
//Array ( [0] => 50 [1] => 40 [2] => 30 [3] => 20 [4] => 10 [5] => 0 )
print_r(range('a', 'd', 1));echo "</br>";
//Array ( [0] => a [1] => b [2] => c [3] => d )

shuffle

/**
 * shuffle($input)
 * 把数组中的元素按随机顺序重新排列,原有键名将被删除，索引从0开始
 * @return 数组
 */
$input = ["a" => "Puppy", "b" => "Peppa", "Kitten", 2 => 'Ally', '10'];
shuffle($input);
print_r($input);
//Array ( [0] => Peppa [1] => Kitten [2] => Puppy [3] => Ally [4] => 10 )

数组指向相关函数

//key() -函数返回的是元素的键名
//current() - 返回数组中的当前元素的值
//end() - 将内部指针指向数组中的最后一个元素，并输出
//next() - 将内部指针指向数组中的下一个元素，并输出
//prev() - 将内部指针指向数组中的上一个元素，并输出
//reset() - 将内部指针指向数组中的第一个元素，并输出
//each() - 返回当前元素的键名和键值，并将内部指针向前移动
$input = ["a" => "Puppy", "b" => "Peppa", "Kitten", 2 => 'Ally'];
echo key($input) . "<br>"; // 当前元素的键名是 a,
echo current($input) . "<br>"; // 当前元素是 Puppy,
echo next($input) . "<br>"; // Puppy 的下一个元素是 Peppa
echo key($input) . "<br>"; // 当前元素的键名是 b,
echo current($input) . "<br>"; // 现在当前元素是 Peppa
echo prev($input) . "<br>"; // Peppa 的上一个元素是 Puppy
echo end($input) . "<br>"; // 最后一个元素是 Ally
echo prev($input) . "<br>"; // Ally 之前的元素是 Kitten
echo key($input) . "<br>"; // 当前元素的键名是 0,
echo current($input) . "<br>"; // 目前的当前元素是 Kitten
echo reset($input) . "<br>"; // 把内部指针移动到数组的首个元素，即 Puppy
echo next($input) . "<br>"; // Puppy 的下一个元素是 Peppa
print_r (each($input)); // 返回当前元素的键名和键值（目前是 Peppa），并向前移动内部指针
//Array ( [1] => Peppa [value] => Peppa [0] => b [key] => b )
清音Susunma
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php array fill 实例,PHP array_fill()用法及代码示例
weixin_31986143的博客
03-22 151
array_fill()是PHP的内置函数，用于用值填充数组。此函数本质上创建具有给定预填充值的用户定义的数组。用法:array_fill($start_index, $number_elements, $values)参数：array_fill()函数采用三个参数，如下所述：$start_index:此参数指定将值填充到用户要创建的数组中的起始位置。如果$start_index为负，则返回数组的...
PHP常用数组函数27个（个人总结）
HuaKai_YinYuLi的博客
09-14 285
常用（6个） array(); 创建数组 rand(arr,[number]); 从数组中随机的选出一个或多个元素，并返回键名 replace(arr1,[arr2]); 使用后面数组的值替换第一个数组的值 merge(arr1,arr2,arr3); 将一个或多个数组合并为一个新数组 slice(arr,start,[length],[preserve]); 返回数组中选定的部分，也叫截取数...
数组函数分组(转自"白色黄昏"-嘉鹏)
摘取天上星
03-29 1018
由于php提供了数组函数，我们可以方便的完成很多工作。 但是数组函数很多，使用的时候php手册那种按字母排序的函数列表，查阅并不方便。 这里将数组的函数根据功能用途做简单的分类，使用的时候就可以减少查询的范围，至于具体的函数用法，请查阅php手册。  统计计算： array_count_values 统计数组中所有的值出现的次数 array_product 计算数组中所有
php组数玩法
何毅
07-23 465
在PHP中大部分都使用到了数组（php对数组和处理比Java性能好） 在php5 给我们封装了好多常用的数组处理类；如: array_column()函数返回数组中指定的字段形成新的数组，array_slice()函数返回指定内容数据，array_unique()数组去重等等这些高效的函数PHP 数组的排序函数 sort() 以升序对数组排序rsort() - 以降序对数组排序 asort(
PHP数组的常见操作和常用函数
qq_66198247的博客
10-20 1249
以上两种语法格式都是通过foreach语句来实现对数组的遍历，不同的是，在语法格式一中，只是将。参数，默认值为0，如果将该参数设置为1，则count()函数会递归计算多维数组中每个元素的个数。使用格式：array_diff_assoc(array,array2,array3,....)使用格式：array_diff_key(array,array2,array3,....)使用格式：array_diff(array,array2,array3,....)，其中$var参数是必需的，它表示传入的数组对象。
php常用数组函数实例小结
12-18
本文实例总结了php常用数组函数。分享给大家供大家参考，具体如下： 1. array array_merge(array $array1 [, array $array2 [, $array]]) 函数功能：将一个或多个数组的单元合并起来，一个数组中的值附加在前一个...
php array_walk() 数组函数
12-18
复制代码 代码如下: /*函数array_walk():单一数组回调函数—对数组中的每个成员应用用户函数 * 1、语法：bool array_walk ( array &array, callback funcname [, mixed $userdata] ) * 2、描述：如果成功则返回 TRUE...
php中的注释、变量、数组、常量、函数应用介绍
12-19
php中单引号与双引号的区别？ 1. 由下可看出，双引号的变量是解析并输出，而单引号的变量不解析。 2.单引号的解析速度比双引号的快 3. 对于单引号来说，只有两个转义 \’,\\ 4. 除了上述两个转义字符，其他都原样...
php基于数组函数实现关联表的编辑操作示例
10-19
`array_intersect`和`array_diff`在处理关联表编辑操作中提供了简洁且强大的解决方案，而PHP数组函数库中的其他工具则能进一步扩展我们的处理能力。不断学习和实践这些技巧，将有助于提升PHP编程技能，并在实际项目...
php回调函数处理数组操作示例
10-15
`array_map` 用于将回调函数应用到数组的每个元素上，返回一个新的数组，包含了经过处理的元素。以下例子展示了如何对数组进行立方运算： ```php function cube($n) { return $n * $n * $n; } $a = [1, 2, 3, 4, ...
php array 数组函数,php array数组函数
weixin_32279911的博客
03-20 148
array()：创建数组array_change_key_case()：返回其键名均为大写或小写的数组array_chunk()：把一个数组分割为新的数组块array_combine()：创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值array_count_values()：用于统计数组中所有值出现的次数array_diff()：返回两个数组的差集数组。键名保持不变array_di...
PHP常用数组(Array)函数整理
张默的博客
04-23 1738
一、数组操作的基本函数 数组的键名和值 array_values($arr); 获得数组的值 array_keys($arr); 获得数组的键名 array_flip($arr); 数组中的值与键名互换（如果有重复前面的会被后面的覆盖） in_array("apple",$arr); 在数组中检索apple array_search("apple",$arr); 在数组中检索appl...
php常用数组函数
滑稽型自走雷的博客
04-20 340
反转键值： array_flip() 函数用于反转/交换数组中的键名和对应关联的键值。
PHP Array 函数
weixin_30467087的博客
05-29 130
PHP 5 Array 函数 函数描述 array() 创建数组。 array_change_key_case() 返回其键均为大写或小写的数组。 array_chunk() 把一个数组分割为新的数组块。 array_column() 返回输入数组中某个单一列的值。 array_combine() 通过合并两个数组（一个为键...
php array函数
weixin_43088788的博客
09-01 228
Array函数(76) 差集(8) array_diff(array1,array2,array3…) array_diff_assoc(array1,array2,array3…) array_diff_key(array1,array2,array3…) array_diff_uassoc(array1,array2,array3…,myfunction...
php数组传给该函数,将php数组传递给jquery函数
weixin_42384267的博客
03-10 209
我有一个带有表单的页面,用来填写客户信息.我将以前的客户数据存储在php数组中.使用下拉列表,用户可以使用我存储的数据填写表单.我所拥有的是一个jquery函数,当值发生变化时触发,在函数内部我想用我存储的数据更新表单值(在我的php数组中).问题是我不知道如何将我的php数组传递给jquery函数,任何想法？这是我填充数组的方式：$contador_acompanantes = 0;foreac...
PHP数组常用函数
Devil_ping的博客
12-11 339
1.获取数组的长度,count()和sizeof()统计数组下标的个数 统计一个数组里的所有元素. 2.each() 返回当前元素的键名和键值，并将内部指针向前移动一步 3.list() 用于在一次操作中给一组变量赋值 4.数组元素的排序: sort()、asort()和 ksort()都是正向排序,rsort()、arsort()和 krsort()是反向排序 5...
php中函数应用,PHP的函数应用
weixin_39964869的博客
03-20 142
函数的定义：函数就是一段封装好的代码块，可以随时调用。在PHP中有两种函数：自定义函数与系统函数。自定义函数语法格式：function 函数名称([参数1，[参数2]....]){函数体(程序内容叙述)[return 返回值；]}注：[]里的东西可有可无自定义函数的名称：它是函数在程序代码中的识别名称，函数名可以是以字母或下划线开头后跟零个或多个字母、下划线和数字的任何字符串。符合变量名的命名规...
PHP常用函数功能资料大全.doc
最新发布
11-21
PHP常用函数功能资料大全.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值