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

数组 函数

　　php--数组的尝鲜事例

• ---

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

　　　　　语法：array_change_key_case(数组名);　　　

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

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

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

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

• array_column — 返回数组中指定的一列

　　　　　　待定

• 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_product — 计算数组中所有值的乘积
• array_push — 将一个或多个单元压入数组的末尾（入栈）
• array_rand — 从数组中随机取出一个或多个单元
• array_reduce — 用回调函数迭代地将数组简化为单一的值
• array_replace_recursive — 使用传递的数组递归替换第一个数组的元素
• array_replace — 使用传递的数组替换第一个数组的元素
• array_reverse — 返回一个单元顺序相反的数组
• array_search — 在数组中搜索给定的值，如果成功则返回相应的键名
• array_shift — 将数组开头的单元移出数组
• array_slice — 从数组中取出一段
• array_splice — 把数组中的一部分去掉并用其它值取代
• array_sum — 计算数组中所有值的和
• array_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 ：返回字符串键名全为小写或大写的数组

【风马一族_php】数组函数