文章目录
- 数组内部指针控制
- current(); 读取指针位置的内容
- key(); 读取当前指针指向内容的索引值
- next(); 将数组中的内部指针指向下一单元
- prev(); 将数组内部指针倒回一位
- end(); 将数组内部指针指向最后一个元素
- reset(); 将目前指针指向第一个索引位置
- list(); 不是真正的函数，而是PHP的语言结构，用于给一组变量赋值，仅能用于索引数组
- each(); //返回数组当前元素的键值对，并将指针移动到下一个元素位置(php7.2已被废弃)
- 数组键值操作函数
- array_values(\$arr); //获得数组的值
- array_keys(\$arr); //获得数组的键名
- array_flip(\$arr); //数组中的值与键名互换（如果有重复前面的会被后面的覆盖）
- array_search('PHP',\$arr); //检索给定的值，加true则是严格类型检查
- array_reverse(\$arr); //将数组中的元素翻转(前后顺序)
- in_array("apple", \$arr); //在数组中检索apple
- array_key_exists("apple", \$arr); // 检索给定的键名是否存在数组中
- array_count_values(\$arr); // 统计数组中所有值出现的次数
- array_unique(\$arr); // 删除数组中重复的值
- array_column() 返回数组中指定的一列
- array_combine 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
- array_fill() 用给定的值填充数组
- 数组回调函数
- array_filter(); 使用回调函数过滤数组中的元素 回调返回true则当前的元素被包含到返回数组中
- array_walk(); 回调函数处理数组 函数要有两个参数 本函数第三个参数可以作为回调第三个参数返回
- array_map(); //可以处理多个数组，每个数组的长度应该相同，传入数组的个数和回调函数参数个数应该一致
- 数组的分段和填充
- array_slice(\$arr, 0, 3); //将数组中的一段取出，此函数忽略键名（数组的分段）
- array_splice(\$arr, 0, 3，array("black","maroon")); //将数组中的一段取出，返回的序列从原数组中删除
- array_chunk(\$arr, 3, TRUE); //将一个数组分割成多个，TRUE为保留原数组的键名（分割多个数组）
- 数组与栈，列队
- array_push(\$arr, "apple", "pear"); //将一个或多个元素压入数组栈的末尾（入栈），返回入栈元素的个数
- array_pop(\$arr); // 将数组栈的最后一个元素弹出（出栈）
- array_shift(\$arr); //数组中第一个元素移出并返回（长度减1，其他元素向前移动一位，数字键名改为从零计数，文字键名不变）
- array_unshift(\$arr,"a",array(1,2)); //在数组的开头插入一个或多个元素
- 数组的排序
- sort(\$arr); 由小到大的顺序排序（第二个参数为按什么方式排序）忽略键名的数组排序
- rsort(\$arr); 由大到小的顺序排序（第二个参数为按什么方式排序）忽略键名的数组排序
- usort(\$arr,"function"); 使用用户自定义的比较函数对数组中的值进行排序（function中有两个参数，返回0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）忽略键名的数组排序
- asort(\$arr); 由小到大的顺序排序（第二个参数为按什么方式排序）保留键名的数组排序
- arsort(\$arr); 由大到小的顺序排序（第二个参数为按什么方式排序）保留键名的数组排序
- uasort(\$arr,"function"); 使用用户自定义的比较函数对数组中的值进行排序（function中有两个参数，0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）保留键名的数组排序
- ksort(\$arr); 按照键名正序排序
- krsort(\$arr); 按照键名逆序排序
- uksort(\$arr,"function"); 使用用户自定义的比较函数对数组中的键名进行排序（function中有两个参数，0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）
- natsort($arr); 自然排序（忽略键名）
- natcasesort($arr); 自然排序（忽略大小写，忽略键名）
- 数组的计算
- array_sum(\$arr); //对数组内部的所有元素做求和运算（数组元素的求和）
- array_merge(\$arr1, \$arr2); //合并两个或多个（相同字符串键名，后面覆盖前面，相同的数字键名，后面的附加到后面）
- array_diff(\$arr1, \$arr2); //返回差集结果数组
- array_diff_assoc(\$arr1, \$arr2, \$arr3); //返回差集结果数组，键名也做比较
- array_intersect(\$arr1, \$arr2); //返回交集结果数组
- array_intersect_assoc(\$arr1, \$arr2); //返回交集结果数组，键名也做比较
- 其他的数组函数
- array_unique(\$arr); //移除数组中重复的值，新的数组中会保留原始的键名
- shuffle(\$arr); // 将数组的顺序打乱
- array_rand //从数组中随机取出一个或多个单元
数组内部指针控制
current(); 读取指针位置的内容
$arr = [
'name'=>'antor',
'age' => 18,
'sex' => '男',
];
var_dump(current($arr));//string(5) "antor"
end($arr);//将指针指向数组末尾
var_dump(current($arr));//string(5) "男"
key(); 读取当前指针指向内容的索引值
$arr = [
'name'=>'antor',
'age' => 18,
'sex' => '男',
];
var_dump(key($arr));//string(5) "name"
end($arr);//将指针指向数组末尾
var_dump(key($arr));//string(5) "sex"
next(); 将数组中的内部指针指向下一单元
$arr = [
'name'=>'antor',
'age' => 18,
'sex' => '男',
];
var_dump(key($arr));//string(5) "name"
next($arr);//将指针指向数组下一个单元
var_dump(key($arr));//string(5) "age"
prev(); 将数组内部指针倒回一位
end(); 将数组内部指针指向最后一个元素
reset(); 将目前指针指向第一个索引位置
list(); 不是真正的函数，而是PHP的语言结构，用于给一组变量赋值，仅能用于索引数组
$info = array('one', 'two', 'three');
// 列出所有变量
list($drink, $color, $power) = $info;
echo "$drink is $color and $power makes it special.\n";
// 列出他们的其中一个
list($drink, , $power) = $info;
echo "$drink has $power.\n";
// 或者让我们跳到仅第三个
list( , , $power) = $info;
echo "I need $power!\n";
// list() 不能对字符串起作用
list($bar) = "abcde";
var_dump($bar); // NULL
each(); //返回数组当前元素的键值对，并将指针移动到下一个元素位置(php7.2已被废弃)
$arr = [
'name'=>'antor',
'age' => 18,
'sex' => '男',
];
var_dump(each($arr));
/*
array(4) {
[1] =>string(5) "antor"
'value' =>string(5) "antor"
[0] =>string(4) "name"
'key' =>string(4) "name"
}
*/
var_dump(each($arr));
/*
array(4) {
[1] =>int(18)
'value' =>int(18)
[0] =>string(3) "age"
'key' =>string(3) "age"
}
*/
数组键值操作函数
array_values($arr); //获得数组的值
$info = array('one'=>'11', 'two'=>22, 'three'=>11);
var_dump(array_values($info));
/**
array(3) {
[0] =>string(2) "11"
[1] =>int(22)
[2] =>int(11)
}
*/
array_keys($arr); //获得数组的键名
$info = array('one'=>'11', 'two'=>22, 'three'=>11);
var_dump(array_keys($info));
/**
array(3) {
[0] =>string(3) "one"
[1] =>string(3) "two"
[2] =>string(5) "three"
}
*/
array_flip($arr); //数组中的值与键名互换（如果有重复前面的会被后面的覆盖）
$info = array('one'=>'11', 'two'=>22, 'three'=>11);
var_dump(array_flip($info));
/**
array(2) {
[11] =>
string(5) "three"
[22] =>
string(3) "two"
}
*/
array_search(‘PHP’,$arr); //检索给定的值，加true则是严格类型检查
$info = array('one'=>'11', 'two'=>22, 'three'=>11);
var_dump(array_search(11,$info));//one
var_dump(array_search(11,$info,true));//three
array_reverse($arr); //将数组中的元素翻转(前后顺序)
$info = array(11,'one'=>'11', 'two'=>22, 'three'=>11,44);
print_r(array_reverse($info));
/**
Array
(
[0] => 44
[three] => 11
[two] => 22
[one] => 11
[1] => 11
)
*/
print_r(array_reverse($info,true));
/**
Array
(
[1] => 44
[three] => 11
[two] => 22
[one] => 11
[0] => 11
)
*/
in_array(“apple”, $arr); //在数组中检索apple
array_key_exists(“apple”, $arr); // 检索给定的键名是否存在数组中
array_count_values($arr); // 统计数组中所有值出现的次数
$info = array(11,'one'=>'11', 'two'=>22, 'three'=>11,44);
print_r(array_count_values($info));
/**
Array
(
[11] => 3
[22] => 1
[44] => 1
)
*/
array_unique($arr); // 删除数组中重复的值
$info = array(11,'one'=>'11', 'two'=>22, 'three'=>11,44);
print_r(array_unique($info));
/**
Array
(
[0] => 11
[two] => 22
[1] => 44
)
*/
array_column() 返回数组中指定的一列
$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',
)
);
print_r(array_column($records, 'first_name'));
print_r(array_column($records,'first_name','id'));
/*
Array
(
[0] => John
[1] => Sally
[2] => Jane
[3] => Peter
)
Array
(
[2135] => John
[3245] => Sally
[5342] => Jane
[5623] => Peter
)
*/
array_combine 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);
print_r($c);
/**
Array
(
[green] => avocado
[red] => apple
[yellow] => banana
)
*/
array_fill() 用给定的值填充数组
$a = array_fill(5, 3, 'banana');
$b = array_fill(-2, 4, ['bear']);
print_r($a);
/**
Array
(
[5] => banana
[6] => banana
[7] => banana
)
*/
print_r($b);
/*
Array
(
[-2] => Array
(
[0] => bear
)
[0] => Array
(
[0] => bear
)
[1] => Array
(
[0] => bear
)
[2] => Array
(
[0] => bear
)
)
*/
数组回调函数
array_filter(); 使用回调函数过滤数组中的元素 回调返回true则当前的元素被包含到返回数组中
function odd($var,$key)
{
// returns whether the input integer is odd
return (($var & 1) && $key == 'c');
}
$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);
print_r(array_filter($array1, "odd",ARRAY_FILTER_USE_BOTH));
echo "Even:\n";
print_r(array_filter($array2, function($var){
// returns whether the input integer is even
return (!($var & 1));
}));
array_walk(); 回调函数处理数组 函数要有两个参数 本函数第三个参数可以作为回调第三个参数返回
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
function test_alter(&$item1, $key, $prefix)
{
$item1 = "$prefix: $item1";
}
function test_print($item2, $key)
{
echo "$key. $item2<br />\n";
}
echo "Before ...:\n";
array_walk($fruits, 'test_print');
array_walk($fruits, 'test_alter', 'fruit');
echo "... and after:\n";
array_walk($fruits, 'test_print');
/**
Before ...:
d. lemon<br />
a. orange<br />
b. banana<br />
c. apple<br />
... and after:
d. fruit: lemon<br />
a. fruit: orange<br />
b. fruit: banana<br />
c. fruit: apple<br />
*/
array_map(); //可以处理多个数组，每个数组的长度应该相同，传入数组的个数和回调函数参数个数应该一致
$func = function($value) {
return $value * 2;
};
print_r(array_map($func, range(1, 5)));
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
)
//-----------------------------------------------------------
function map_Spanish($n, $m)
{
return(array($m => $n));
}
$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");
$d = array_map("map_Spanish", $a , $b);
print_r($d);
Array
(
[0] => Array
(
[uno] => 1
)
[1] => Array
(
[dos] => 2
)
[2] => Array
(
[tres] => 3
)
[3] => Array
(
[cuatro] => 4
)
[4] => Array
(
[cinco] => 5
)
)
数组的分段和填充
array_slice($arr, 0, 3); //将数组中的一段取出，此函数忽略键名（数组的分段）
$a = array(1, 2, 3, 4, 5);
print_r(array_slice($a,2,2));
print_r(array_slice($a,2,2,true));
Array
(
[0] => 3
[1] => 4
)
Array
(
[2] => 3
[3] => 4
)
array_splice($arr, 0, 3，array(“black”,“maroon”)); //将数组中的一段取出，返回的序列从原数组中删除
$a = array(1, 2, 3, 4, 5);
print_r(array_splice($a,0,2));
print_r(array_splice($a,0,2,['111','222']));
print_r($a);
Array
(
[0] => 1
[1] => 2
)
Array
(
[0] => 3
[1] => 4
)
Array
(
[0] => 111
[1] => 222
[2] => 5
)
array_chunk($arr, 3, TRUE); //将一个数组分割成多个，TRUE为保留原数组的键名（分割多个数组）
a = array(1, 2, 3, 4, 5);
print_r(array_chunk($a,2));
print_r(array_chunk($a,2,true));
Array
(
[0] => Array
(
[0] => 1
[1] => 2
)
[1] => Array
(
[0] => 3
[1] => 4
)
[2] => Array
(
[0] => 5
)
)
Array
(
[0] => Array
(
[0] => 1
[1] => 2
)
[1] => Array
(
[2] => 3
[3] => 4
)
[2] => Array
(
[4] => 5
)
)
数组与栈，列队
array_push($arr, “apple”, “pear”); //将一个或多个元素压入数组栈的末尾（入栈），返回入栈元素的个数
$a = array('one'=>1, 2, 3, 4, 5);
print_r(array_push($a,'111',['22','333']));
echo PHP_EOL;
print_r($a);
/*
7
Array
(
[one] => 1
[0] => 2
[1] => 3
[2] => 4
[3] => 5
[4] => 111
[5] => Array
(
[0] => 22
[1] => 333
)
)
*/
array_pop($arr); // 将数组栈的最后一个元素弹出（出栈）
$a = array('one'=>1, 2, 3, 4, 5);
print_r(array_pop($a));
echo PHP_EOL;
print_r($a);
/*
5
Array
(
[one] => 1
[0] => 2
[1] => 3
[2] => 4
)
*/
array_shift($arr); //数组中第一个元素移出并返回（长度减1，其他元素向前移动一位，数字键名改为从零计数，文字键名不变）
$a = array('one'=>1, 2, 3, 4, 5);
print_r(array_shift($a));
echo PHP_EOL;
print_r($a);
/*
1
Array
(
[0] => 2
[1] => 3
[2] => 4
[3] => 5
)
*/
array_unshift($arr,“a”,array(1,2)); //在数组的开头插入一个或多个元素
$a = array('one'=>1, 2, 3, 4, 5);
print_r(array_unshift($a,'aa',['111','222']));
echo PHP_EOL;
print_r($a);
/*
7
Array
(
[0] => aa
[1] => Array
(
[0] => 111
[1] => 222
)
[one] => 1
[2] => 2
[3] => 3
[4] => 4
[5] => 5
)
*/
数组的排序
sort($arr); 由小到大的顺序排序（第二个参数为按什么方式排序）忽略键名的数组排序
$fruits = array(
"Orange1", "orange2", "Orange3", "orange20"
);
sort($fruits);
foreach ($fruits as $key => $val) {
echo "fruits[" . $key . "] = " . $val . "\n";
}
/*
fruits[0] = Orange1
fruits[1] = Orange3
fruits[2] = orange2
fruits[3] = orange20
*/
echo PHP_EOL;
sort($fruits, SORT_NATURAL | SORT_FLAG_CASE);
foreach ($fruits as $key => $val) {
echo "fruits[" . $key . "] = " . $val . "\n";
}
/*
fruits[0] = Orange1
fruits[1] = orange2
fruits[2] = Orange3
fruits[3] = orange20
*/
rsort($arr); 由大到小的顺序排序（第二个参数为按什么方式排序）忽略键名的数组排序
usort($arr,“function”); 使用用户自定义的比较函数对数组中的值进行排序（function中有两个参数，返回0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）忽略键名的数组排序
asort($arr); 由小到大的顺序排序（第二个参数为按什么方式排序）保留键名的数组排序
arsort($arr); 由大到小的顺序排序（第二个参数为按什么方式排序）保留键名的数组排序
uasort($arr,“function”); 使用用户自定义的比较函数对数组中的值进行排序（function中有两个参数，0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）保留键名的数组排序
ksort($arr); 按照键名正序排序
krsort($arr); 按照键名逆序排序
uksort($arr,“function”); 使用用户自定义的比较函数对数组中的键名进行排序（function中有两个参数，0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）
natsort($arr); 自然排序（忽略键名）
natcasesort($arr); 自然排序（忽略大小写，忽略键名）
数组的计算
array_sum($arr); //对数组内部的所有元素做求和运算（数组元素的求和）
array_merge($arr1, $arr2); //合并两个或多个（相同字符串键名，后面覆盖前面，相同的数字键名，后面的附加到后面）
array_diff($arr1, $arr2); //返回差集结果数组
array_diff_assoc($arr1, $arr2, $arr3); //返回差集结果数组，键名也做比较
array_intersect($arr1, $arr2); //返回交集结果数组
array_intersect_assoc($arr1, $arr2); //返回交集结果数组，键名也做比较
其他的数组函数
array_unique($arr); //移除数组中重复的值，新的数组中会保留原始的键名
shuffle($arr); // 将数组的顺序打乱
array_rand //从数组中随机取出一个或多个单元
更多推荐
php常用数组函数
发布评论