PHP之数组函数归类辨析

最新推荐文章于 2022-11-18 15:32:42 发布

abcPHP

最新推荐文章于 2022-11-18 15:32:42 发布

阅读量1.2k

点赞数

分类专栏： PHP

本文链接：https://blog.csdn.net/t_1007/article/details/78706851

版权

PHP 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

数组键值特性

key 可以是 integer 或者 string。value 可以是任意类型。
此外 key 会有如下的强制转换：

包含有合法整型值的字符串会被转换为整型。
例如键名 “8” 实际会被储存为 8。但是 “08” 则不会强制转换，因为其不是一个合法的十进制数值。浮点数也会被转换为整型，意味着其小数部分会被舍去。例如键名 8.7 实际会被储存为 8。
布尔值也会被转换成整型。即键名 true 实际会被储存为 1 而键名 false 会被储存为 0。 Null 会被转换为空字符串，即键名null 实际会被储存为 “”。
数组和对象不能被用为键名。坚持这么做会导致警告：Illegal offset type。

$array = array(
	1     => "a",
	"1"   => "b",
	1.5   => "c",
	1.999 => "c",
	TRUE  => "d",
	FALSE => FALSE,
	NULL  => NULL,
	0     => 'false',
);
var_dump($array);
/*array (size=3)
	1 => string 'd' (length=1)
	0 => string 'false' (length=5)
	'' => null
* */

// 创建一个简单的数组
$array = array(1, 2, 3, 4, 5);
var_dump($array);

// 现在删除其中的所有元素，但保持数组本身不变:
foreach ($array as $i => $value) {
  unset($array[$i]);
}
var_dump($array);

// （接上）添加一个单元（注意新的键名是 5，而不是你可能以为的 0）
$array[] = 6;
var_dump($array);

// 重新索引：
$array = array_values($array);
$array[] = 7;
var_dump($array);

一、键/值处理

array_values()

array array_values ( array $array )
返回数组中的值并给其建立数字索引

array_keys

array array_keys ( array $array [, mixed $search_value = null [, bool $strict = false ]] )
array_keys() 返回 input 数组中的数字或者字符串的键名。
如果指定了可选参数 search_value，则只返回该值的键名。否则 input 数组中的所有键名都会被返回。

    $array = array(0 => 100, "color" => "red", 'null' => NULL, NULL, 'false' => FALSE);
    var_dump(array_keys($array), array_keys($array, NULL), array_keys($array, NULL, TRUE));
    /*
     * array (size=5)
        0 => int 0
        1 => string 'color' (length=5)
        2 => string 'null' (length=4)
        3 => int 1
        4 => string 'false' (length=5)

      array (size=3)
        0 => string 'null' (length=4)
        1 => int 1
        2 => string 'false' (length=5)

      array (size=2)
        0 => string 'null' (length=4)
        1 => int 1
     * */

array_change_key_case

array array_change_key_case ( array $array [, int $case = CASE_LOWER ] )
将 array 数组中的所有键名改为全小写或大写--CASE_UPPER 或 CASE_LOWER。本函数不改变数字索引。
如果输入值（array）不是一个数组，错误警告（E_WARNING）,返回FALSE
如果一个数组中的多个键名经过本函数后变成一样的话（例如 "keY" 和 "kEY"），最后一个值将覆盖其它的值。

//递归改变键名的大小写
function array_change_kay_case_rec($arr,$case=CASE_LOWER){
    return array_map(function($item) use ($case){
        if(is_array($item)){
            $item=array_change_kay_case_rec($item,$case);
        }
        return $item;
    },array_change_key_case($arr,$case));
}

array_column

array array_column ( array $input , mixed $column_key [, mixed $index_key = null ] )
array_column() 返回input数组中键值为column_key的列， 如果指定了可选参数index_key，那么input数组中的这一列的值将作为返回数组中对应值的键。
input
需要取出数组列的多维数组。 如果提供的是包含一组对象的数组，只有 public 属性会被直接取出。 为了也能取出 private 和 protected 属性，类必须实现 __get() 和 __isset() 魔术方法。

column_key
需要返回值的列，它可以是索引数组的列索引，或者是关联数组的列的键，也可以是属性名。 也可以是NULL，此时将返回整个数组（配合index_key参数来重置数组键的时候，非常管用）

index_key
作为返回数组的索引/键的列，它可以是该列的整数索引，或者字符串键值。

$records = array(
    array(
        'id' => 2135,
        'first_name' => 'John',
        'last_name' => 'Doe',
    ),
    array(
        'id' => 3245,
        'first_name' => 'Sally',
        'last_name' => 'Smith',
    ),
    array(
        'id' => 5342,
        'first_name' => 'Jane',
        'last_name' => 'Jones',
    ),
    array(
        'id' => 5623,
        'first_name' => 'Peter',
        'last_name' => 'Doe',
    )
);
 
$first_names = array_column($records, 'first_name');
print_r($first_names);//顺序数字索引，‘first_name’为值
$last_names = array_column($records, 'last_name', 'id');
print_r($last_names);//'id'为索引，‘first_name’位置
$null_names = array_column($records, null,'first_name');
print_r($null_names);//'first_name'为索引的二维数组
/*
Array
(
    [John] => Array
        (
            [id] => 2135
            [first_name] => John
            [last_name] => Doe
        )
    ...
)
*/
$index_key = array_column($null_names, null);
print_r($index_key);//关联索引转变为数字索引
/*
Array
(
    [0] => Array
        (
            [id] => 2135
            [first_name] => John
            [last_name] => Doe
        )
    ...
 )
*/

in_array/array_search

判断值是否在数组中，注意默认为不严格的比较，不对类型作检查，只要能转为相同的值就可以

bool in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] )
大海捞针，在干草堆（haystack）中搜索针（ needle），如果没有设置 strict 则使用宽松的比较

mixed array_search ( mixed $needle , array $haystack [, bool $strict = false ] )
大海捞针，在干草堆（haystack）中搜索针（ needle 参数）
如果找到了 needle 则返回它的键，否则返回 FALSE。
如果 needle 在 haystack 中出现不止一次，则返回第一个匹配的键。
要返回所有匹配值的键，应该用 array_keys() 加上可选参数 search_value 来代替。

// 实际生产中数组值多字符串、数字，实际情况较少见（bool）
$array = array(
	'egg' => true,
	'cheese' => false,
	'hair' => 765,
	'goblins' => null,
	'ogres' => 'no ogres allowed in this array'
);

// Loose checking -- 松散比较，类型转换
var_dump(in_array(null, $array)); // true null==false
var_dump(in_array(false, $array)); // true false==false
var_dump(in_array(765, $array)); // true 765==true
echo '----';
var_dump(in_array(7630, $array)); // true 7630==true
var_dump(in_array('egg', $array)); // true  'egg'==true
var_dump(in_array('hhh', $array)); // true  'hhh'==true
var_dump(in_array(array(1,2,3), $array)); // true 
var_dump(in_array(array(), $array)); // true
echo '----';
// Strict checking
var_dump(in_array(null, $array, true)); // true
var_dump(in_array(false, $array, true)); // true
var_dump(in_array(765, $array, true)); // true
var_dump(in_array(763, $array, true)); // false
var_dump(in_array('egg', $array, true)); // false
var_dump(in_array('hhh', $array, true)); // false
var_dump(in_array(array(), $array, true)); // false

//符合比较时，类型转换
// https://www.php.net/manual/zh/language.operators.comparison.php
// https://www.php.net/manual/zh/language.types.string.php#language.types.string.conversion
var_dump(in_array(0, ['a', 'b', 'c'])); // true 0==‘a’

$test_array = array('test', '1234abcd','0xA','1e3');
var_dump(in_array(1234, $test_array));//true 1234=='1234abcd'
var_dump(in_array('1234', $test_array));//false
var_dump(in_array(10, $test_array));//false
var_dump(in_array(1000, $test_array));//true

$test_array = array('test', '1234abcd','0xA','1e3', 1234);
var_dump(in_array('1234', $test_array));//false

//不区分大小写in_array
in_array(strtolower($needle), array_map('strtolower', $haystack));
var_dump(in_array(1, null)); //返回null

array_key_exists

bool array_key_exists ( mixed $key , array $array )
数组里有键 key 时，array_key_exists() 返回 TRUE。 key 可以是任何能作为数组索引的值。

$arr=['test','null'=>null];
var_dump(isset($arr['null'])); //false
var_dump(array_key_exists('null',$arr)); //true

//Very simple case-insensitive array_key_exists
bool (in_array(strtolower($needle), array_map('strtolower', array_keys($haystack))))

array_flip

array array_flip ( array $array )
array_flip() 返回一个反转后的 array，例如 array 中的键名变成了值，而 array 中的值成了键名。
注意 array 中的值需要能够作为合法的键名（例如需要是 integer 或者 string）。如果类型不对，将出现一个警告，并且有问题的键／值对将不会出现在结果里。
如果同一个值出现多次，则最后一个键名将作为它的值，其它键会被丢弃。

array_reverse

array array_reverse ( array $array [, bool $preserve_keys = false ] )
array_reverse() 接受数组 array 作为输入并返回一个单元为相反顺序的新数组。
preserve_keys 如果设置为 TRUE 会保留数字的键。 非数字的键则不受这个设置的影响，总是会被保留。

array_count_values

返回每个值出现的次数，键名为该值

array array_count_values ( array $array )
返回一个关联数组，用 array 数组中的值作为键名，该值在数组中出现的次数作为值。
对数组里面的每个不是 string 和 integer 类型的元素抛出一个警告错误（E_WARNING）。

三、拆分合并填充

array_chunk

array array_chunk ( array $array , int $size [, bool $preserve_keys = false ] )
将一个数组分割成多个数组，其中每个数组的单元数目由 size 决定。最后一个数组的单元数目可能会少于 size 个。最后各个数组整合在一起形成二维数组返回
preserve_keys 设为 TRUE，可以使 PHP 保留输入数组中原来的键名。如果你指定了 FALSE，那每个结果数组将用从零开始的新数字索引。默认值是 FALSE。

得到的数组是一个多维数组中的单元，其索引从零开始，每一维包含了 size 个元素。
如果 size 小于 1，会抛出一个 E_WARNING 错误并返回 NULL。
如果 size 大于等于原数组长度：二维数组，[ 0=>[0=>[...],1=>[...],2=>[...]] ]

//arr,m,n，m行n列
$m=6;
$n=9;
$arr=range(1,$m*$n);
$mTmp=$nTmp=0;
$data=[];
$arrow=['right','down','left','up'];
$flag=0;
foreach($arr as $k=>$v){
  $data[$mTmp][$nTmp]=$v;
  if($arrow[$flag%4]=='right'){
    $nTmp++;
    if(isset($data[$mTmp][$nTmp+1]) || $nTmp==$n-1){
      $flag++;
    }
  }elseif($arrow[$flag%4]=='down'){
    $mTmp++;
    if(isset($data[$mTmp+1][$nTmp]) || $mTmp==$m-1){
      $flag++;
    }
  }elseif($arrow[$flag%4]=='left'){
    $nTmp--;
    if(isset($data[$mTmp][$nTmp-1]) || $nTmp==0){
      $flag++;
    }
  }elseif($arrow[$flag%4]=='up'){
    $mTmp--;
    if(isset($data[$mTmp-1][$nTmp]) || $mTmp==0){
      $flag++;
    }
  }
}

for($row=0;$row<$m;$row++){
  for($col=0;$col<$n;$col++){
    printf('[%2s]',$data[$row][$col]);
  }
  echo '<br>';
}

array_slice

从数组中切一段返回，注意传入偏移、长度参数的正负，偏移为正则从数组左边开始，为负则从末端倒数这么多个开始。长度为正则切出这么多个，为负则切到末端倒数到这个长度值为止

array array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = false ]] )
array_slice() 返回根据 offset 和 length 参数所指定的 array 数组中的一段序列。
preserve_keys 注意 array_slice() 默认会重新排序并重置数组的数字索引。你可以通过将 preserve_keys 设为 TRUE 来改变此行为。(关联数组不变)

array_splice

从数组中切出一段，要么删除，要么用其他值代替删除的一部分，注意传入偏移和长度参数的正负

array array_splice ( array &$input , int $offset [, int $length = count($input) [, mixed $replacement = array() ]] )
把 input 数组中由 offset 和 length 指定的单元去掉，如果提供了 replacement 参数，则用其中的单元取代。
注意 input 中的数字键名不被保留。
offset
如果 offset 为正，则从 input 数组中该值指定的偏移量开始移除。如果 offset 为负，则从 input 末尾倒数该值指定的偏移量开始移除。

length
如果省略 length，则移除数组中从 offset 到结尾的所有部分。如果指定了 length 并且为正值，则移除这么多单元。如果指定了 length 并且为负值，则移除从 offset 到数组末尾倒数 length 为止中间所有的单元。 如果设置了 length 为零，不会移除单元。 小窍门：当给出了 replacement 时要移除从 offset 到数组末尾所有单元时，用 count($input) 作为 length。

replacement
如果给出了 replacement 数组，则被移除的单元被此数组中的单元替代。
如果 offset 和 length 的组合结果是不会移除任何值，则 replacement 数组中的单元将被插入到 offset 指定的位置。 注意替换数组中的键名不保留。
如果用来替换 replacement 只有一个单元，那么不需要给它加上 array()，除非该单元本身就是一个数组、一个对象或者 NULL。

array_unique

将重复值归并为一个，非严格判断

array array_unique ( array $array [, int $sort_flags = SORT_STRING ] )

注意键名保留不变。array_unique() 先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留。
默认SORT_STRING排序比较时当且仅当 (string) $elem1 === (string)$elem2 时两个单元被认为相同
SORT_REGULAR - 按照通常方法比较（不修改类型，可用于多维数组去重）

$input = array(4, "4", "3", 4, 3, "3",null,false,0);
$result = array_unique($input);//默认SORT_STRING - 按照字符串形式比较
$result_numeric = array_unique($input,SORT_NUMERIC);//SORT_NUMERIC - 按照数字形式比较
var_dump($result,$result_numeric,(string)null,(string)false,(string)0);

/*
array (size=4)
  0 => int 4
  2 => string '3' (length=1)
  6 => null
  8 => int 0

array (size=3)
  0 => int 4
  2 => string '3' (length=1)
  6 => null
*/

array_combine

array array_combine ( array $keys , array $values )
返回一个 array，用来自 keys 数组的值作为键名，来自 values 数组的值作为相应的值。
返回合并的 array，如果两个数组的单元数不同,将会抛出一个警告错误（E_WARNING）,返回 FALSE。

implode

将数组连接为一个字符串

string implode ( string $glue , array $pieces )
string implode ( array $pieces )
用 glue（默认为空字符串） 将一维数组的值连接为一个字符串。
因为历史原因，implode() 可以接收两种参数顺序，但是 explode() 不行。

explode

array explode ( string $delimiter , string $string [, int $limit ] )
此函数返回由字符串组成的数组，每个元素都是 string 的一个子串，它们被字符串 delimiter 作为边界点分割出来。
limit
如果设置了 limit 参数并且是正数，则返回的数组包含最多 limit 个元素，而最后那个元素将包含 string 的剩余部分。
如果 limit 参数是负数，则返回除了最后的 -limit 个元素外的所有元素。
如果 limit 是 0，则会被当做 1。
如果 delimiter 为空字符串（""），explode() 将返回 FALSE。 如果 delimiter 在 string 中找不到，并且使用了负数的 limit ， 那么会返回空的 array， 否则返回只有 string 单个元素的数组（ [string] ）。

$str = 'one|two|three|four';
// 正数的 limit
print_r(explode('|', $str, 2));
// 负数的 limit（自 PHP 5.1 起）
print_r(explode('|', $str, -1));
//Array ( [0] => one [1] => two|three|four )
// Array ( [0] => one [1] => two [2] => three )

// delimiter 在 string 中找不到
print_r(explode('||', $str));
// 负数的 limit, delimiter 在 string 中找不到
print_r(explode('||', $str, -1));
//Array ( [0] => one|two|three|four )
// Array ( )

array_merge

array array_merge ( array $array1 [, array $... ] )
array_merge() 将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。
如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。
如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引。
如果有一个参数为null，整体返回null

array_merge_recursive

递归合并，即当数组中元素仍为数组时，继续执行并操作，注意此时相同的字符串键名的元素会合并到同一个数组中去，整数索引的元素仍为附加

array_pad

用指定值将数组填充到指定长度，指定长度小于本身长度时不作处理

$b = array('1229600459'=>'large', '0x45'=>20, 1229609459=>'red','44'=>44);
var_dump(array_pad($b, count($b)+1, 'foo'));//加在最后一个，所有数字索引键值从0顺序重排
var_dump(array_pad($b, -(count($b)+1), 'foo'));//加在第一个，所有数字索引键值从0顺序重排

var_dump($b);
array_unshift($b,'unshift');//加在第一个 0，所有索引键值从0顺序重排
var_dump($b);
$b = array('1229600459'=>'large', '0x45'=>20, 1229609459=>'red','44'=>44);
array_push($b,'push');//索引键值，最大的索引键值加1
var_dump($b);

array_fill

array array_fill ( int $start_index , int $num , mixed $value )
array_fill() 用 value 参数的值将一个数组填充 num 个条目，键名由 start_index 参数指定的开始。

array_fill_keys

array array_fill_keys ( array $keys , mixed $value )
使用 value 参数的值作为值，使用 keys 数组的值作为键来填充一个数组。
keys 使用该数组的值作为键。非法值将被转换为字符串。

$a = array_fill(5, 6, 'banana');
print_r($a);
/*
Array
(
    [5]  => banana
    [6]  => banana
    [7]  => banana
    [8]  => banana
    [9]  => banana
    [10] => banana
)
*/

$keys = array('foo', 5, 10, 'bar');
$a = array_fill_keys($keys, 'banana');
print_r($a);
/*
Array
(
    [foo] => banana
    [5] => banana
    [10] => banana
    [bar] => banana
)*/

五、集合运算

array_diff

差集，仅比较值

array_diff(A,B) returns all elements from A, which are not elements of B (= A without B).
两个单元仅在 (string) $elem1 === (string) $elem2 时被认为是相同的。也就是说，当字符串的表达是一样的时候。
注意本函数只检查了多维数组中的一维。当然可以用 array_diff($array1[0], $array2[0]); 检查更深的维度。

array_diff_key

差集，仅比较键

array_diff_assoc

差集，比较键和值，即当键与值均相同时才被认为是同样的元素。判断同与不同均执行严格的全等于检查

array_diff_ukeys

使用用户自定义函数，通过键名比较，带u的表示user，即用户自定义的比较形式

array_diff_uassoc

自定义函数，键和值比较差值运算
##array_intersect
交集运算，（转）字符串后相等即相等
在这里插入图片描述
array_intersect_key
array_intersect_assoc
array_intersect_ukey
array_intersect_uassoc
对于差集和交集，还有用回调函数处理值的（array_udiff），或同时使用两个回调函数来处理键和值（array_udiff_uassoc、array_uintersect_uassoc）等等。

六、类数据结构处理

array_push 从数组末尾添加元素，可一次添加多个
array_pop 从末端弹出一个元素
array_shift 从头部弹出一个元素
array_unshift 从头部添加一个元素
以上函数就可以模拟栈、队列等结构

$arr=[1,2,3,4,5];
next($arr);
var_dump(current($arr));//int 2
//array_pop($arr);  //var_dump(current($arr)); 结果 int 1 重置指针
//array_push($arr,'push');   //var_dump(current($arr)); 结果 int 2 未重置指针
//array_shift($arr);   //var_dump(current($arr)); 结果 int 2 重置指针
array_unshift($arr,'unshift');   //var_dump(current($arr)); 结果 string 'unshift' (length=7) 重置指针
var_dump(current($arr));

七、使用回调函数

array_reduce

mixed array_reduce ( array $array , callable $callback [, mixed $initial = NULL ] )
使用自定义函数将数组中的值转化为一个值，比如相乘、相加等

function sum($carry, $item)//累加器，数组的每一个值
{
    $carry += $item;
    return $carry;
}

function product($carry, $item)
{
    $carry *= $item;
    return $carry;
}

$a = array(1, 2, 3, 4, 5);
$x = array();

var_dump(array_reduce($a, "sum")); // int(15)
var_dump(array_reduce($a, "product", 10)); // int(1200), because: 10*1*2*3*4*5，类似累加器$carry初始值为10
var_dump(array_reduce($x, "sum", "No data to reduce")); // string(17) "No data to reduce"

array_walk

对数组中每个元素使用回调函数遍历一遍，类似foreach，返回bool值
只有 array 的值才可以被改变，用户不应在回调函数中改变该数组本身的结构。例如增加/删除单元，unset 单元等等。

array_walk ( array &$array , callable $callback [, mixed $userdata = NULL ] ) : bool

callback 接受两个参数。array 参数的值作为第一个，键名作为第二个；如果 callback 需要直接作用于数组中的值，则给 callback 的第一个参数指定为引用

// 使用方法类
// class is static:
array_walk($array, array('self', 'walkFunction'));
array_walk($array, array('className', 'walkFunction'));
// Otherwise:
array_walk($array, array($this, 'walkFunction'));

array_walk_recursive

上面的递归版本，子元素为数组时，将子元素中的每一个元素再使用回调函数处理一遍

array_filter

array array_filter ( array $array [, callable $callback [, int $flag = 0 ]] )
依次将 array 数组中的每个值传递到 callback 函数。如果 callback 函数返回 true，则 array 数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。
callback
使用的回调函数
如果没有提供 callback 函数， 将删除 array 中所有等值为 FALSE 的条目。更多信息见转换为布尔值。

flag
决定callback接收的参数形式:
ARRAY_FILTER_USE_KEY - callback接受键名作为的唯一参数
ARRAY_FILTER_USE_BOTH - callback同时接受键名和键值

array_map

array array_map ( callable $callback , array $array1 [, array $... ] )

返回数组，是为 array1 [, array… ] 每个元素应用 callback函数（已定义的函数名或者匿名函数）之后的数组。
参数为一个数组时，callback中返回的值作为新的值，key不变，关联数组仍为关联数组
多个数组，回调函数的参数个数需与数组参数个数保持一致，遍历处理时回调参数与数组参数顺序一一对应，返回回调处理后的一维索引数组。如果数组元素不够将以空代替。

$yuwen=[57,98,90,87,45,34,78];
$new_yuwen=array_map(function($v){
    if($v<60){
        return $v+15;
    }
    return $v; //如果没有这个return，则新数组value变为null
},$yuwen);

// 一个数组参数，原数组为关联数组的仍返回关联数组
$yuwen_asso=['xiaoming'=>57,'xiaoli'=>98,'xiaowang'=>90,87,'xiaoxin'=>45,34,78];
$yuwen_asso_new=array_map(function($v){
    if($v<60){
        return $v+15;
    }
    return $v;
},$yuwen_asso);

//多个数组参数，返回索引数组
$yuwen = [57, 98, 90, 87];
$shuxue = [56, 78, 98, 100];
$yingyu = [100, 97, 56, 111];
$max_score = array_map('max', $yuwen, $shuxue, $yingyu);
var_dump($max_score);

$list = array_map(null, $yuwen, $shuxue, $yingyu);
var_dump($list);

$yuwen = ['xiaoming' => 57, 'xiaoli' => 98, 'xiaowang' => 90, 'xiaoxin' => 87];
$shuxue = ['xiaoming' => 56, 'xiaoli' => 78, 'xiaowang' => 98, 'xiaoxin' => 100];
$yingyu = ['xiaoming' => 100, 'xiaoli' => 97, 'xiaowang' => 56, 'xiaoxin' => 111];
//都转变为索引数组，根上面的结果一致
$max_score = array_map('max', $yuwen, $shuxue, $yingyu);
var_dump($max_score);

$list = array_map(null, $yuwen, $shuxue, $yingyu);
var_dump($list);

使用命名空间函数

<?php
namespace Test;
function mapping_function($var)  {
    ...
}
array_map('Test\mapping_function', $array);  //using FQNS.
?>

同时使用key value

function callback($k, $v) { ... }
array_map( "callback", array_keys($array), $array);

八、排序函数

sort 升序排列，可以更改各种排序模式
rsort 降序排列（r：reverse，颠倒，倒置，即反向的意思）
usort 使用用户自定义函数排序（user）
asort 升序排列，保持原索引不变（association）
arsort 类上的降序排列
uasort 用户自定义函数升序排列，保持原键名
ksort 按照键名，升序排列（key）
uksort 使用用户自定义函数，按照键名升序排列
krsort 按照键名，降序排列
natsort 使用自然排序法进行升序排列
natcasesort natsort不区分大小写的版本
array_multisort 对多个或多维数组排序，实现多个或多维数组联动排序，可达到SQL语句的order by多个字段的效果

九、其他函数

range

array range ( mixed $start , mixed $end [, number $step = 1 ] )
建立一个包含指定范围单元的索引数组。

shuffle

bool shuffle ( array &$array )
本函数打乱（随机排列单元的顺序）一个数组。

array_rand

mixed array_rand ( array $array [, int $num = 1 ] )
(数组，个数);随机地从数组内取得元素，取的是下标！

array_sum

求数组中的所有值的和

echo array_sum(array(1,'22','3ab','1e3'));//1026
echo array_sum(array('0xA','011',011));//30 10+11+9

array_product

求数组中所有值得积

$a = array(2, 4, 6, 8);
echo "product(a) = " . array_product($a) . "\n";
echo "product(array()) = " . array_product(array()) . "\n";

count/sizeof

int count ( mixed $array_or_countable [, int $mode = COUNT_NORMAL ] )
array_or_countable
数组或者 Countable 对象。

mode
如果可选的 mode 参数设为 COUNT_RECURSIVE（或 1），count() 将递归地对数组计数。对计算多维数组的所有单元尤其有用。

如果参数既不是数组，也不是实现 Countable 接口的对象，如字符串、bool、数字，将返回 1；如果  是 NULL 则结果是 0。

指针

current() 函数返回当前被内部指针指向的数组单元的值，并不移动指针。如果内部指针指向超出了单元列表的末端，current() 返回 FALSE。
next() 它返回的是下一个数组单元的值并将数组指针向前移动了一位。
prev 返回数组内部指针指向的前一个单元的值，或当没有更多单元时返回 FALSE。将数组的内部指针倒回一位

$transport = array('foot', 'bike', 'car', 'plane');
$mode = current($transport); // $mode = 'foot';
$mode = next($transport);    // $mode = 'bike';
$mode = next($transport);    // $mode = 'car';
$mode = prev($transport);    // $mode = 'bike';
$mode = end($transport);     // $mode = 'plane';
echo '---------------------------<br>';

php 5.6结果，php 7中current不会触发非法指针的重置，赋值会

$arr1=[1,2,3];
next($arr1);
$arr2=$arr1;
var_dump(current($arr2));
//---------------------------

$arr1=[1,2,3];
end($arr1);
next($arr1);//非法了
$arr2=$arr1;//值传递 COW 写时复制copy on write
//注意，current也会发出写操作，导致空间被复制！先current谁，谁是那个新的，指针被初始化！
var_dump(current($arr2));// 1
echo '<br>';
var_dump(current($arr1));// false
//------------------------------------

$arr1=[1,2,3];
end($arr1);
next($arr1);//非法了
$arr2=$arr1;

var_dump(current($arr1));// 1
echo '<br>';
var_dump(current($arr2));// false
//------------------------------------

$arr1=[1,2,3];
end($arr1);
next($arr1);//非法了
$arr2=$arr1;

$arr2[]=4;//$arr 改了，开辟新空间存新数组，让$arr2使用新空间，指针被初始化
var_dump(current($arr1));// false
echo '<br>';
var_dump(current($arr2));// 1

数组索引重排

二维数组，数字索引、关联索引混合，全部变为数字索引

array_values、array_column、array_chunk、array_splice、sort、rsort、shuffle
array_merge、array_slice索引键会保留
unset并不会重排键值

$records = array(
    'John'=>array(
        'id' => 2135,
        'first_name' => 'John',
        'last_name' => 'Doe',
    ),
    'Sally'=>array(
        'id' => 3245,
        'first_name' => 'Sally',
        'last_name' => 'Smith',
    ),
);

$records[10]=    array(
        'id' => 56238,
        'first_name' => 'Peter',
        'last_name' => 'Doe',
    );

var_dump($records);

$index_key = array_column($records, null);
var_dump($index_key);

$index_key2=array_chunk($records,count($records));
var_dump($index_key2[0]);

$empty=[];
array_splice($empty,0,0,$records);
var_dump($empty);

$index_key4=$records;
array_splice($index_key4,0,count($index_key4),$index_key4);
var_dump($index_key4);

var_dump(array_values($records));

$index_key5=$records;
var_dump(shuffle($index_key5),$index_key5);

$index_key6=$records;
var_dump(sort($index_key6),$index_key6);

一维数组，数字索引、关联索引混合，全部变为数字索引

$records=[0,‘one’=>‘one’,‘two’=>‘two’,‘three’=>‘three’,4,‘10’=>10];
以上二维数组的，去除array_column

一维数组，只有数字索引，对数字索引从0重排

array_values、array_merge
array_slice array_splice
shuffle、sort、rsort、array_reverse
array_chunk array_pad + array_pop array_unshift + array_shift

$records=['2'=>0,'one','two','three',4,'10'=>10];

var_dump(array_merge($records));

$records1=array_pad($records,count($records)+1,null);
array_pop($records1);
var_dump($records1);

var_dump(array_reverse($records));

$records2=$records;
array_unshift($records2,null);
array_shift($records2);
var_dump($records2);

var_dump(array_slice($records,0));

$records3=$records;
array_splice($records3,0,0);
var_dump($records3);

$records4=$records;
$records5=array_splice($records4,0);
var_dump($records5);

对数组原值操作（引用传递）

排序类（sort shuffle）、队栈操作（push pop unshift shift）、array_splice、array_walk

array_walk($arr,function($v,$k){});
array_walk($arr,function($v,$k,$userdata){},$userdata);
array_walk($arr,function(&$v,$k,$userdata){},$userdata);

辨析

array_pad、array_fill、range、array_fill_keys

$n=4;
var_dump(range(0,$n));
var_dump(array_pad([],$n,1));
var_dump(array_fill(0,$n,1));
/**
array (size=5)
  0 => int 0
  1 => int 1
  2 => int 2
  3 => int 3
  4 => int 4
  
array (size=4)
  0 => int 1
  1 => int 1
  2 => int 1
  3 => int 1

array (size=4)
  0 => int 1
  1 => int 1
  2 => int 1
  3 => int 1
  */

array_flip、array_reverse

array_merge、+号、array_combine、array_replace
这里写图片描述

in_array、array_key_exists、isset、array_search、array_keys

array_rand、shuffle

array_map、array_walk

#参考
php.net
PHP之数组函数归类
 PHP数组常用函数分类整理
 为什么in_array(0, [‘a’, ‘b’, ‘c’])返回true
Differences between array_replace and array_merge in PHP

abcPHP

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
PHP之数组函数归类辨析

数组键值特性key 可以是 integer 或者 string。value 可以是任意类型。此外 key 会有如下的强制转换：包含有合法整型值的字符串会被转换为整型。例如键名 “8” 实际会被储存为 8。但是 “08” 则不会强制转换，因为其不是一个合法的十进制数值。浮点数也会被转换为整型，意味着其小数部分会被舍去。例如键名 8.7 实际会被储存为 8。布尔值也会
复制链接

扫一扫