[PHP从小白到大牛]-018 PHP数组函数EXTR_OVERWRITE 如果有冲突，覆盖已有的变量。 EXTR_SK

数组函数库

创建数组操作

`range($min,$max[$step=1])`:快速创建下标连续的索引数组

range(开始, 结束, 步长)

第一个参数: 最小值, 开始
第二个参数: 最大值, 结束
第三个参数: 步长, 默认是1

range('a','z'); // 从a到z, 26个字母, 索引数组

`compact($varname,$varname....)`:快速创建关联数组

把多个变量, 生成一个关联数组
参数可以有多个, 变量名字符串

<?php

$username = "zhangsan";
$sex = "male";
$age = 18;

$arr = compact('username','sex','age');

var_dump($arr);

D:\php20190701\php_code\0809\array_fun.php:10:
array (size=3)
  'username' => string 'zhangsan' (length=8)
  'sex' => string 'male' (length=4)
  'age' => int 18

`array_fill($start_index,$num,$value)`:用给定的值填充数组

第一个参数: 开始的下标
第二个参数: 元素个数
第三个参数: 元素的值

<?php


$arr1 = array_fill(3,4,'blue');


var_dump($arr1);

D:\php20190701\php_code\0809\array_fun.php:7:
array (size=4)
  3 => string 'blue' (length=4)
  4 => string 'blue' (length=4)
  5 => string 'blue' (length=4)
  6 => string 'blue' (length=4)

`array_fill_keys($keys,$value)`:使用指定的键和值填充数组

第一个参数: 键名的数组
第二个参数: 键名对应的键值

<?php

$keys = array('a','b','c');

$arr = array_fill_keys($keys, 'blue');

var_dump($arr);

D:\php20190701\php_code\0809\array_fun.php:7:
array (size=3)
  'a' => string 'blue' (length=4)
  'b' => string 'blue' (length=4)
  'c' => string 'blue' (length=4)

<?php

$keys = array('a','b','c');

$values = array('aaa','bbb','ccc');

$arr = array_fill_keys($keys, $values);

var_dump($arr);

D:\php20190701\php_code\0809\array_fun.php:9:
array (size=3)
  'a' => 
    array (size=3)
      0 => string 'aaa' (length=3)
      1 => string 'bbb' (length=3)
      2 => string 'ccc' (length=3)
  'b' => 
    array (size=3)
      0 => string 'aaa' (length=3)
      1 => string 'bbb' (length=3)
      2 => string 'ccc' (length=3)
  'c' => 
    array (size=3)
      0 => string 'aaa' (length=3)
      1 => string 'bbb' (length=3)
      2 => string 'ccc' (length=3)

`array_combine($keys,$values)`:创建一个数组，用一个数组的值作为其键名, 另一个数组的值, 作为键值

第一个参数: 作为键名的索引数组, 如果是关联数组, 只取键值
第二个参数: 作为键值的索引数组, 如果是关联数组, 只取键值
如果两个参数的元素数量不一致, 返回false, 报warning

<?php

$keys = array('a','b','c');

$values = array('aaa','bbb','ccc');

$arr = array_combine($keys, $values);

var_dump($arr);

D:\php20190701\php_code\0809\array_fun.php:9:
array (size=3)
  'a' => string 'aaa' (length=3)
  'b' => string 'bbb' (length=3)
  'c' => string 'ccc' (length=3)

键值相关操作

`count($var[,$mode=COUNT_NORMAL])/sizeof()`:计算数组中的元素数量

count和sizeof是一样的功能
空数组是0
第二个参数, 如果是0, 只计算第一层, 如果是1, 递归计算
count是sizeof的别名, 功能一样

`array_keys($array)`:取得数组的键名作为`下标连续的索引数组`返回

如果只有一个, 也是返回数组
第二个参数: 键值, 只返回该键值, 对应的键名, 根据键值找键名
第三个参数: 布尔值, true, false true相当于===, false 相当于 ==, 默认是false

<?php

$arr = ['Volvo'=>'XC90',"BMW"=>"X5","Toyota"=>"Highlander"];

var_dump(array_keys($arr));

D:\php20190701\php_code\0809\array_fun.php:5:
array (size=3)
  0 => string 'Volvo' (length=5)
  1 => string 'BMW' (length=3)
  2 => string 'Toyota' (length=6)

<?php

$arr = ['Volvo'=>'XC90',"BMW"=>"5","Toyota"=>5];

var_dump(array_keys($arr,5,true)); // 5 和 "5" 是不一样的
var_dump(array_keys($arr,5,false)); // 5 和 "5" 一样
var_dump(array_keys($arr,5)); // 默认false

D:\php20190701\php_code\0809\array_fun.php:5:
array (size=1)
  0 => string 'Toyota' (length=6)
D:\php20190701\php_code\0809\array_fun.php:6:
array (size=2)
  0 => string 'BMW' (length=3)
  1 => string 'Toyota' (length=6)
D:\php20190701\php_code\0809\array_fun.php:7:
array (size=2)
  0 => string 'BMW' (length=3)
  1 => string 'Toyota' (length=6)

`array_values($array)`:取得数组的键值作为下标连续的索引数组返回

相当于关联数组转索引数组

<?php

$arr = ['Volvo'=>'XC90',"BMW"=>"X5","Toyota"=>"Highlander"];

var_dump(array_values($arr));

D:\php20190701\php_code\0809\array_fun.php:5:
array (size=3)
  0 => string 'XC90' (length=4)
  1 => string 'X5' (length=2)
  2 => string 'Highlander' (length=10)

`array_flip($array)`:交换数组中的键名和键值

<?php


$arr1 = ['first'=>1,'second'=>2,'third'=>3];


var_dump(array_flip($arr1)); // 键名和键值互换

D:\php20190701\php_code\0809\array_fun.php:7:
array (size=3)
  1 => string 'first' (length=5)
  2 => string 'second' (length=6)
  3 => string 'third' (length=5)

`in_array($search,$array[,$strict])`:检测数组中是否存在某个值

判断一个变量的值, 是否在数组中
第一个参数: 键值
第二个参数: 目标数组
第三个参数: 判断数据类型是否一致, 默认false, 不用检测数据类型

<?php

$arr = ['Volvo'=>'XC90',"BMW"=>"X5","Toyota"=>"Highlander"];

var_dump(in_array("X5",$arr)); // true
var_dump(in_array("X6",$arr)); // false
var_dump(in_array("BMW",$arr)); // false, 只能搜索键值

D:\php20190701\php_code\0809\array_fun.php:5:boolean true
D:\php20190701\php_code\0809\array_fun.php:6:boolean false
D:\php20190701\php_code\0809\array_fun.php:7:boolean false

<?php

$arr = ['Volvo'=>'XC90',"BMW"=>"5","Toyota"=>"5"];

var_dump(in_array(5,$arr,true)); // 相当于 "==="
var_dump(in_array(5,$arr,false)); // 相当于 "=="
var_dump(in_array(5,$arr)); // 默认false

D:\php20190701\php_code\0809\array_fun.php:5:boolean false
D:\php20190701\php_code\0809\array_fun.php:6:boolean true
D:\php20190701\php_code\0809\array_fun.php:7:boolean true

`array_search($search,$array[,$strict])`:在数组中搜索给定的值

根据键值找键名
第一个参数: 键值
第二个参数: 目标数组
第三个参数: 是否检测数据类型, 默认false, 找不见, 返回false
如果有多个相同键值, 返回第一个匹配的键名

<?php

$arr = ['a'=>'red','b'=>'green','c'=>'blue'];

echo array_search('red', $arr);

<?php

$arr = ['a'=>'red','b'=>'green','c'=>'blue','d'=>"5"];

var_dump(array_search(5, $arr,true)); // 相当于 "==="
var_dump(array_search(5, $arr,false)); // 相当于 "=="
var_dump(array_search(5, $arr)); // 默认false

D:\php20190701\php_code\0809\array_fun.php:5:boolean false
D:\php20190701\php_code\0809\array_fun.php:6:string 'd' (length=1)
D:\php20190701\php_code\0809\array_fun.php:7:string 'd' (length=1)

<?php

$arr = ['a'=>'red','b'=>'green','c'=>"5",'d'=>5];

var_dump(array_search(5, $arr,true)); // d
var_dump(array_search(5, $arr,false)); // c
var_dump(array_search(5, $arr)); // c

D:\php20190701\php_code\0809\array_fun.php:5:string 'd' (length=1)
D:\php20190701\php_code\0809\array_fun.php:6:string 'c' (length=1)
D:\php20190701\php_code\0809\array_fun.php:7:string 'c' (length=1)

`array_key_exists($search,$array)`:检查给定的键名或索引是否存在于数组中

有返回true, 没有, 返回false

<?php

$arr = [
	'first'=>'one',
	'second'=>'two',
	'third'=>'three',
];


var_dump(array_key_exists('first',$arr));
var_dump(array_key_exists('first111',$arr));

D:\php20190701\php_code\0809\array_fun3.php:10:boolean true
D:\php20190701\php_code\0809\array_fun3.php:11:boolean false

<?php

$arr = ['one','two','three'];


var_dump(array_key_exists('0',$arr)); // true
var_dump(array_key_exists(0,$arr)); // true
var_dump(array_key_exists('1',$arr)); // true
var_dump(array_key_exists(1,$arr)); // true

`array_reverse($array[,$preserve_keys=false])`:数组倒置

改变数组的元素顺序
不改变原来数组中元素的顺序
第二个参数, 默认flase, 如果是true, 则保留原来的键名, 只针对索引数组

<?php

$arr = ['one','two','three'];


var_dump(array_reverse($arr));
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:6:
array (size=3)
  0 => string 'three' (length=5)
  1 => string 'two' (length=3)
  2 => string 'one' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:7:
array (size=3)
  0 => string 'one' (length=3)
  1 => string 'two' (length=3)
  2 => string 'three' (length=5)

<?php

$arr = ['one','two','three'];


var_dump(array_reverse($arr));
var_dump(array_reverse($arr,false));
var_dump(array_reverse($arr,true));

D:\php20190701\php_code\0809\array_fun3.php:6:
array (size=3)
  0 => string 'three' (length=5)
  1 => string 'two' (length=3)
  2 => string 'one' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:7:
array (size=3)
  0 => string 'three' (length=5)
  1 => string 'two' (length=3)
  2 => string 'one' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:8:
array (size=3)
  2 => string 'three' (length=5)
  1 => string 'two' (length=3)
  0 => string 'one' (length=3)

`shuffle($array)`:打乱数组的元素

会改变原来的数组
如果是关联数组, 键名会丢失

<?php

$arr = ['one','two','three','four','five','six','seven'];


var_dump(shuffle($arr)); // true
var_dump($arr); // 展示结果
var_dump(shuffle($arr)); // true
var_dump($arr); // 展示结果

D:\php20190701\php_code\0809\array_fun3.php:6:boolean true
D:\php20190701\php_code\0809\array_fun3.php:7:
array (size=7)
  0 => string 'three' (length=5)
  1 => string 'five' (length=4)
  2 => string 'seven' (length=5)
  3 => string 'two' (length=3)
  4 => string 'six' (length=3)
  5 => string 'four' (length=4)
  6 => string 'one' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:8:boolean true
D:\php20190701\php_code\0809\array_fun3.php:9:
array (size=7)
  0 => string 'six' (length=3)
  1 => string 'seven' (length=5)
  2 => string 'three' (length=5)
  3 => string 'one' (length=3)
  4 => string 'four' (length=4)
  5 => string 'two' (length=3)
  6 => string 'five' (length=4)

<?php

$arr = [
	'1st'=>'one',
	'2nd'=>'two',
	'3rd'=>'three',
	'4th'=>'four',
	'5th'=>'five',
	'6th'=>'six',
	'7th'=>'seven',
];


var_dump(shuffle($arr)); // true
var_dump($arr); // 展示结果
var_dump(shuffle($arr)); // true
var_dump($arr); // 展示结果

D:\php20190701\php_code\0809\array_fun3.php:14:boolean true
D:\php20190701\php_code\0809\array_fun3.php:15:
array (size=7)
  0 => string 'three' (length=5)
  1 => string 'one' (length=3)
  2 => string 'two' (length=3)
  3 => string 'five' (length=4)
  4 => string 'four' (length=4)
  5 => string 'six' (length=3)
  6 => string 'seven' (length=5)
D:\php20190701\php_code\0809\array_fun3.php:16:boolean true
D:\php20190701\php_code\0809\array_fun3.php:17:
array (size=7)
  0 => string 'seven' (length=5)
  1 => string 'four' (length=4)
  2 => string 'three' (length=5)
  3 => string 'two' (length=3)
  4 => string 'six' (length=3)
  5 => string 'one' (length=3)
  6 => string 'five' (length=4)

`array_unique($array[,$sort_flag=SORT_STRING])`:移除数组中重复的值

去除重复值, 会保留最先出现的值
不会改变原来的数组
如果是关联数组, 键名不会丢失

<?php

$arr = [
	'seven',
	'one',
	'two',
	'three',
	'four',
	'five',
	'six',
	'seven',
];


var_dump(array_unique($arr));
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:15:
array (size=7)
  0 => string 'seven' (length=5)
  1 => string 'one' (length=3)
  2 => string 'two' (length=3)
  3 => string 'three' (length=5)
  4 => string 'four' (length=4)
  5 => string 'five' (length=4)
  6 => string 'six' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:16:
array (size=8)
  0 => string 'seven' (length=5)
  1 => string 'one' (length=3)
  2 => string 'two' (length=3)
  3 => string 'three' (length=5)
  4 => string 'four' (length=4)
  5 => string 'five' (length=4)
  6 => string 'six' (length=3)
  7 => string 'seven' (length=5)

<?php

$arr = [
	"111"=>'seven',
	"222"=>'one',
	"333"=>'two',
	"444"=>'three',
	"555"=>'four',
	"666"=>'five',
	"777"=>'six',
	"888"=>'seven',
];


var_dump(array_unique($arr));
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:15:
array (size=7)
  111 => string 'seven' (length=5)
  222 => string 'one' (length=3)
  333 => string 'two' (length=3)
  444 => string 'three' (length=5)
  555 => string 'four' (length=4)
  666 => string 'five' (length=4)
  777 => string 'six' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:16:
array (size=8)
  111 => string 'seven' (length=5)
  222 => string 'one' (length=3)
  333 => string 'two' (length=3)
  444 => string 'three' (length=5)
  555 => string 'four' (length=4)
  666 => string 'five' (length=4)
  777 => string 'six' (length=3)
  888 => string 'seven' (length=5)

<?php

$arr = [
	123,'123a',123
];


var_dump(array_unique($arr,SORT_STRING));
var_dump(array_unique($arr,SORT_NUMERIC));

D:\php20190701\php_code\0809\array_fun3.php:8:
array (size=2)
  0 => int 123
  1 => string '123a' (length=4)
D:\php20190701\php_code\0809\array_fun3.php:9:
array (size=1)
  0 => int 123

第二个参数, 默认SORT_STRING, 把所有元素转成字符串, 在进行去重的比较, SORT_NUMERIC, 把所有的元素转成数字, 然后进行去重的比较

`array_rand($array[,$num_req=1])`:随机取出数组的键名

第一个参数, 是数组
第二个参数, 是一个数字, 表示取出多少个键名, 随机获取

<?php


$arr1 = ['first'=>1,'second'=>2,'third'=>3];

// 随机返回键名, 是一个数组
// 第二个参数如果不写, 默认是1, 返回就不是数组, 而是数字或者字符串(键名)
// 第二个参数如果是0, 或者超出数组数量, 报warning, 返回null
var_dump(array_rand($arr1,2));

D:\php20190701\php_code\0809\array_fun3.php:8:
array (size=2)
  0 => string 'first' (length=5)
  1 => string 'third' (length=5)

`array_sum($array)`:统计数组中元素值的总和

数组中所有的元素, 先转成数字, 浮点也可以, 然后求和

<?php

$str = "1,2,5,6,9";

$arr = explode(',',$str);

var_dump(array_sum($arr)); // 23

<?php

$arr = ["a1","2b","5c","6d","9e"];


var_dump(array_sum($arr)); // 22

`array_product($array)`:计算数组中所有值的乘积

数组中所有的元素, 先转成数字, 浮点也可以, 然后求乘积

$arr = [1,2,3,4];

var_dump(array_product($arr)); // 24

<?php

$arr = ["1a",'11.1',"5c"];


var_dump(array_product($arr)); // 55.5

`array_count_values($array)`:统计数组中值出现的次数

关联数组和索引数组, 均适用

<?php

$arr = ['red','red','green','orange','grass','orange','grey','blue','grass','pink'];

var_dump(array_count_values($arr));

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=7)
  'red' => int 2
  'green' => int 1
  'orange' => int 2
  'grass' => int 2
  'grey' => int 1
  'blue' => int 1
  'pink' => int 1

`extract($array[,$extract_type=EXTR_OVERWRITE[,$prefix=null]])`:数组转变量

键名转成变量名, 键值转成变量值
如果重名, 会覆盖之前的变量
第二个参数: 出现重复时的处理方案
第三个参数: 前缀, 加载变量名前面, 自动增加_
- EXTR_OVERWRITE 如果有冲突，覆盖已有的变量。
- EXTR_SKIP 如果有冲突，不覆盖已有的变量。
- EXTR_PREFIX_SAME 如果有冲突，在变量名前加上前缀 prefix。
- EXTR_PREFIX_ALL 给所有变量名加上前缀 prefix。

<?php

$arr = [
	"a"=>'red',
	"b"=>'red',
	"c"=>'green'
];

extract($arr);

var_dump($a);
var_dump($b);
var_dump($c);

D:\php20190701\php_code\0809\array_fun3.php:11:string 'red' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:12:string 'red' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:13:string 'green' (length=5)

<?php

$a = "abc";

$arr = [
	"a"=>'red',
	"b"=>'red',
	"c"=>'green'
];

extract($arr,EXTR_PREFIX_ALL,"pre");

var_dump($a);
var_dump($pre_a);
var_dump($pre_b);
var_dump($pre_c);

D:\php20190701\php_code\0809\array_fun3.php:13:string 'abc' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:14:string 'red' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:15:string 'red' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:16:string 'green' (length=5)

`array_pad($array,$size,$value)`:用值将数组填补到指定长度

第一个参数: 目标数组
第二个参数: 补充到的长度, 如果原来的数组已经超过此长度, 不做任何处理
第三个参数: 补充的值, 可以是数组

<?php

$arr = ['red','green'];
var_dump(array_pad($arr,5,'blue'));

D:\php20190701\php_code\0809\array_fun3.php:4:
array (size=5)
  0 => string 'red' (length=3)
  1 => string 'green' (length=5)
  2 => string 'blue' (length=4)
  3 => string 'blue' (length=4)
  4 => string 'blue' (length=4)

<?php

$arr = ['red','green'];
var_dump(array_pad($arr,5,['blue','red','pink']));

D:\php20190701\php_code\0809\array_fun3.php:4:
array (size=5)
  0 => string 'red' (length=3)
  1 => string 'green' (length=5)
  2 => 
    array (size=3)
      0 => string 'blue' (length=4)
      1 => string 'red' (length=3)
      2 => string 'pink' (length=4)
  3 => 
    array (size=3)
      0 => string 'blue' (length=4)
      1 => string 'red' (length=3)
      2 => string 'pink' (length=4)
  4 => 
    array (size=3)
      0 => string 'blue' (length=4)
      1 => string 'red' (length=3)
      2 => string 'pink' (length=4)

数组指针函数

`key($array)`:得到当前指针所在位置元素的键名

<?php

$arr = ['red','green','blue','pink','orange'];
var_dump(key($arr)); // 0

`current($array)|pos($array)`:得到当前指针所在位置元素的键值

<?php

$arr = ['red','green','blue','pink','orange'];
var_dump(current($arr)); // red

`next($array)`:将数组指针向下移动一位，并且返回当前指针所在位置元素的键值

<?php

$arr = ['red','green','blue','pink','orange'];
var_dump(next($arr)); // green

`prev($array)`:将数组指针向上移动一位，并且返回当前指针所在位置元素的键值

没有则返回false

<?php

$arr = ['red','green','blue','pink','orange'];
var_dump(next($arr)); // green

`end($array)`:将数组指针移动倒数组的末尾，并且返回当前指针所在位置元素的键值

<?php

$arr = ['red','green','blue','pink','orange'];
var_dump(end($arr)); // orange

`reset($array)`:将数组指针移动到数组的开始，并且返回当前指针所在位置元素的键值

<?php

$arr = ['red','green','blue','pink','orange'];
var_dump(reset($arr)); // red

`each($array)`:返回数组中当前的键值对，并将数组指针向下移动一位

<?php

$arr = ['red','green','blue','pink','orange'];
var_dump(each($arr)); 
var_dump(each($arr));

D:\php20190701\php_code\0809\array_fun3.php:4:
array (size=4)
  1 => string 'red' (length=3)
  'value' => string 'red' (length=3)
  0 => int 0
  'key' => int 0
D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=4)
  1 => string 'green' (length=5)
  'value' => string 'green' (length=5)
  0 => int 1
  'key' => int 1

`list($var,...)`:将数组中元素的值赋给对应的变量

<?php

$arr = ['red','green','blue','pink','orange'];
list($a,$b,$c,$d,$e) = $arr;
var_dump($a,$b,$c,$d,$e);

D:\php20190701\php_code\0809\array_fun3.php:5:string 'red' (length=3)
D:\php20190701\php_code\0809\array_fun3.php:5:string 'green' (length=5)
D:\php20190701\php_code\0809\array_fun3.php:5:string 'blue' (length=4)
D:\php20190701\php_code\0809\array_fun3.php:5:string 'pink' (length=4)
D:\php20190701\php_code\0809\array_fun3.php:5:string 'orange' (length=6)

`array_unshift($array,$value...)`:在数组开头插入一个元素或者多个元素

<?php

$arr = ['red','green','blue','pink','orange'];
array_unshift($arr,'hello');
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=6)
  0 => string 'hello' (length=5)
  1 => string 'red' (length=3)
  2 => string 'green' (length=5)
  3 => string 'blue' (length=4)
  4 => string 'pink' (length=4)
  5 => string 'orange' (length=6)

`array_shift($array)`:弹出数组的第一个元素

<?php

$arr = ['red','green','blue','pink','orange'];
array_shift($arr);
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=4)
  0 => string 'green' (length=5)
  1 => string 'blue' (length=4)
  2 => string 'pink' (length=4)
  3 => string 'orange' (length=6)

`array_push($array,$value...)`:在数组末尾压入一个元素或者多个元素

<?php

$arr = ['red','green','blue','pink','orange'];
array_push($arr,'hello');
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=6)
  0 => string 'red' (length=3)
  1 => string 'green' (length=5)
  2 => string 'blue' (length=4)
  3 => string 'pink' (length=4)
  4 => string 'orange' (length=6)
  5 => string 'hello' (length=5)

`array_pop($array)`:弹出数组的最后一个元素

<?php

$arr = ['red','green','blue','pink','orange'];
array_pop($arr);
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=4)
  0 => string 'red' (length=3)
  1 => string 'green' (length=5)
  2 => string 'blue' (length=4)
  3 => string 'pink' (length=4)

数组排序函数

`sort($array[,$sort_flag=SORT_REGULAR])`:对数组的键值按照升序排列，不保留键名

第一个参数: 目标数组
第二个参数: 排列的具体规则
- 参见: segmentfault.com/a/119000001…
改参数, 会改变原来的数组, 如果排序成功, 返回true, 失败false

<?php

$arr = ["Volvo","BMW","Toyota"];

var_dump(sort($arr));

var_dump($arr);

D:\php20190701\php_code\0809\array_fun.php:5:boolean true
D:\php20190701\php_code\0809\array_fun.php:7:
array (size=3)
  0 => string 'BMW' (length=3)
  1 => string 'Toyota' (length=6)
  2 => string 'Volvo' (length=5)

`rsort($array[,$sort_flag=SORT_REGULAR])`:对数组键值按照降序排列，不保留键名

<?php

$arr = ["Volvo","BMW","Toyota"];

var_dump(rsort($arr));

var_dump($arr);

D:\php20190701\php_code\0809\array_fun.php:5:boolean true
D:\php20190701\php_code\0809\array_fun.php:7:
array (size=3)
  0 => string 'Volvo' (length=5)
  1 => string 'Toyota' (length=6)
  2 => string 'BMW' (length=3)

`asort($array[,$sort_flag=SORT_REGULAR])`:对数组键值按照升序排列，保留键值对关系

<?php

$arr = [
	"Joe"=>"43",
	"Peter"=>"35",
	"Ben"=>"37",
];

var_dump(asort($arr));

var_dump($arr);

D:\php20190701\php_code\0809\array_fun2.php:9:boolean true
D:\php20190701\php_code\0809\array_fun2.php:11:
array (size=3)
  'Peter' => string '35' (length=2)
  'Ben' => string '37' (length=2)
  'Joe' => string '43' (length=2)

`arsort($array[,$sort_flag=SORT_REGULAR])`:对数组键值按照降序排列，保留键值对关系

<?php

$arr = [
	"Joe"=>"43",
	"Peter"=>"35",
	"Ben"=>"37",
];

var_dump(arsort($arr));

var_dump($arr);

D:\php20190701\php_code\0809\array_fun2.php:9:boolean true
D:\php20190701\php_code\0809\array_fun2.php:11:
array (size=3)
  'Joe' => string '43' (length=2)
  'Ben' => string '37' (length=2)
  'Peter' => string '35' (length=2)

`ksort($array[,$sort_flag=SORT_REGULAR])`:对数组的键名按照升序排列

<?php

$arr = [
	"Joe"=>"43",
	"Peter"=>"35",
	"Ben"=>"37",
];

var_dump(ksort($arr));

var_dump($arr);

D:\php20190701\php_code\0809\array_fun2.php:9:boolean true
D:\php20190701\php_code\0809\array_fun2.php:11:
array (size=3)
  'Ben' => string '37' (length=2)
  'Joe' => string '43' (length=2)
  'Peter' => string '35' (length=2)

`krsort($array[,$sort_flag=SORT_REGULAR])`:对数组的键名按照降序排列

<?php

$arr = [
	"Joe"=>"43",
	"Peter"=>"35",
	"Ben"=>"37",
];

var_dump(krsort($arr));

var_dump($arr);

D:\php20190701\php_code\0809\array_fun2.php:9:boolean true
D:\php20190701\php_code\0809\array_fun2.php:11:
array (size=3)
  'Peter' => string '35' (length=2)
  'Joe' => string '43' (length=2)
  'Ben' => string '37' (length=2)

`natsort($array)`:用自然排序法排序

<?php

$arr = [
	"tmp15.txt",
	"tmp10.txt",
	"tmp1.txt",
	"tmp22.txt",
	"tmp2.txt",
];

var_dump(sort($arr));
var_dump($arr);
var_dump(natsort($arr));
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:11:boolean true
D:\php20190701\php_code\0809\array_fun3.php:12:
array (size=5)
  0 => string 'tmp1.txt' (length=8)
  1 => string 'tmp10.txt' (length=9)
  2 => string 'tmp15.txt' (length=9)
  3 => string 'tmp2.txt' (length=8)
  4 => string 'tmp22.txt' (length=9)
D:\php20190701\php_code\0809\array_fun3.php:13:boolean true
D:\php20190701\php_code\0809\array_fun3.php:14:
array (size=5)
  0 => string 'tmp1.txt' (length=8)
  3 => string 'tmp2.txt' (length=8)
  1 => string 'tmp10.txt' (length=9)
  2 => string 'tmp15.txt' (length=9)
  4 => string 'tmp22.txt' (length=9)

`natcasesort($array)`:用自然排序算法对数组进行不区分大小写字母的排序

<?php

$arr = [
	"tmp15.txt",
	"TMP10.txt",
	"tmp1.txt",
	"TMP22.txt",
	"tmp2.txt",
];

var_dump(natsort($arr));
var_dump($arr);
var_dump(natcasesort($arr));
var_dump($arr);

D:\php20190701\php_code\0809\array_fun3.php:11:boolean true
D:\php20190701\php_code\0809\array_fun3.php:12:
array (size=5)
  1 => string 'TMP10.txt' (length=9)
  3 => string 'TMP22.txt' (length=9)
  2 => string 'tmp1.txt' (length=8)
  4 => string 'tmp2.txt' (length=8)
  0 => string 'tmp15.txt' (length=9)
D:\php20190701\php_code\0809\array_fun3.php:13:boolean true
D:\php20190701\php_code\0809\array_fun3.php:14:
array (size=5)
  2 => string 'tmp1.txt' (length=8)
  4 => string 'tmp2.txt' (length=8)
  1 => string 'TMP10.txt' (length=9)
  0 => string 'tmp15.txt' (length=9)
  3 => string 'TMP22.txt' (length=9)

`array_multisort($arr[,$arg=SORT_STRING...])`:对多个数组或多维数组进行排序

先按第一个数组排序, 然后再第一个数组排序的基础上, 对第二个数组排序, 适用于多个条件

$array[] = array("age"=>20,"name"=>"li");
$array[] = array("age"=>21,"name"=>"ai");
$array[] = array("age"=>20,"name"=>"ci");
$array[] = 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);
var_dump($array);

D:\php20190701\php_code\0809\array_fun3.php:27:
array (size=4)
  0 => 
    array (size=2)
      'age' => int 22
      'name' => string 'di' (length=2)
  1 => 
    array (size=2)
      'age' => int 21
      'name' => string 'ai' (length=2)
  2 => 
    array (size=2)
      'age' => int 20
      'name' => string 'ci' (length=2)
  3 => 
    array (size=2)
      'age' => int 20
      'name' => string 'li' (length=2)

数组的交集与差集

`array_diff($array1,$array2[...])`:计算数组的差集

所谓差集, 就是元素在array1中, 但是不在array2中, 多个同理...

<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");

$result=array_diff($a1,$a2);
var_dump($result);

D:\php20190701\php_code\0809\array_fun3.php:6:
array (size=1)
  'd' => string 'yellow' (length=6)

利用差集, 可以比较两个数组是否相同

if( !array_diff($arr1, $arr2) && !array_diff($arr2, $arr1)){
    // 即相互都不存在差集，那么这两个数组就是相同的了，多数组也一样的道理
    echo '两个数组相同';
}

`array_diff_assoc($array1,$array2[,...])`:带索引检查计算数组的差集

和上面函数不同的是, 这个不仅比较键值, 还比较键名, 只有两个都一样, 才算是同时存在

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
var_dump($result);

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=3)
  'b' => string 'brown' (length=5)
  'c' => string 'blue' (length=4)
  0 => string 'red' (length=3)

`array_intersect($array1,$array2[...])`:计算数组的交集

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
var_dump($result);

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=2)
  'a' => string 'green' (length=5)
  0 => string 'red' (length=3)

`array_intersect_assoc($array1,$array2[...])`:带索引检查计算数组的交集

和上面函数不同的是, 这个不仅比较键值, 还比较键名, 只有两个都一样, 才算是同时存在

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_intersect_assoc($array1, $array2);
var_dump($result);

D:\php20190701\php_code\0809\array_fun3.php:5:
array (size=1)
  'a' => string 'green' (length=5)

数组的拆分与合并

`array_slice($array,$offset[$length=null[,$preserve_keys=false]])`:截取数组

第一个参数, 目标数组
第二个参数, 开始下标
第三个参数, 截取长度, 负数表示截取到倒数第几个
第四个参数, 对于索引数组, 是否保留原来的索引, 默认false不保留, true保留

<?php
$arr = [
	'one'=>'a', 
	'two'=>'b', 
	'three'=>'c', 
	'four'=>'d', 
	'five'=>'e'
];
var_dump(array_slice($arr,2));

D:\php20190701\php_code\0809\array_fun3.php:9:
array (size=3)
  'three' => string 'c' (length=1)
  'four' => string 'd' (length=1)
  'five' => string 'e' (length=1)

`array_splice($array,$offset[,$length=0,$replacement]])`:将数组中一部分去掉并用其它值替代

第一个参数, 目标数组
第二个参数, 开始的截取位置/下标
第三个参数, 截取长度, 负数表示, 截取到倒数第几个
第四个参数, 截取位置要填充的数组, 键名不会保留

<?php
$arr1=[
	"a"=>"red",
	"b"=>"green",
	"c"=>"blue",
	"d"=>"yellow"
];
$arr2=[
	"a"=>"purple",
	"b"=>"orange"
];
array_splice($arr1,0,2,$arr2);
var_dump($arr1);

D:\php20190701\php_code\0809\array_fun3.php:13:
array (size=4)
  0 => string 'purple' (length=6)
  1 => string 'orange' (length=6)
  'c' => string 'blue' (length=4)
  'd' => string 'yellow' (length=6)

`array_merge($arr1[,$arr2...])`:合并数组

<?php


$arr1 = ['first'=>1,'second'=>2,'third'=>3];
$arr2 = ['first'=>4,'second'=>5,'third'=>6];
$arr3 = [3=>'hello',4=>'world'];

var_dump(array_merge($arr1,$arr2)); // 后面的会覆盖前面的
var_dump($arr1+$arr2); // 前面的会覆盖后面的
var_dump(array_merge($arr3)); // 如果只有一个数组, 并且是数字下标, 下标会重新索引

D:\php20190701\php_code\0809\array_fun3.php:8:
array (size=3)
  'first' => int 4
  'second' => int 5
  'third' => int 6
D:\php20190701\php_code\0809\array_fun3.php:9:
array (size=3)
  'first' => int 1
  'second' => int 2
  'third' => int 3
D:\php20190701\php_code\0809\array_fun3.php:10:
array (size=2)
  0 => string 'hello' (length=5)
  1 => string 'world' (length=5)

`array_chunk($array,$size[,$preserve_keys=false])`:将一个数组分割成多个

第一个参数: 目标数组
第二个参数: 拆分的数组, 每个数组有多少个元素
第三个参数: 是否保留关联数组的键名, true保留, false不保留,默认false

<?php
$arr = array('a', 'b', 'c', 'd', 'e');
var_dump(array_chunk($arr, 2));

D:\php20190701\php_code\0809\array_fun3.php:3:
array (size=3)
  0 => 
    array (size=2)
      0 => string 'a' (length=1)
      1 => string 'b' (length=1)
  1 => 
    array (size=2)
      0 => string 'c' (length=1)
      1 => string 'd' (length=1)
  2 => 
    array (size=1)
      0 => string 'e' (length=1)

<?php
$arr = [
	'one'=>'a', 
	'two'=>'b', 
	'three'=>'c', 
];
var_dump(array_chunk($arr, 2, true));
var_dump(array_chunk($arr, 2, false));

D:\php20190701\php_code\0809\array_fun3.php:7:
array (size=2)
  0 => 
    array (size=2)
      'one' => string 'a' (length=1)
      'two' => string 'b' (length=1)
  1 => 
    array (size=1)
      'three' => string 'c' (length=1)
D:\php20190701\php_code\0809\array_fun3.php:8:
array (size=2)
  0 => 
    array (size=2)
      0 => string 'a' (length=1)
      1 => string 'b' (length=1)
  1 => 
    array (size=1)
      0 => string 'c' (length=1)

`array_column($array,$column_key[,$index_key])`:返回数组中指定的一列, 从多维数组中返回单列数组

第一个参数: 多维数组
第二个参数: 返回的键值
第三个参数: 返回的键名, 不写的话, 返回索引数组

<?php
$records = [
	[
		'id' => 2135,
		'first_name' => 'John',
		'last_name' => 'Doe',
	], [
		'id' => 3245,
		'first_name' => 'Sally',
		'last_name' => 'Smith',
	], [
		'id' => 5342,
		'first_name' => 'Jane',
		'last_name' => 'Jones',
	], [
		'id' => 5623,
		'first_name' => 'Peter',
		'last_name' => 'Doe',
	]
];

$first_names = array_column($records, 'first_name');
var_dump($first_names);

D:\php20190701\php_code\0809\array_fun3.php:23:
array (size=4)
  0 => string 'John' (length=4)
  1 => string 'Sally' (length=5)
  2 => string 'Jane' (length=4)
  3 => string 'Peter' (length=5)

<?php
$records = [
	[
		'id' => 2135,
		'first_name' => 'John',
		'last_name' => 'Doe',
	], [
		'id' => 3245,
		'first_name' => 'Sally',
		'last_name' => 'Smith',
	], [
		'id' => 5342,
		'first_name' => 'Jane',
		'last_name' => 'Jones',
	], [
		'id' => 5623,
		'first_name' => 'Peter',
		'last_name' => 'Doe',
	]
];

$first_names = array_column($records, 'first_name','id');
var_dump($first_names);

D:\php20190701\php_code\0809\array_fun3.php:23:
array (size=4)
  2135 => string 'John' (length=4)
  3245 => string 'Sally' (length=5)
  5342 => string 'Jane' (length=4)
  5623 => string 'Peter' (length=5)

[PHP从小白到大牛]-018 PHP数组函数

数组函数库

创建数组操作

range($min,$max[$step=1]):快速创建下标连续的索引数组

compact($varname,$varname....):快速创建关联数组

array_fill($start_index,$num,$value):用给定的值填充数组

array_fill_keys($keys,$value):使用指定的键和值填充数组

array_combine($keys,$values):创建一个数组，用一个数组的值作为其键名, 另一个数组的值, 作为键值

键值相关操作

count($var[,$mode=COUNT_NORMAL])/sizeof():计算数组中的元素数量

array_keys($array):取得数组的键名作为下标连续的索引数组返回

array_values($array):取得数组的键值作为下标连续的索引数组返回

array_flip($array):交换数组中的键名和键值

in_array($search,$array[,$strict]):检测数组中是否存在某个值

array_search($search,$array[,$strict]):在数组中搜索给定的值

array_key_exists($search,$array):检查给定的键名或索引是否存在于数组中

array_reverse($array[,$preserve_keys=false]):数组倒置

shuffle($array):打乱数组的元素

array_unique($array[,$sort_flag=SORT_STRING]):移除数组中重复的值

array_rand($array[,$num_req=1]):随机取出数组的键名

array_sum($array):统计数组中元素值的总和

array_product($array):计算数组中所有值的乘积

array_count_values($array):统计数组中值出现的次数

extract($array[,$extract_type=EXTR_OVERWRITE[,$prefix=null]]):数组转变量

array_pad($array,$size,$value):用值将数组填补到指定长度

数组指针函数

key($array):得到当前指针所在位置元素的键名

current($array)|pos($array):得到当前指针所在位置元素的键值

next($array):将数组指针向下移动一位，并且返回当前指针所在位置元素的键值

prev($array):将数组指针向上移动一位，并且返回当前指针所在位置元素的键值

end($array):将数组指针移动倒数组的末尾，并且返回当前指针所在位置元素的键值

reset($array):将数组指针移动到数组的开始，并且返回当前指针所在位置元素的键值

each($array):返回数组中当前的键值对，并将数组指针向下移动一位

list($var,...):将数组中元素的值赋给对应的变量

array_unshift($array,$value...):在数组开头插入一个元素或者多个元素

array_shift($array):弹出数组的第一个元素

array_push($array,$value...):在数组末尾压入一个元素或者多个元素

array_pop($array):弹出数组的最后一个元素

数组排序函数

sort($array[,$sort_flag=SORT_REGULAR]):对数组的键值按照升序排列，不保留键名

rsort($array[,$sort_flag=SORT_REGULAR]):对数组键值按照降序排列，不保留键名

asort($array[,$sort_flag=SORT_REGULAR]):对数组键值按照升序排列，保留键值对关系

arsort($array[,$sort_flag=SORT_REGULAR]):对数组键值按照降序排列，保留键值对关系

ksort($array[,$sort_flag=SORT_REGULAR]):对数组的键名按照升序排列

krsort($array[,$sort_flag=SORT_REGULAR]):对数组的键名按照降序排列

natsort($array):用自然排序法排序

natcasesort($array):用自然排序算法对数组进行不区分大小写字母的排序

array_multisort($arr[,$arg=SORT_STRING...]):对多个数组或多维数组进行排序

数组的交集与差集

array_diff($array1,$array2[...]):计算数组的差集

array_diff_assoc($array1,$array2[,...]):带索引检查计算数组的差集

array_intersect($array1,$array2[...]):计算数组的交集

array_intersect_assoc($array1,$array2[...]):带索引检查计算数组的交集

数组的拆分与合并

array_slice($array,$offset[$length=null[,$preserve_keys=false]]):截取数组

array_splice($array,$offset[,$length=0,$replacement]]):将数组中一部分去掉并用其它值替代

array_merge($arr1[,$arr2...]):合并数组

array_chunk($array,$size[,$preserve_keys=false]):将一个数组分割成多个

array_column($array,$column_key[,$index_key]):返回数组中指定的一列, 从多维数组中返回单列数组

`range($min,$max[$step=1])`:快速创建下标连续的索引数组

`compact($varname,$varname....)`:快速创建关联数组

`array_fill($start_index,$num,$value)`:用给定的值填充数组

`array_fill_keys($keys,$value)`:使用指定的键和值填充数组

`array_combine($keys,$values)`:创建一个数组，用一个数组的值作为其键名, 另一个数组的值, 作为键值

`count($var[,$mode=COUNT_NORMAL])/sizeof()`:计算数组中的元素数量

`array_keys($array)`:取得数组的键名作为`下标连续的索引数组`返回

`array_values($array)`:取得数组的键值作为下标连续的索引数组返回

`array_flip($array)`:交换数组中的键名和键值

`in_array($search,$array[,$strict])`:检测数组中是否存在某个值

`array_search($search,$array[,$strict])`:在数组中搜索给定的值

`array_key_exists($search,$array)`:检查给定的键名或索引是否存在于数组中

`array_reverse($array[,$preserve_keys=false])`:数组倒置

`shuffle($array)`:打乱数组的元素

`array_unique($array[,$sort_flag=SORT_STRING])`:移除数组中重复的值

`array_rand($array[,$num_req=1])`:随机取出数组的键名

`array_sum($array)`:统计数组中元素值的总和

`array_product($array)`:计算数组中所有值的乘积

`array_count_values($array)`:统计数组中值出现的次数

`extract($array[,$extract_type=EXTR_OVERWRITE[,$prefix=null]])`:数组转变量

`array_pad($array,$size,$value)`:用值将数组填补到指定长度

`key($array)`:得到当前指针所在位置元素的键名

`current($array)|pos($array)`:得到当前指针所在位置元素的键值

`next($array)`:将数组指针向下移动一位，并且返回当前指针所在位置元素的键值

`prev($array)`:将数组指针向上移动一位，并且返回当前指针所在位置元素的键值

`end($array)`:将数组指针移动倒数组的末尾，并且返回当前指针所在位置元素的键值

`reset($array)`:将数组指针移动到数组的开始，并且返回当前指针所在位置元素的键值

`each($array)`:返回数组中当前的键值对，并将数组指针向下移动一位

`list($var,...)`:将数组中元素的值赋给对应的变量

`array_unshift($array,$value...)`:在数组开头插入一个元素或者多个元素

`array_shift($array)`:弹出数组的第一个元素

`array_push($array,$value...)`:在数组末尾压入一个元素或者多个元素

`array_pop($array)`:弹出数组的最后一个元素

`sort($array[,$sort_flag=SORT_REGULAR])`:对数组的键值按照升序排列，不保留键名

`rsort($array[,$sort_flag=SORT_REGULAR])`:对数组键值按照降序排列，不保留键名

`asort($array[,$sort_flag=SORT_REGULAR])`:对数组键值按照升序排列，保留键值对关系

`arsort($array[,$sort_flag=SORT_REGULAR])`:对数组键值按照降序排列，保留键值对关系

`ksort($array[,$sort_flag=SORT_REGULAR])`:对数组的键名按照升序排列

`krsort($array[,$sort_flag=SORT_REGULAR])`:对数组的键名按照降序排列

`natsort($array)`:用自然排序法排序

`natcasesort($array)`:用自然排序算法对数组进行不区分大小写字母的排序

`array_multisort($arr[,$arg=SORT_STRING...])`:对多个数组或多维数组进行排序

`array_diff($array1,$array2[...])`:计算数组的差集

`array_diff_assoc($array1,$array2[,...])`:带索引检查计算数组的差集

`array_intersect($array1,$array2[...])`:计算数组的交集

`array_intersect_assoc($array1,$array2[...])`:带索引检查计算数组的交集

`array_slice($array,$offset[$length=null[,$preserve_keys=false]])`:截取数组

`array_splice($array,$offset[,$length=0,$replacement]])`:将数组中一部分去掉并用其它值替代

`array_merge($arr1[,$arr2...])`:合并数组

`array_chunk($array,$size[,$preserve_keys=false])`:将一个数组分割成多个

`array_column($array,$column_key[,$index_key])`:返回数组中指定的一列, 从多维数组中返回单列数组