PHP数组函数分类整理

最新推荐文章于 2023-05-01 16:13:20 发布

gscsdlz

最新推荐文章于 2023-05-01 16:13:20 发布

阅读量483

点赞数

分类专栏： PHP和MYSQL学习笔记文章标签： php

本文链接：https://blog.csdn.net/gscsdlz/article/details/77962264

版权

PHP和MYSQL学习笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

PHP数组函数分类整理

array_change_key_case

array array_change_key_case( array $array[, int $case = CASE_LOWER ] )

将数组中所有键名(key)修改为大写或者小写，默认为小写。

var_dump(array_change_key_case([
   'abc' => 1,
    'aBC' => 1,
    '12C' => 1,
    '123' => 1,
]));
/*
array (size=3)
  'abc' => int 1
  '12c' => int 1
  123 => int 1
*/

这个函数对数字没有作用。如果键名中混用数字字符，也会全部转为小写。

array_chunk

array array_chunk(array $input, $size, $preserve_keys = null)

将一个数组分成小块，每个块的大小通过$size指定，如果设置了$preserve_keys为true，那么在每个块中会保留键的原始值，否则新的数组中从0开始重新分配键。也就是把关联数组改为索引数组
默认值为false也就是不保留键，在使用函数的时候一定要注意，数组的键是否很重要，如果重要一定要记得保留。

var_dump(array_chunk(['a'=>1,2,3,4,5,6,7,8,9], 4));
/*
array (size=3)
  0 => 
    array (size=4)
      0 => int 1
      1 => int 2
      2 => int 3
      3 => int 4
  1 => 
    array (size=4)
      0 => int 5
      1 => int 6
      2 => int 7
      3 => int 8
  2 => 
    array (size=1)
      0 => int 9
*/

var_dump(array_chunk(['a'=>1,2,3,4,'b'=>5,6,7,8,9], 4, true));
/*
array (size=3)
  0 => 
    array (size=4)
      'a' => int 1
      0 => int 2
      1 => int 3
      2 => int 4
  1 => 
    array (size=4)
      'b' => int 5
      3 => int 6
      4 => int 7
      5 => int 8
  2 => 
    array (size=1)
      6 => int 9
*/

分成小块以后，除了最后一块以外，其余的大小应该等于$size，另外形成的小块数组使用数字索引的时候，如果没有保留键名，那么每个小块数组中会同时从0开始重新分配，但是如果设置了不保留，整个数字索引的分配的顺序增长的，详细见输出

array_column

array array_column ( array $input , mixed $column_key [, mixed $index_key = null ] )

返回数组中的一列，如果指定了$index_key会创建键-值对，二维数组才有列的说法，一维数组返回空数组，二维数组以上的数组，仅返回第二维，剩余的作为值返回，详细见实例：

$arr_assoc = array(
    'a'=>[
        'sex' => 'male',
        'name' => 'andy',
        'age' => 17,
        'arr' => [
            1, 2, 3
        ]
    ],
    [
        'name' => 'bob',
        'age' => 18,
    ],
    [
        'name' => 'cindy',
        'age' => 19,
    ]
);

var_dump(array_column($arr_assoc, 'arr'));
var_dump(array_column($arr_assoc, 'a'));
var_dump(array_column($arr_assoc, 'name'));
/*
array (size=1)
  0 => 
    array (size=3)
      0 => int 1
      1 => int 2
      2 => int 3

array (size=0)
  empty

array (size=3)
  0 => string 'andy' (length=4)
  1 => string 'bob' (length=3)
  2 => string 'cindy' (length=5)

*/

var_dump(array_column($arr_assoc, 'age', 'name'));
/*
array (size=3)
  'andy' => int 17
  'bob' => int 18
  'cindy' => int 19
*/

array_combine

array array_combine ( array $keys , array $values )

创建一个数组，使用第一个数组的值作为键，使用第二个数组的值作为值。两个数组大小必须相同，仅合并第一维。$keys只能是一维数组，元素应该是字符串（或者可以转为字符串的）。$values的元素可以包含数组，会使用$keys中的键指向它。

class A{
    function __toString()
    {
        // TODO: Implement __toString() method.
        return 'mac';
    }
}
$arr_key = array('apple', 'ios', new A());
$arr_val = array(2, 1, [2, 3]);

var_dump(array_combine($arr_key, $arr_val));
/*
array (size=3)
  'apple' => int 2
  'ios' => int 1
  'mac' => 
    array (size=2)
      0 => int 2
      1 => int 3
*/

array_count_values

array array_count_values ( array $array )

统计数组中的值，及其出现次数。仅能统计字符串和整数，不能统计数组中的数组

$arr = [1, 2, 3, 1, 2, 3, 4];
var_dump(array_count_values($arr));
/*
array (size=4)
  1 => int 2
  2 => int 2
  3 => int 2
  4 => int 1
*/

计算数组的差集

在A数组中，但是不在B数组的元素即为两个数组的差集，以下函数都是计算差集的，和排序类似，计算差集的时候，比较两个元素是否相同可以比较值，也可以比较键，也可以比较键值。同时可以使用用户自定义回调函数处理什么是相等。
u表示该函数需要使用用户自定义函数。

array_diff_assoc

array_diff_key

array_diff_uassoc

array_diff_ukey

array_diff

array_udiff_assoc

array_udiff_uassoc

array_udiff

array_fill_keys

array_fill

array array_fill ( int $start_index , int $num , mixed $value )

用指定值，初始化一个数组，通过$strat_index设置起始键，$num设置$value使用次数。
如果使用负数，第一个使用负数键，接下来继续从0开始增加

var_dump(array_fill(8, 2, [1, 2]));
var_dump(array_fill(-8, 2, [1, 2]));
/*
array (size=2)
  8 => 
    array (size=2)
      0 => int 1
      1 => int 2
  9 => 
    array (size=2)
      0 => int 1
      1 => int 2

array (size=2)
  -8 => 
    array (size=2)
     ...
  0 => 
    array (size=2)
      ...
*/

array_filter

array_flip

array_intersect_assoc

array_intersect_key

array_intersect_uassoc

array_intersect_ukey

array_intersect

array_key_exists / key_exists

array_keys

array_map

array_merge_recursive

array_merge

array_multisort

array_pad

array_pop

array_product

array_push

array_rand

array_reduce

array_replace_recursive

array_replace

array_reverse

array_search

array_shift

array_slice

array_splice

array_sum

array_uintersect_assoc

array_uintersect_uassoc

array_uintersect

array_unique

array_unshift

array_values

array_walk_recursive

array_walk

array

compact

array compact ( mixed $varname1 [, mixed $... ] )

这个函数与extract互逆，将变量合成数组。该函数是可变长参数的函数。

extract

int extract ( array &$array [, int $flags = EXTR_OVERWRITE [, string $prefix = NULL ]] )

将数组中元素分配到当前符号表中（可以理解为生成变量）。以键名作为新的变量名，会检查是否符合命名法。如果给的数组中，有键名冲突，非法/数字索引键，可以通过$flags进行调整，也可以通过$prefix参数设定所有生成的变量的前缀(需要$flags参数配合)

$arr = array(
  'b' => 123,
  '213' => 'b'
);
extract($arr);
echo $b;  //123
echo $213; //报错

count / sizeof

int count ( mixed $array_or_countable [, int $mode = COUNT_NORMAL ] )

用于统计数组中元素的个数，使用$mode主要调整是否递归进行统计，适合于多维数组

$arr_assoc = array(
    'a' => [
    1, 2, 3
    ],
    'b' => 1,
    'c' => 2
);
echo count($arr_assoc); //3

输出为3，由于没有使用递归，所以仅仅统计一层。

echo count($arr_assoc, COUNT_RECURSIVE);
//同样的数组 输出6

为什么会输出6呢？首先第一层有3个元素，其次’a’的下一层还有3个元素。使用count的递归统计可能会得到意想不到的结果，例如[ [ [ 1 ] ] ]输出应该是3，但是我们可能期望是1。

in_array

bool in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] )

检查某个值是否在数组中，如果设置了$strict将进行类型的比较。

$arr = [
    1,
    'a' => '2',
    'b' => [
        1, 3
    ]
];

var_dump(in_array(1, $arr));  //T
var_dump(in_array(2, $arr));  //T
var_dump(in_array(2, $arr, true));  //F
var_dump(in_array([1, 3], $arr));   //T
var_dump(in_array('a', $arr));   //F 不能用于检测键 检测键使用array_key_exists

list

range

array range ( mixed $start , mixed $end [, number $step = 1 ] )

根据范围创建数组，设置起始点，终止点，步长（默认为1）。创建一个索引数组，从0开始。

var_dump(range(2, 5,2));
/*
array (size=2)
  0 => int 2
  1 => int 4
*/
for($i = 2; $i <= 5; $i += 2)
    $arr[] = $i;
var_dump($arr);

shuffle

bool shuffle ( array &$array )

调用随机函数打乱数组，通过引用传统参数，返回值仅仅代表是否成功。

内部指针相关函数

下面七个函数主要用于遍历、访问关联数组（下标不完全连续的索引数组也可以），由于关联数组的特殊性，可能无法实现简单的访问下一个元素。例如

$arr = [
    'a' => 1,
    'ac' => 2,
];

如果想要访问’ac’并不是那么容易（在事先不知道’ac’的情况下）。

key

返回当前内部指针所指元素的键

current / pos

返回当前内部指针所指元素的值
key和current共同构成了一个键值对

reset

将内部指针移到头部（重置指针）

end

将内部指针移到末尾（不超过数组长度）

将内部指针往前移动（如果已经在头部，往前移动会移出数组，此时无法通过next还原，只能使用reset重置）

next($arr_assoc);
prev($arr_assoc);
prev($arr_assoc);
prev($arr_assoc);
next($arr_assoc);
next($arr_assoc);
var_dump(current($arr_assoc)); //boolean false

同prev，但是是讲指针后移，如果已经在尾部了，继续后移和prev效果相同。

each

返回当前的键值对并下移指针，相当于current，key，next调用，配合上while可以遍历一个关联数组，和foreach类似。

foreach函数，会在调用的时候，自动reset，但是调用结束以后并不是恢复指针，必须通过reset重置。

$arr_assoc = array(
    'a' => 0,
    'b' => 1,
    'c' => 2
);
foreach($arr_assoc as $row)
    ;
var_dump(current($arr_assoc));

prev($arr_assoc);
var_dump(current($arr_assoc));

reset($arr_assoc);
var_dump(current($arr_assoc));
/*
boolean false

boolean false

int 0
*/

each的返回值是一个数组，但是一般包括4个元素，包含有·key·和·value·的关联数组，以及使用0、1表示的索引数组，其中0表示key 1表示value

array (size=4)
  1 => int 0
  'value' => int 0
  0 => string 'a' (length=1)
  'key' => string 'a' (length=1)

each还可以和list配合，详细见list解析

排序相关

排序基本上按照键排序，值排序，升序降序，用户自定义函数排序
r表示reverse，逆序
a表示association，按值
k表示key，按键
u表示user，用户自定义排序方式
除了u开头的函数能够自由调整排序方式，其余的函数如果需要逆序都需要使用带r的函数。

sort

对数组排序，返回从低到高的数组，通过引用传递数组，排序完成后的返回值仅仅是true或false表示是否排序成功。
可以通过第二参数传递选项，选项一般控制了进行比较的规则，尤其是数字和字符串的比较。
例如'123'应该按照123来排序，还是'123',可以通过选项控制。
排序后不保留键

$arr_assoc = array(
    'a' => 2,
    'c' => 1,
    'b' => 3,
    'e' => 4,
    'd' => 5
);
sort($arr_assoc);
/*
array (size=5)
  0 => int 1
  1 => int 2
  2 => int 3
  3 => int 4
  4 => int 5
*/

rsort

同sort，只是从大到小排序。

ksort

同sort，该函数保留键，按照键排序

asort

该函数按照值排序，保留键

krsort

同ksort，按照从大到小排序

arsort

同asort，按照从大到小排序

usort

用户自定义排序函数，第一个参数是数组的引用，第二个参数是一个回调函数，参数有两个。分别是比较对象的第一个和第二个。
该回调函数，应该返回一个小于、等于、大于0的整数，如果返回了浮点数，将被强制转换为intege
例如：

$arr_assoc = array(
    'a' => 2,
    'c' => 1,
    'b' => 3,
    'e' => 4,
    'd' => 5
);
usort($arr_assoc, function($a, $b){
   // return $a < $b;
    return ($a < $b) ? 1 : -1;
});

排序时return $a < $b;怎么知道排序方向？简单技巧，当$a < $b时，返回true，表示需要交换，那么小的值就会放在后面，也就是从大到小。
该函数不保留键。

uasort

同usort，对值进行排序，保留键

uksort

同usort，对键进行排序，保留键
如果一个数组中的某一项是由数组构成的，也就是多维数组
除了usort，uksort，uasort以外，剩余的排序函数排序时会显得力不从心，一般来说默认以多维数组的第一项排序
例如：

$arr_assoc = array(
    [
        'sex' => 'male',
        'name' => 'andy',
        'age' => 17,
    ],
    [
        'name' => 'bob',
        'age' => 18,
    ],
    [
        'name' => 'cindy',
        'age' => 19,
    ]
);
sort($arr_assoc);
/*
array (size=3)
  0 => 
    array (size=2)
      'name' => string 'bob' (length=3)
      'age' => int 18
  1 => 
    array (size=2)
      'name' => string 'cindy' (length=5)
      'age' => int 19
  2 => 
    array (size=3)
      'sex' => string 'male' (length=4)
      'name' => string 'andy' (length=4)
      'age' => int 17
*/

默认按照第一个值排序，而不是统一使用’name’排序。而且还可以发现sort并没有取消下一层的键。
如果需要对类似这种数组排序，应该使用自定义函数处理:

usort($arr_assoc, function($a, $b){
    return $a['age'] > $b['age'];
});//按年龄升序

natcasesort / natsort

这两个函数和sort类函数的区别在于，排序的时候按照自然序排序（case表示不区分大小写）。
自然序即按照人类的习惯排序，例如字符串I12和字符串I2按照sort的规则，由于第二个2已经比1大，所以不会进行后续比较，但实际上2比12小。所以这时候就可以使用nat(case)sort，这个函数按值的自然序排序，并且保留键。

如果字符串是纯数字，并不会有特殊性，因为已经进行了类型转换。

$arr = [
    'I12', 'I2'
];
sort($arr);
var_dump($arr);
natsort($arr);
var_dump($arr);
/*
array (size=2)
  0 => string 'I12' (length=3)
  1 => string 'I2' (length=2)

array (size=2)
  1 => string 'I2' (length=2)
  0 => string 'I12' (length=3)
*/