php中数组函数的应用

PHP学习之旅 专栏收录该内容
11 篇文章 0 订阅

说到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 )
  • 1
    点赞
  • 0
    评论
  • 6
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

参与评论 您还未登录,请先 登录 后发表或查看评论
©️2022 CSDN 皮肤主题:终极编程指南 设计师:CSDN官方博客 返回首页

打赏作者

清音Susunma

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值