• 【风马一族_php】数组函数

    原文来自：http://www.cnblogs.com/sows/p/6045699.html （博客园的）风马一族 侵犯版本，后果自负  2016-11-09 15:56:26

    数组 函数

    　　php--数组的尝鲜事例

    　　　　　语法：array_change_key_case(数组名);　　　

    •    　php-->修改数组的键名（下标）的字母大小写

    　　array_chunk — 将一个数组分割成多个

    　　　　　语法：array_chunk(数组名,设置数组的长度);　　　

    　　　　　php--将数组划分成若干个数组

    　　　　　　待定

    • array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
      • php--数组的元素充当另个数组的键名
    • array_count_values — 统计数组中所有的值出现的次数
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(23,324,32,45,645,6,56,23,5,5,56,54,65,7,5,45,63,45,34
 9     );
10     
11     //统计数组中各个元素的出现数量
12     var_dump(array_count_values($arr));
13 ?>
14 
15 结果：
16 array(13) {
17   [23]=>
18   int(2)
19   [324]=>
20   int(1)
21   [32]=>
22   int(1)
23   [45]=>
24   int(3)
25   [645]=>
26   int(1)
27   [6]=>
28   int(1)
29   [56]=>
30   int(2)
31   [5]=>
32   int(3)
33   [54]=>
34   int(1)
35   [65]=>
36   int(1)
37   [7]=>
38   int(1)
39   [63]=>
40   int(1)
41   [34]=>
42   int(1)
43 }
        php--统计各个元素在数组中出现的次数
    • array_diff_assoc — 带索引检查计算数组的差集
      • php--两个数组相减
    • array_diff_key — 使用键名比较计算数组的差集
      • php--通过数组的下标进行减法运算，计算出不同下标或不同值
    • array_diff_uassoc — 用用户提供的回调函数做索引检查来计算数组的差集
      • php--使用回调函数来处理两个数组的减法
    • array_diff_ukey — 用回调函数对键名比较计算数组的差集
      • php--使用回调函数，两个函数间不同的下标
    • array_diff — 计算数组的差集
      • php--两个数组是减法运算
    • array_fill_keys — 使用指定的键和值填充数组
      • php--关系一对多，数组的每个元素，对应另个数组的所有元素
    • array_fill — 用给定的值填充数组
      • 语法  array_fill(索引的位置起始，数量，元素的值)　　
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr1 = array(111,222,333);
 9     $arr2 = array(111,222,333);
10 
11     var_dump(array_fill(0,2,'a'));
12 ?>
13 
14 结果：
15 array(2) {
16   [0]=>
17   string(1) "a"
18   [1]=>
19   string(1) "a"
20 }
        php--给数组提供若干个相同的元素
    • array_filter — 用回调函数过滤数组中的单元
      • 语法：array_filter(数组名, 回调函数)　　
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(
 9         254235,34,534,654,75,8,9,677,423,5,7,6435,43543,4,5,7,65,765,3
10     );
11 
12     var_dump(array_filter($arr,'odd'));
13 
14     function odd($var){
15         return($var & 0);
16     }
17 ?>
18 
19 结果：
20 //return($var & 0);
21 array(0) {       
22 
23 }
24 
25 
26 //return($var & 1);
27 array(14) {
28   [0]=>
29   int(254235)
30   [4]=>
31   int(75)
32   [6]=>
33   int(9)
34   [7]=>
35   int(677)
36   [8]=>
37   int(423)
38   [9]=>
39   int(5)
40   [10]=>
41   int(7)
42   [11]=>
43   int(6435)
44   [12]=>
45   int(43543)
46   [14]=>
47   int(5)
48   [15]=>
49   int(7)
50   [16]=>
51   int(65)
52   [17]=>
53   int(765)
54   [18]=>
55   int(3)
56 }
57 
58 //return($var & 2);
59 array(11) {
60   [0]=>
61   int(254235)
62   [1]=>
63   int(34)
64   [2]=>
65   int(534)
66   [3]=>
67   int(654)
68   [4]=>
69   int(75)
70   [8]=>
71   int(423)
72   [10]=>
73   int(7)
74   [11]=>
75   int(6435)
76   [12]=>
77   int(43543)
78   [15]=>
79   int(7)
80   [18]=>
81   int(3)
82 }
        php--过滤数组中的某些元素
    • array_flip — 交换数组中的键和值
      • 语法：array_flip(数组名);　　
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(
 9         'name'=>'sows',
10         'sex'=>'mm',
11         'age'=>'23'
12     );
13 
14     var_dump(array_flip($arr));
15 ?>
16 
17 结果：
18 array(3) {
19   ["sows"]=>
20   string(4) "name"
21   ["mm"]=>
22   string(3) "sex"
23   [23]=>
24   string(3) "age"
25 }
        php--数组中的键名与元素进行位置调换
    • array_intersect_assoc — 带索引检查计算数组的交集
      • 语法：array_intersect_assoc(数组1,数组2,数组3.......);　　
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr1 = array(
 9         'name'=>'sows','age'=>'23','sex'=>'mm'
10     );
11 
12     $arr2 = array(
13         'age'=>'23','sex'=>'mm','name'=>'sows'
14     );
15 
16     var_dump(array_intersect_assoc($arr1,$arr2));
17 
18 ?>
19 
20 结果：
21 array(3) {
22   ["name"]=>
23   string(4) "sows"
24   ["age"]=>
25   string(2) "23"
26   ["sex"]=>
27   string(2) "mm"
28 }
29 
30 =============================
31 <?php
32     //设置文件的编码为 utf-8,以便识别中文
33     header('Content-type:text/html;charset=utf-8');  
34 
35     //让结果，按原先的格式输出
36     echo '<pre>';
37 
38     $arr1 = array(
39         'name'=>'sows','age'=>'23','sex'=>'mm'
40     );
41 
42     $arr2 = array(
43         'a1ge'=>'23','sex'=>'m1m','name'=>'sows'
44     );
45 
46     $arr3 = array(
47         'age'=>'23','sex'=>'mm','name'=>'sows'
48     );
49 
50 
51     var_dump(array_intersect_assoc($arr1,$arr2,$arr3));
52 
53 ?>
54 
55 
56 结果：
57 array(1) {
58   ["name"]=>
59   string(4) "sows"
60 }
        php--根据索引，对多个数组进行判断，寻找相同的索引的相同元素
    • array_intersect_key — 使用键名比较计算数组的交集
      • 语法：array_intersect_key(数组1，数组2，数组3.。。。。。。。。);
      • 说明：获取所有数组中，相同的键名，然后键名对应的元素，由第一个数组的元素来提供，元素排序由第一数组决定
      •  1 <?php
 2 
 3     //设置文件的编码为 utf-8,以便识别中文
 4     header('Content-type:text/html;charset=utf-8');  
 5 
 6     //让结果，按原先的格式输出
 7     echo '<pre>';
 8 
 9     $arr1 = array(
10         'name'=>'苏俄',
11         'age'=>'34',
12         'sex'=>'mm'
13     );
14 
15     $arr2 = array(
16         'name'=>'苏俄',
17         'age'=>'342',
18         'sex'=>'mm'
19     );
20 
21     $arr3 = array(
22         'name'=>'苏俄','sex'=>'mm',
23         'age'=>'342'
24         
25     );
26     
27     var_dump(array_intersect_key($arr1,$arr2));
28     var_dump(array_intersect_key($arr2,$arr1));
29     var_dump(array_intersect_key($arr3,$arr1,$arr2));
30     var_dump(array_intersect_key($arr3,$arr2,$arr1));
31 
32 ?>
33 
34 结果：
35 array(3) {
36   ["name"]=>
37   string(6) "苏俄"
38   ["age"]=>
39   string(2) "34"
40   ["sex"]=>
41   string(2) "mm"
42 }
43 array(3) {
44   ["name"]=>
45   string(6) "苏俄"
46   ["age"]=>
47   string(3) "342"
48   ["sex"]=>
49   string(2) "mm"
50 }
51 array(3) {
52   ["name"]=>
53   string(6) "苏俄"
54   ["sex"]=>
55   string(2) "mm"
56   ["age"]=>
57   string(3) "342"
58 }
59 array(3) {
60   ["name"]=>
61   string(6) "苏俄"
62   ["sex"]=>
63   string(2) "mm"
64   ["age"]=>
65   string(3) "342"
66 }
        php-求数组间的交集
    • array_intersect_uassoc — 带索引检查计算数组的交集，用回调函数比较索引
      • 语法：array_intersect_uassoc(数组一，数组二。。。。。，回调函数)　　
      • 说明：求多个数组间的交集，并使用回调函数（自定义）
      •  1 <?php
 2     
 3     //设置文件的编码为 utf-8,以便识别中文
 4     header('Content-type:text/html;charset=utf-8');  
 5 
 6     //让结果，按原先的格式输出
 7     echo '<pre>';
 8 
 9     $arr1 = array(
10         'name'=>'sows',
11         'age'=>'25',
12         'sex'=>'mm'
13     );
14 
15     $arr2 = array(
16         'name'=>'sows',
17         'age'=>'25',
18         'sex'=>'mm'
19     );
20 
21     $arr3 = array(
22             'name'=>'sows',
23             'age'=>'215',
24             'sex'=>'mm'
25         );
26 
27 
28 
29     var_dump(array_intersect_uassoc($arr1,$arr2,'fun'));
30     
31     var_dump(array_intersect_uassoc($arr1,$arr2,$arr3,'fun'));
32 
33     function fun($a,$b){
34         if($a > $b){
35             return 1;    
36         }elseif($a <$b){
37             return     -1;
38         }else{
39             return 0;
40         }
41     }
42 
43 
44 ?>
45 
46 结果：
47 //array_intersect_uassoc($arr1,$arr2,'fun')
48 array(3) {
49   ["name"]=>
50   string(4) "sows"
51   ["age"]=>
52   string(2) "25"
53   ["sex"]=>
54   string(2) "mm"
55 }
56 
57 //array_intersect_uassoc($arr1,$arr2,$arr3,'fun')
58 array(2) {
59   ["name"]=>
60   string(4) "sows"
61   ["sex"]=>
62   string(2) "mm"
63 }
        php--使用回调函数，获取数组间的交集
    • array_intersect_ukey — 用回调函数比较键名来计算数组的交集
      • 语法：array_intersect_ukey(数组1，数组2，数组3.。。。。，回调函数)　
      • 说明：使用回调函数，获取所有数组中，相同的键名，然后键名对应的元素，由第一个数组的元素来提供，元素排序由第一数组决定
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr1 = array(
 9         'name'=>'楼主',
10         'age'=>'15',
11         'sex'=>'GG'
12     );
13 
14     $arr2 = array(
15         'name'=>'楼主',
16         'sex'=>'GGM',
17         'age'=>'15'
18         
19     );
20 
21     var_dump(array_intersect_ukey($arr2,$arr1,'fun'));
22 
23     function fun($a,$b){
24         if($a > $b){
25             return 1;    
26         }elseif($a <$b){
27             return     -1;
28         }else{
29             return 0;
30         }
31     }
32 ?>
33 
34 结果：array(3) {
35   ["name"]=>
36   string(6) "楼主"
37   ["sex"]=>
38   string(3) "GGM"
39   ["age"]=>
40   string(2) "15"
41 }
        php--使用回调函数，根据数组间的键名比较，获取相同键名的元素，元素的值由第一个数组决定
    • array_intersect — 计算数组的交集
      • 语法：array_intersect(数组1，数组2，数组3.。。。。);
      • 说明：从多个数组中，获取相同的元素
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr1 = array(1,2,3,4,5,6);
 9     $arr2 = array(1,2,31,4,51,6);
10     
11     var_dump(array_intersect($arr1,$arr1));
12     var_dump(array_intersect($arr1,$arr2));
13     var_dump(array_intersect($arr2,$arr1));
14 
15 ?>
16 
17 结果：
18 array(6) {
19   [0]=>
20   int(1)
21   [1]=>
22   int(2)
23   [2]=>
24   int(3)
25   [3]=>
26   int(4)
27   [4]=>
28   int(5)
29   [5]=>
30   int(6)
31 }
32 array(4) {
33   [0]=>
34   int(1)
35   [1]=>
36   int(2)
37   [3]=>
38   int(4)
39   [5]=>
40   int(6)
41 }
42 array(4) {
43   [0]=>
44   int(1)
45   [1]=>
46   int(2)
47   [3]=>
48   int(4)
49   [5]=>
50   int(6)
51 }
        php--获取多个数组间的相同元素
    • array_key_exists — 检查给定的键名或索引是否存在于数组中
      • 语法：array_key_exists(键名,数组名);
      • 说明：在数组中搜索键名, 若存在返回true;若不存在返回false
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr1 = array(
 9         'name'=>'sows',
10         'age'=>15,
11         'sex'=>'mm'
12     );
13 
14     var_dump(array_key_exists('name',$arr1));
15     var_dump(array_key_exists('sex1',$arr1));
16 
17 ?>
18 
19 结果：
20 bool(true)
21 bool(false)
        php--在数组中搜索键名
    • array_keys — 返回数组中部分的或所有的键名
      • 语法：array_keys(数组)     array_keys(数组，元素);
      • 说明：获取数组的键名
      • php--输出数组的所有键名或部分键名
      • 　　
    • array_map — 将回调函数作用到给定数组的单元上
      • 语法：array_map(回调函数，数组);　　
      • 说明：使用回调函数，对数组中的每个元素进行处理
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(
 9         'name'=>'楼主',
10         'age'=>'15',
11         'sex'=>'GG'
12     );
13 
14     var_dump(array_map('fun',$arr));
15 
16     function fun($a){
17         return $a.=' 你好';
18     }
19 ?>
20 
21 结果：
22 array(3) {
23   ["name"]=>
24   string(13) "楼主 你好"
25   ["age"]=>
26   string(9) "15 你好"
27   ["sex"]=>
28   string(9) "GG 你好"
29 }
        php--回调函数对数组的所有元素进行处理
    • array_merge_recursive — 递归地合并一个或多个数组   （ 与array_merge 的效果，有问题）
      • 语法：array_merge_recursive(数组一，数组二，数组三。。。。。。。);
      • 说明：多个数组间的头尾相连，形成大的数组
      •   1 <?php
  2     //设置文件的编码为 utf-8,以便识别中文
  3     header('Content-type:text/html;charset=utf-8');  
  4 
  5     //让结果，按原先的格式输出
  6     echo '<pre>';
  7     
  8     $arr1 = array(1,2,3,4,5,6,7,8,9,0);
  9     $arr2 = array('a','b','c','d','e','f','g','h','j','n');
 10     $arr3 = array('A','B','C','D','E','F','G','H','J','N');
 11 
 12     var_dump(array_merge_recursive($arr1,$arr2));
 13     
 14     var_dump(array_merge_recursive($arr2,$arr1));
 15     
 16     var_dump(array_merge_recursive($arr1,$arr2,$arr3));
 17     
 18 ?>
 19 
 20 结果：
 21 //array_merge_recursive($arr1,$arr2)
 22 array(20) {
 23   [0]=>
 24   int(1)
 25   [1]=>
 26   int(2)
 27   [2]=>
 28   int(3)
 29   [3]=>
 30   int(4)
 31   [4]=>
 32   int(5)
 33   [5]=>
 34   int(6)
 35   [6]=>
 36   int(7)
 37   [7]=>
 38   int(8)
 39   [8]=>
 40   int(9)
 41   [9]=>
 42   int(0)
 43   [10]=>
 44   string(1) "a"
 45   [11]=>
 46   string(1) "b"
 47   [12]=>
 48   string(1) "c"
 49   [13]=>
 50   string(1) "d"
 51   [14]=>
 52   string(1) "e"
 53   [15]=>
 54   string(1) "f"
 55   [16]=>
 56   string(1) "g"
 57   [17]=>
 58   string(1) "h"
 59   [18]=>
 60   string(1) "j"
 61   [19]=>
 62   string(1) "n"
 63 }
 64 
 65 //array_merge_recursive($arr2,$arr1)
 66 array(20) {
 67   [0]=>
 68   string(1) "a"
 69   [1]=>
 70   string(1) "b"
 71   [2]=>
 72   string(1) "c"
 73   [3]=>
 74   string(1) "d"
 75   [4]=>
 76   string(1) "e"
 77   [5]=>
 78   string(1) "f"
 79   [6]=>
 80   string(1) "g"
 81   [7]=>
 82   string(1) "h"
 83   [8]=>
 84   string(1) "j"
 85   [9]=>
 86   string(1) "n"
 87   [10]=>
 88   int(1)
 89   [11]=>
 90   int(2)
 91   [12]=>
 92   int(3)
 93   [13]=>
 94   int(4)
 95   [14]=>
 96   int(5)
 97   [15]=>
 98   int(6)
 99   [16]=>
100   int(7)
101   [17]=>
102   int(8)
103   [18]=>
104   int(9)
105   [19]=>
106   int(0)
107 }
108 
109 //array_merge_recursive($arr1,$arr2,$arr3))
110 array(30) {
111   [0]=>
112   int(1)
113   [1]=>
114   int(2)
115   [2]=>
116   int(3)
117   [3]=>
118   int(4)
119   [4]=>
120   int(5)
121   [5]=>
122   int(6)
123   [6]=>
124   int(7)
125   [7]=>
126   int(8)
127   [8]=>
128   int(9)
129   [9]=>
130   int(0)
131   [10]=>
132   string(1) "a"
133   [11]=>
134   string(1) "b"
135   [12]=>
136   string(1) "c"
137   [13]=>
138   string(1) "d"
139   [14]=>
140   string(1) "e"
141   [15]=>
142   string(1) "f"
143   [16]=>
144   string(1) "g"
145   [17]=>
146   string(1) "h"
147   [18]=>
148   string(1) "j"
149   [19]=>
150   string(1) "n"
151   [20]=>
152   string(1) "A"
153   [21]=>
154   string(1) "B"
155   [22]=>
156   string(1) "C"
157   [23]=>
158   string(1) "D"
159   [24]=>
160   string(1) "E"
161   [25]=>
162   string(1) "F"
163   [26]=>
164   string(1) "G"
165   [27]=>
166   string(1) "H"
167   [28]=>
168   string(1) "J"
169   [29]=>
170   string(1) "N"
171 }
        php--多个数组间相连成大的数组
    • array_merge — 合并一个或多个数组
      • 语法：array_merge(数组1，数组2，数组3.。。。。。。。)；
      • 说明:
      •   1 <?php
  2     //设置文件的编码为 utf-8,以便识别中文
  3     header('Content-type:text/html;charset=utf-8');  
  4 
  5     //让结果，按原先的格式输出
  6     echo '<pre>';
  7     
  8     $arr1 = array(1,2,3,4,5,6,7,8,9,0);
  9     $arr2 = array('a','b','c','d','e','f','g','h','j','n');
 10     $arr3 = array('A','B','C','D','E','F','G','H','J','N');
 11 
 12     var_dump(array_merge($arr1,$arr2));
 13     var_dump(array_merge($arr2,$arr1));
 14     var_dump(array_merge($arr1,$arr2,$arr3));
 15 
 16 
 17     $arr4 = array('name1'=>1,'name2'=>2,'name3'=>3,'name4'=>4);
 18     $arr5 = array('name1'=>1,'name2'=>2,'name3'=>3,'name4'=>4);
 19     
 20     var_dump(array_merge_recursive($arr4,$arr5));
 21 ?>
 22 
 23 结果：
 24 array(20) {
 25   [0]=>
 26   int(1)
 27   [1]=>
 28   int(2)
 29   [2]=>
 30   int(3)
 31   [3]=>
 32   int(4)
 33   [4]=>
 34   int(5)
 35   [5]=>
 36   int(6)
 37   [6]=>
 38   int(7)
 39   [7]=>
 40   int(8)
 41   [8]=>
 42   int(9)
 43   [9]=>
 44   int(0)
 45   [10]=>
 46   string(1) "a"
 47   [11]=>
 48   string(1) "b"
 49   [12]=>
 50   string(1) "c"
 51   [13]=>
 52   string(1) "d"
 53   [14]=>
 54   string(1) "e"
 55   [15]=>
 56   string(1) "f"
 57   [16]=>
 58   string(1) "g"
 59   [17]=>
 60   string(1) "h"
 61   [18]=>
 62   string(1) "j"
 63   [19]=>
 64   string(1) "n"
 65 }
 66 array(20) {
 67   [0]=>
 68   string(1) "a"
 69   [1]=>
 70   string(1) "b"
 71   [2]=>
 72   string(1) "c"
 73   [3]=>
 74   string(1) "d"
 75   [4]=>
 76   string(1) "e"
 77   [5]=>
 78   string(1) "f"
 79   [6]=>
 80   string(1) "g"
 81   [7]=>
 82   string(1) "h"
 83   [8]=>
 84   string(1) "j"
 85   [9]=>
 86   string(1) "n"
 87   [10]=>
 88   int(1)
 89   [11]=>
 90   int(2)
 91   [12]=>
 92   int(3)
 93   [13]=>
 94   int(4)
 95   [14]=>
 96   int(5)
 97   [15]=>
 98   int(6)
 99   [16]=>
100   int(7)
101   [17]=>
102   int(8)
103   [18]=>
104   int(9)
105   [19]=>
106   int(0)
107 }
108 array(30) {
109   [0]=>
110   int(1)
111   [1]=>
112   int(2)
113   [2]=>
114   int(3)
115   [3]=>
116   int(4)
117   [4]=>
118   int(5)
119   [5]=>
120   int(6)
121   [6]=>
122   int(7)
123   [7]=>
124   int(8)
125   [8]=>
126   int(9)
127   [9]=>
128   int(0)
129   [10]=>
130   string(1) "a"
131   [11]=>
132   string(1) "b"
133   [12]=>
134   string(1) "c"
135   [13]=>
136   string(1) "d"
137   [14]=>
138   string(1) "e"
139   [15]=>
140   string(1) "f"
141   [16]=>
142   string(1) "g"
143   [17]=>
144   string(1) "h"
145   [18]=>
146   string(1) "j"
147   [19]=>
148   string(1) "n"
149   [20]=>
150   string(1) "A"
151   [21]=>
152   string(1) "B"
153   [22]=>
154   string(1) "C"
155   [23]=>
156   string(1) "D"
157   [24]=>
158   string(1) "E"
159   [25]=>
160   string(1) "F"
161   [26]=>
162   string(1) "G"
163   [27]=>
164   string(1) "H"
165   [28]=>
166   string(1) "J"
167   [29]=>
168   string(1) "N"
169 }
170 array(4) {
171   ["name1"]=>
172   array(2) {
173     [0]=>
174     int(1)
175     [1]=>
176     int(1)
177   }
178   ["name2"]=>
179   array(2) {
180     [0]=>
181     int(2)
182     [1]=>
183     int(2)
184   }
185   ["name3"]=>
186   array(2) {
187     [0]=>
188     int(3)
189     [1]=>
190     int(3)
191   }
192   ["name4"]=>
193   array(2) {
194     [0]=>
195     int(4)
196     [1]=>
197     int(4)
198   }
199 }
        php--多个数组间的头尾相连

         　　

    • array_multisort — 对多个数组或多维数组进行排序
      • 语法：array_multisort(数组1，数组2，数组3.。。。。。，排序顺序|排序类型)　　
        • 排序顺序标志：
          • SORT_ASC - 按照上升顺序排序（默认值，即不填时，默认使用它）
          • SORT_DESC - 按照下降顺序排序
        • 排序类型标志：
          • SORT_REGULAR - 将项目按照通常方法比较（默认值，即不填时，默认使用它）
          • SORT_NUMERIC - 将项目按照数值比较
          • SORT_STRING - 将项目按照字符串比较
      • 说明：
        • 两种排序方式：用键名进行排序 | 用元素进行排序
        • 数组排序前后的顺序会发生改变
        • 可以同时对多个数组进行排序，排序只针对一个数组内部的元素，即数组间不会相互影响，
      •   1 <?php
  2     //设置文件的编码为 utf-8,以便识别中文
  3     header('Content-type:text/html;charset=utf-8');  
  4 
  5     //让结果，按原先的格式输出
  6     echo '<pre>';
  7 
  8     $arr1 = array(
  9         324,32,5345,6,788,6,78,79,98786,78897
 10     );
 11 
 12     array_multisort($arr1,SORT_STRING);
 13         var_dump($arr1);
 14     array_multisort($arr1,SORT_NUMERIC );
 15     var_dump($arr1);
 16 
 17     $arr2 = array(
 18         'a'=>3324,'d'=>3432,'f'=>435436,'c'=>8723,'g'=>645
 19     );
 20     array_multisort($arr2,SORT_NUMERIC ); //默认式，按元素，从小到大排序
 21     var_dump($arr2);
 22     array_multisort($arr2,SORT_STRING);   //按键名，从小到大排序(默认：SORT_ASC)
 23     var_dump($arr2);
 24     array_multisort($arr2,SORT_NUMERIC ); //按元素，从小到大排序(默认：SORT_ASC)
 25     var_dump($arr2);
 26 
 27     //修改显示的顺序
 28     array_multisort($arr2,SORT_NUMERIC,SORT_ASC); //按元素，从小到大排序
 29     var_dump($arr2);
 30     array_multisort($arr2,SORT_NUMERIC,SORT_DESC); //按元素，从大到小排序
 31     var_dump($arr2);
 32 
 33 ?>
 34 
 35 结果：
 36 array(10) {
 37   [0]=>
 38   int(32)
 39   [1]=>
 40   int(324)
 41   [2]=>
 42   int(5345)
 43   [3]=>
 44   int(6)
 45   [4]=>
 46   int(6)
 47   [5]=>
 48   int(78)
 49   [6]=>
 50   int(788)
 51   [7]=>
 52   int(78897)
 53   [8]=>
 54   int(79)
 55   [9]=>
 56   int(98786)
 57 }
 58 array(10) {
 59   [0]=>
 60   int(6)
 61   [1]=>
 62   int(6)
 63   [2]=>
 64   int(32)
 65   [3]=>
 66   int(78)
 67   [4]=>
 68   int(79)
 69   [5]=>
 70   int(324)
 71   [6]=>
 72   int(788)
 73   [7]=>
 74   int(5345)
 75   [8]=>
 76   int(78897)
 77   [9]=>
 78   int(98786)
 79 }
 80 array(5) {
 81   ["g"]=>
 82   int(645)
 83   ["a"]=>
 84   int(3324)
 85   ["d"]=>
 86   int(3432)
 87   ["c"]=>
 88   int(8723)
 89   ["f"]=>
 90   int(435436)
 91 }
 92 array(5) {
 93   ["a"]=>
 94   int(3324)
 95   ["d"]=>
 96   int(3432)
 97   ["f"]=>
 98   int(435436)
 99   ["g"]=>
100   int(645)
101   ["c"]=>
102   int(8723)
103 }
104 array(5) {
105   ["g"]=>
106   int(645)
107   ["a"]=>
108   int(3324)
109   ["d"]=>
110   int(3432)
111   ["c"]=>
112   int(8723)
113   ["f"]=>
114   int(435436)
115 }
116 array(5) {
117   ["g"]=>
118   int(645)
119   ["a"]=>
120   int(3324)
121   ["d"]=>
122   int(3432)
123   ["c"]=>
124   int(8723)
125   ["f"]=>
126   int(435436)
127 }
128 array(5) {
129   ["f"]=>
130   int(435436)
131   ["c"]=>
132   int(8723)
133   ["d"]=>
134   int(3432)
135   ["a"]=>
136   int(3324)
137   ["g"]=>
138   int(645)
139 }
        php--对数组按某种方式进行排序
    • array_pad — 用值将数组填补到指定长度
      • 语法：array_pad(数组名,设置数组长度，要增添的元素)      
        • 1.设置数组长度不超过数组的原先长度，都才有意义
        • 2.如果对数组会有删除操作，空余的位置，由增添元素处理，或许有意义
      • 说明：给数组增加若干个相同的元素
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(
 9         1,2,5
10     );
11     
12     //设置数组的长度为10，当原先数组的长度不够10时，剩余的位置由2填充
13     print_r(array_pad($arr,10,2));
14 
15     //设置数组的长度为2，当原先数组的长度超过设置的数组长度，则保持不变
16     print_r(array_pad($arr,2,2));
17 
18     //设置数组的长度为10，当原先数组的长度不够5时，剩余的位置由3填充
19     print_r(array_pad($arr,5,3));
20 
21 
22 ?>
23 
24 结果：
25 Array
26 (
27     [0] => 1
28     [1] => 2
29     [2] => 5
30     [3] => 2
31     [4] => 2
32     [5] => 2
33     [6] => 2
34     [7] => 2
35     [8] => 2
36     [9] => 2
37 )
38 Array
39 (
40     [0] => 1
41     [1] => 2
42     [2] => 5
43 )
44 Array
45 (
46     [0] => 1
47     [1] => 2
48     [2] => 5
49     [3] => 3
50     [4] => 3
51 )
        ohp--给数组增添若干个相同的元素
    • array_pop — 将数组最后一个单元弹出（出栈）
      • 语法：array_pop(数组);
      • 说明：栈结构：先进后出，用数组作栈结构，元素的进出都在数组尾巴进行
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(1,2,3,4,5,6,7,8,9,10);
 9 
10     var_dump(array_pop($arr));
11     var_dump(array_pop($arr));
12     print_r(array_pop($arr));
13 
14 ?>
15 
16 结果：
17 10
18 9
19 8
        php--移出数组的最后一个元素

         　　

    • array_product — 计算数组中所有值的乘积
      • 语法：array_product(数组);
      • 说明：对纯数字的数组进行相乘，用字符串表示的数字也可以接受
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     //对数组的数字进行相乘
 9     $arr = array(1,2,3,4,5,6,7,8,9); 
10     var_dump(array_product($arr));
11     
12     //用字符串表示的数字，同样可以参与运算
13     $arr = array(1,2,3,4,5,6,7,8,9,'323');
14     var_dump(array_product($arr));
15 
16     //对非数字的字符，不起作用
17     $arr = array(1,2,3,4,5,6,7,8,9,'a3');
18     var_dump(array_product($arr));
19 ?>
20 
21 结果：
22 int(362880)
23 int(117210240)
24 int(0)
        php--对纯数字的数组进行相乘
        　　
    • array_push — 将一个或多个单元压入数组的末尾（入栈）
      • 语法：array_push(数组，要添加的元素);
      • 说明：栈结构：先进后出，用数组作栈结构，元素的进出都在数组尾巴进行
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     
 9     $arr = array(1,2,3,4,5,6,7,8,9,10);
10 
11     var_dump(array_push($arr,11));
12     var_dump(array_push($arr,12));
13     var_dump(array_push($arr,13));
14     
15     print_r($arr);
16 ?>
17 
18 结果：
19 int(11)
20 int(12)
21 int(13)
22 Array
23 (
24     [0] => 1
25     [1] => 2
26     [2] => 3
27     [3] => 4
28     [4] => 5
29     [5] => 6
30     [6] => 7
31     [7] => 8
32     [8] => 9
33     [9] => 10
34     [10] => 11
35     [11] => 12
36     [12] => 13
37 )
        php--向数组的尾巴添加元素
        　　
    • array_rand — 从数组中随机取出一个或多个单元
      • 语法：array_rand(数组，产生数字的长度);    //长度不能超过数组的长度　　
      • 说明：用数组产生随机数
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(1,2,3,4,5,6,7,8,9,0);
 9     
10     //随机获取一个元素
11     var_dump(array_rand($arr));
12 
13     //随机获取二个元素
14     var_dump(array_rand($arr,2));
15 
16     //随机获取三个元素
17     var_dump(array_rand($arr,3));
18 
19 ?>
20 
21 结果：
22 //随机产生一个数字
23 int(5)
24 
25 //随机产生二个数字
26 array(2) {
27   [0]=>
28   int(2)
29   [1]=>
30   int(7)
31 }
32 
33 //随机产生三个数字
34 array(3) {
35   [0]=>
36   int(0)
37   [1]=>
38   int(7)
39   [2]=>
40   int(9)
41 }
        php--从数组中随机产生数字
    • array_reduce — 用回调函数迭代地将数组简化为单一的值
      • 语法：array_reduce(数组名,回调函数的名);   //回调函数的写法，自己订
      • 说明：把数组的元素，转化成一个值
      •  1 <?php
 2     //设置文件的编码为 utf-8,以便识别中文
 3     header('Content-type:text/html;charset=utf-8');  
 4 
 5     //让结果，按原先的格式输出
 6     echo '<pre>';
 7 
 8     $arr = array(234,32,4,25,34,543,643,6,43543);
 9 
10     //=================================================
11     //让数组通过回调函数，进行处理
12     var_dump(array_reduce($arr,'fun'));
13 
14     //使用回调函数，对元素进行相加
15     function fun($a, $b){
16     
17         $a += $b;
18         return $a;
19     }
20     //===============================================
21     //使用回调函数，对元素进行相加，并添加数字
22     var_dump(array_reduce($arr,'fun1',100));
23 
24     //使用回调函数，对元素进行相加
25         function fun1($a, $b){
26         
27             $a += $b;
28             return $a;
29     }
30 ?>
31 
32 结果：
33 int(45064)
34 int(45164)
        php--数组通过回调函数进行处理，化成一个数字

         　　

    • array_replace_recursive — 使用传递的数组递归替换第一个数组的元素
      • 语法：
      • 说明：
      • 　　
    • array_replace — 使用传递的数组替换第一个数组的元素
    • array_reverse — 返回一个单元顺序相反的数组
    • array_search — 在数组中搜索给定的值，如果成功则返回相应的键名
    • array_shift — 将数组开头的单元移出数组
    • array_slice — 从数组中取出一段
    • array_splice — 把数组中的一部分去掉并用其它值取代
    • array_sum — 计算数组中所有值的和
    • array_udiff_assoc — 带索引检查计算数组的差集，用回调函数比较数据
    • array_udiff_uassoc — 带索引检查计算数组的差集，用回调函数比较数据和索引
    • array_udiff — 用回调函数比较数据来计算数组的差集
    • array_uintersect_assoc — 带索引检查计算数组的交集，用回调函数比较数据
    • array_uintersect_uassoc — 带索引检查计算数组的交集，用回调函数比较数据和索引
    • array_uintersect — 计算数组的交集，用回调函数比较数据
    • array_unique — 移除数组中重复的值
    • array_unshift — 在数组开头插入一个或多个单元
    • array_values — 返回数组中所有的值
    • array_walk_recursive — 对数组中的每个成员递归地应用用户函数
    • array_walk — 使用用户自定义函数对数组中的每个元素做回调处理
    • array — 新建一个数组
    • arsort — 对数组进行逆向排序并保持索引关系
    • asort — 对数组进行排序并保持索引关系
    • compact — 建立一个数组，包括变量名和它们的值
    • count — 计算数组中的单元数目或对象中的属性个数
    • current — 返回数组中的当前单元
    • each — 返回数组中当前的键／值对并将数组指针向前移动一步
    • end — 将数组的内部指针指向最后一个单元
    • extract — 从数组中将变量导入到当前的符号表
    • in_array — 检查数组中是否存在某个值
    • key_exists — 别名 array_key_exists
    • key — 从关联数组中取得键名
    • krsort — 对数组按照键名逆向排序
    • ksort — 对数组按照键名排序
    • list — 把数组中的值赋给一些变量
    • natcasesort — 用“自然排序”算法对数组进行不区分大小写字母的排序
    • natsort — 用“自然排序”算法对数组排序
    • next — 将数组中的内部指针向前移动一位
    • pos — current 的别名
    • prev — 将数组的内部指针倒回一位
    • range — 建立一个包含指定范围单元的数组
    • reset — 将数组的内部指针指向第一个单元
    • rsort — 对数组逆向排序
    • shuffle — 将数组打乱
    • sizeof — count 的别名
    • sort — 对数组排序
    • uasort — 使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
    • uksort — 使用用户自定义的比较函数对数组中的键名进行排序
    • usort — 使用用户自定义的比较函数对数组中的值进行排序

    数学函数的说明

    　　1. array_change_key_case ：返回字符串键名全为小写或大写的数组

    　　　　

     　　　　
  • 相关阅读:
    有一群志同道合的程序员朋友是怎样的体验？
    hdu1387 模拟队列
    hau 1870 愚人节的礼物（栈）
    hdu1509 优先队列
    hdu1837 看病要排队（优先队列）
    hdu 1237 简单计算器（栈处理）
    hdu1022 模拟栈
    又一个错误的认知！
    jmeter+ant+jenkins 接口自动化测试持续集成（送源码）
    P1197 [JSOI2008]星球大战
  • 原文地址：https://www.cnblogs.com/sows/p/6045699.html
Copyright © 2020-2023  润新知