PHP 數組用法

array() 函數用於建立數組。在 PHP 中，有三種類型的數組：

索引數組 - 帶有數字索引的數組

關聯數組 - 帶有指定的鍵的數組

多維數組 - 包含一個或多個數組的數組

list(var1,var2...)      

var1 必需。第一個須要賦值的變量。var2... 可選。更多須要賦值的變量。

在一次操做中給一組變量賦值。該函數只用於數字索引的數組，且假定數字索引從 0 開始。      

$my_array = array("Dog","Cat","Horse");
list($a, , $c) = $my_array;
echo "我在這裏只用了 $a 和 $c 變量。";
//我在這裏只用了 Dog 和 Horse 變量。

shuffle(array)        

array 必需。規定要使用的數組。

把數組中的元素按隨機順序從新排列。該函數爲數組中的元素分配新的鍵名。已有鍵名將被刪除 。

$my_array = array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"purple");
shuffle($my_array);
print_r($my_array);
//Array ( [0] => green [1] => purple [2] => yellow [3] => red [4] => blue )

array_rand(array,number)     

array 必需。規定數組。 number 可選。規定返回多少隨機鍵名。

返回數組中的隨機鍵名，或者若是您規定函數返回不僅一個鍵名，則返回包含隨機鍵名的數組。

array_rand() 函數從數組中隨機選出一個或多個元素，並返回。

第二個參數用來肯定要選出幾個元素。若是選出的元素不止一個，則返回包含隨機鍵名的數組，不然返回該元素的鍵名。

註釋：自 PHP 4.2.0 起，再也不須要用 srand() 或 mt_srand() 函數給隨機數發生器播種，現已被自動完成。

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
print_r(array_rand($a,1));
//d

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
print_r(array_rand($a,2));
//Array ( [0] => a [1] => d )

range(low,high,step)        

low 必需。規定數組的最低值 high 必需。規定數組的最高值。step 可選。規定元素之間的步進制。默認是 1。

建立一個包含指定範圍的元素的數組。該函數返回一個包含從low到high之間的元素的數組。註釋：若是low參數大於 high 參數，則建立的數組將是從 high 到 low。

$letter = range("a","d");
print_r ($letter);
//Array ( [0] => a [1] => b [2] => c [3] => d )

$number = range(0,50,10);
print_r ($number);
//Array ( [0] => 0 [1] => 10 [2] => 20 [3] => 30 [4] => 40 [5] => 50 )

 array_keys(array,value,strict)

array 必需。規定數組。value 可選。您能夠指定鍵值，而後只有該鍵值對應的鍵名會被返回。

strict 可選。與 value 參數一塊兒使用。可能的值：true - 返回帶有指定鍵值的鍵名。依賴類型，數字 5 與字符串 "5" 是不一樣的。false - 默認值。不依賴類型，數字 5 與字符串 "5" 是相同的。

返回包含數組中全部鍵名的一個新數組。若是提供了第二個參數，則只返回鍵值爲該值的鍵名。若是 strict參數指定爲 true，則 PHP 會使用全等比較 (===) 來嚴格檢查鍵值的數據類型。

$a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
print_r(array_keys($a));
//Array ( [0] => Volvo [1] => BMW [2] => Toyota )

$a=array(10,20,30,"10");
print_r(array_keys($a,"10",true));
//Array ( [0] => 3 )

$a=array(10,20,30,"10");
print_r(array_keys($a,"10",false));
//Array ( [0] => 0 [1] => 3 )

array_values(array)    

array 必需。規定數組。

返回一個包含給定數組中全部鍵值的數組，但不保留鍵名。被返回的數組將使用數值鍵，從 0 開始並以 1 遞增。

$a=array("Name"=>"Bill","Age"=>"60","Country"=>"USA");
print_r(array_values($a));
//Array ( [0] => Bill [1] => 60 [2] => USA )

array_key_exists(key,array)

key 必需。規定鍵名。    array 必需。規定數組。

檢查某個數組中是否存在指定的鍵名，若是鍵名存在則返回 true，若是鍵名不存在則返回 false。

請記住，若是您指定數組的時候省略了鍵名，將會生成從 0 開始而且每一個鍵值對應以 1 遞增的整數鍵名。

$a=array("Volvo"=>"XC90","BMW"=>"X5");
if (key_exists("Toyota",$a))
  {
  echo "鍵存在！";
  }
else
  {
  echo "鍵不存在！";
  }
//鍵不存在！

$a=array("Volvo","BMW");
if (array_key_exists(0,$a))
  {
  echo "鍵存在！";
  }
else
  {
  echo "鍵不存在！";
  }
//鍵存在！

array_fill(index,number,value)  

index 必需。被返回數組的第一個索引。 number 必需。規定要插入的元素數。 value 必需。規定供填充數組所使用的值。

用鍵值填充數組。array_fill() 函數用給定的值填充數組，返回的數組有 number  個元素，值爲 value。返回的數組使用數字索引，從 start 位置開始並遞增。若是 number 爲 0 或小於 0，就會出錯。

$a1=array_fill(3,4,"blue");
print_r($a1);
//Array ( [3] => blue [4] => blue [5] => blue [6] => blue )

array_fill_keys(keys,value)  

keys 必需。使用該數組的值做爲鍵。非法值將被轉換爲字符串。value 必需。填充數組所使用的值。

使用指定的鍵和值填充數組。

$keys=array("a","b","c","d");
$a1=array_fill_keys($keys,"blue");
print_r($a1);
//Array ( [a] => blue [b] => blue [c] => blue [d] => blue )

array_filter(array,callbackfunction)  

array 必需。規定要過濾的數組。callbackfunction 必需。規定要使用的回調函數。

用回調函數過濾數組中的值。該函數把輸入數組中的每一個鍵值傳給回調函數。若是回調函數返回 true，則把輸入數組中的當前鍵值返回結果數組中。數組鍵名保持不變。

function test_odd($var)
{
return($var & 1);
}

$a1=array("a","b",2,3,4);
print_r(array_filter($a1,"test_odd"));
//Array ( [3] => 3 )

array_flip(array)    

array 必需。規定需進行鍵/值對反轉的數組。

反轉/交換數組中全部的鍵名以及它們關聯的鍵值。返回一個反轉後的數組，若是同一值出現了屢次，則最後一個鍵名將做爲它的值，全部其餘的鍵名都將丟失。若是原數組中的值的數據類型不是字符串或整數，函數將報錯。

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$result=array_flip($a1);
print_r($result);
//Array ( [red] => a [green] => b [blue] => c [yellow] => d )

array_change_key_case(array,case)

array 必需。規定要使用的數組。case 可選。可能的值:CASE_LOWER - 默認值。將數組的鍵轉換爲小寫字母。CASE_UPPER - 將數組的鍵轉換爲大寫字母。

將數組的全部的鍵都轉換爲大寫字母或小寫字母。數組的數字索引不發生變化。若是未提供可選參數（即第二個參數），則默認轉換爲小寫字母。若是在運行該函數時兩個或多個鍵相同，則最後的元素會覆蓋其餘元素。

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
print_r(array_change_key_case($age,CASE_UPPER));
//Array ( [BILL] => 60 [STEVE] => 56 [MARK] => 31 )

$pets=array("a"=>"Cat","B"=>"Dog","c"=>"Horse","b"=>"Bird");
print_r(array_change_key_case($pets,CASE_UPPER));
//Array ( [A] => Cat [B] => Bird [C] => Horse )

array_chunk(array,size,preserve_key)

array 必需。規定要使用的數組。    size 必需。整數值，規定每一個新數組包含多少個元素。

preserve_key 可選。可能的值：true - 保留原始數組中的鍵名。false - 默認。每一個結果數組使用從零開始的新數組索引。

把數組分割爲新的數組塊。其中每一個數組的單元數目由 size 參數決定。最後一個數組的單元數目可能會少幾個。可選參數 preserve_key是一個布爾值，它指定新數組的元素是否有和原數組相同的鍵（用於關聯數組），仍是從 0 開始的新數字鍵（用於索引數組）。默認是分配新的鍵。

$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
print_r(array_chunk($cars,2));
//Array ( [0] => Array ( [0] => Volvo [1] => BMW ) [1] => Array ( [0] => Toyota [1] => Honda ) [2] => Array ( [0] => Mercedes [1] => Opel ) )

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31","David"=>"35");
print_r(array_chunk($age,2,true));
//Array ( [0] => Array ( [Bill] => 60 [Steve] => 56 ) [1] => Array ( [Mark] => 31 [David] => 35 ) )

array_column(array,column_key,index_key)

array 必需。規定要使用的多維數組（記錄集）。

column_key 必需。須要返回值的列。能夠是索引數組的列的整數索引，或者是關聯數組的列的字符串鍵值。該參數也能夠是 NULL，此時將返回整個數組（配合 index_key 參數來重置數組鍵的時候，很是有用）。

index_key 可選。用做返回數組的索引/鍵的列。

返回輸入數組中某個單一列的值。

$a = array(
  array(
    'id' => 5698,
    'first_name' => 'Bill',
    'last_name' => 'Gates',
  ),
  array(
    'id' => 4767,
    'first_name' => 'Steve',
    'last_name' => 'Jobs',
  ),
  array(
    'id' => 3809,
    'first_name' => 'Mark',
    'last_name' => 'Zuckerberg',
  )
);

$last_names = array_column($a, 'last_name');
print_r($last_names);
//Array([0] => Gates [1] => Jobs [2] => Zuckerberg)

$a = array(
  array(
    'id' => 5698,
    'first_name' => 'Bill',
    'last_name' => 'Gates',
  ),
  array(
    'id' => 4767,
    'first_name' => 'Steve',
    'last_name' => 'Jobs',
  )
  array(
    'id' => 3809,
    'first_name' => 'Mark',
    'last_name' => 'Zuckerberg',
  )
);
$last_names = array_column($a, 'last_name', 'id');
print_r($last_names);
//Array( [5698] => Gates [4767] => Jobs [3809] => Zuckerberg)

array_combine(keys,values)

keys    必需。鍵名數組。        values    必需。鍵值數組。

經過合併兩個數組來建立一個新數組，其中的一個數組是鍵名，另外一個數組的值爲鍵值。鍵名數組和鍵值數組的元素個數必須相同！若是其中一個數組爲空，或者兩個數組的元素個數不一樣，則該函數返回 false。

$fname=array("Bill","Steve","Mark");
$age=array("60","56","31");

$c=array_combine($fname,$age);
print_r($c);
//Array ( [Bill] => 60 [Steve] => 56 [Mark] => 31 )

array_count_values(array)

array    必需。規定須要對值進行計數的數組。

對數組中的全部值進行計數。用於統計數組中全部值出現的次數。本函數返回一個數組，其元素的鍵名是原數組的值，鍵值是該值在原數組中出現的次數。

$a=array("A","Cat","Dog","A","Dog");
print_r(array_count_values($a));
//Array ( [A] => 2 [Cat] => 1 [Dog] => 2 )

array_map(myfunction,array1,array2,array3...)

myfunction    必需。用戶自定義函數的名稱，或者是 null。

array1    必需。規定數組。          array2    可選。規定數組。        array3    可選。規定數組。

將用戶自定義函數做用到數組中的每一個值上，並返回用戶自定義函數做用後的帶有新值的數組。

回調函數接受的參數數目應該和傳遞給 array_map() 函數的數組數目一致。您能夠向函數輸入一個或者多個數組。

function myfunction($v)
{
  return($v*$v);
}

$a=array(1,2,3,4,5);
print_r(array_map("myfunction",$a));
//Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

function myfunction($v1,$v2)
{
if ($v1===$v2)
  {
  return "same";
  }
return "different";
}

$a1=array("Horse","Dog","Cat");
$a2=array("Cow","Dog","Rat");
print_r(array_map("myfunction",$a1,$a2));
//Array ( [0] => different [1] => same [2] => different )

function myfunction($v)
{
$v=strtoupper($v);
  return $v;
}

$a=array("Animal" => "horse", "Type" => "mammal");
print_r(array_map("myfunction",$a));
//Array ( [Animal] => HORSE [Type] => MAMMAL )

$a1=array("Dog","Cat");
$a2=array("Puppy","Kitten");
print_r(array_map(null,$a1,$a2));
//Array ( [0] => Array ( [0] => Dog [1] => Puppy ) [1] => Array ( [0] => Cat [1] => Kitten ) )

array_multisort(array1,sorting order,sorting type,array2,array3...)

array1    必需。規定數組。

sorting order    可選。規定排列順序。可能的值：SORT_ASC - 默認。按升序排列 (A-Z)。    SORT_DESC - 按降序排列 (Z-A)。

sorting type    可選。規定排序類型。可能的值：

                SORT_REGULAR - 默認。把每一項按常規順序排列（Standard ASCII，不改變類型）。

                SORT_NUMERIC - 把每一項做爲數字來處理。

                SORT_STRING - 把每一項做爲字符串來處理。

               SORT_LOCALE_STRING - 把每一項做爲字符串來處理，基於當前區域設置（可經過 setlocale() 進行更改）。

                SORT_NATURAL - 把每一項做爲字符串來處理，使用相似 natsort() 的天然排序。

               SORT_FLAG_CASE - 能夠結合（按位或）SORT_STRING 或 SORT_NATURAL 對字符串進行排序，不區分大小寫。

array2    可選。規定數組。

array3    可選。規定數組。

返回排序數組。您能夠輸入一個或多個數組。函數先對第一個數組進行排序，接着是其餘數組，若是兩個或多個值相同，它將對下一個數組進行排序。 註釋：字符串鍵名將被保留，可是數字鍵名將被從新索引，從 0 開始，並以 1 遞增。 您能夠在每一個數組後設置排序順序和排序類型參數。若是沒有設置，每一個數組參數會使用默認值。

對多個數組或多維數組進行排序。參數中的數組被當成一個表的列並以行來進行排序 - 這相似 SQL 的 ORDER BY 子句的功能。第一個數組是要排序的主要數組。數組中的行（值）比較爲相同的話，就會按照下一個輸入數組中相應值的大小進行排序，依此類推。

第一個參數是數組，隨後的每個參數多是數組，也多是下面的排序順序標誌（排序標誌用於更改默認的排列順序）之一：SORT_ASC - 默認，按升序排列。(A-Z)    SORT_DESC - 按降序排列。(Z-A)

隨後能夠指定排序的類型：SORT_REGULAR - 默認。將每一項按常規順序排列。SORT_NUMERIC - 將每一項按數字順序排列。SORT_STRING - 將每一項按字母順序排列。

count(array,mode)    sizeof(array,mode)

array    必需。規定數組。    mode    可選。規定模式。可能的值：0 - 默認。不對多維數組中的全部元素進行計數。1 - 遞歸地計數數組中元素的數目（計算多維數組中的全部元素）

返回數組中元素的數目。sizeof() 函數是count() 函數的別名。

計算數組中的單元數目或對象中的屬性個數。對於數組，返回其元素的個數，對於其餘值，返回 1。若是參數是變量而變量沒有定義，則返回 0。若是 mode 被設置爲 COUNT_RECURSIVE（或 1），則會遞歸底計算多維數組中的數組的元素個數。

$cars=array("Volvo","BMW","Toyota");
echo count($cars);
//3

$cars=array
  (
  "Volvo"=>array
  (
  "XC60",
  "XC90"
  ),
  "BMW"=>array
  (
  "X3",
  "X5"
  ),
  "Toyota"=>array
  (
  "Highlander"
  )
  );

echo "常規計數：" . count($cars)." ";
echo "遞歸計數：" . count($cars,1);
//3 8

compact(var1,var2...)    

var1    必需。能夠是帶有變量名的字符串，或者是變量數組。

var2，…    可選。能夠是帶有變量名的字符串，或者是變量數組。容許多個參數。

建立包含變量名和它們的值的數組。任何沒有變量名與之對應的字符串都被略過。

compact() 函數建立一個由參數所帶變量組成的數組。若是參數中存在數組，該數組中變量的值也會被獲取。

本函數返回的數組是一個關聯數組，鍵名爲函數的參數，鍵值爲參數中變量的值。

$firstname = "Bill";
$lastname = "Gates";
$age = "60";
$result = compact("firstname", "lastname", "age");
print_r($result);
//Array ( [firstname] => Bill [lastname] => Gates [age] => 60 )

$firstname = "Bill";
$lastname = "Gates";
$age = "60";
$name = array("firstname", "lastname");
$result = compact($name, "location", "age");
print_r($result);
//Array ( [firstname] => Bill [lastname] => Gates [age] => 60 )

extract(array,extract_rules,prefix)

array    必需。規定要使用的數組。

extract_rules    可選。extract() 函數將檢查每一個鍵名是否爲合法的變量名，同時也檢查和符號表中已存在的變量名是否衝突。對不合法和衝突的鍵名的處理將根據此參數決定。可能的值：

       EXTR_OVERWRITE - 默認。若是有衝突，則覆蓋已有的變量。

       EXTR_SKIP - 若是有衝突，不覆蓋已有的變量。

       EXTR_PREFIX_SAME - 若是有衝突，在變量名前加上前綴 prefix。

       EXTR_PREFIX_ALL - 給全部變量名加上前綴 prefix。

       EXTR_PREFIX_INVALID - 僅在不合法或數字變量名前加上前綴 prefix。

       EXTR_IF_EXISTS - 僅在當前符號表中已有同名變量時，覆蓋它們的值。其它的都不處理。

       EXTR_PREFIX_IF_EXISTS - 僅在當前符號表中已有同名變量時，創建附加了前綴的變量名，其它的都不處理。

       EXTR_REFS - 將變量做爲引用提取。導入的變量仍然引用了數組參數的值。

prefix    可選。請注意 prefix 僅在 extract_type 的值是 EXTR_PREFIX_SAME，EXTR_PREFIX_ALL，EXTR_PREFIX_INVALID 或 EXTR_PREFIX_IF_EXISTS 時須要。若是附加了前綴後的結果不是合法的變量名，將不會導入到符號表中。前綴和數組鍵名之間會自動加上一個下劃線。

從數組中將變量導入到當前的符號表。該函數使用數組鍵名做爲變量名，使用數組鍵值做爲變量值。針對數組中的每一個元素，將在當前符號表中建立對應的一個變量。第二個參數type 用於指定當某個變量已經存在，而數組中又有同名元素時，extract() 函數如何對待這樣的衝突。該函數返回成功導入到符號表中的變量數目。

$a = "Original";
$my_array = array("a" => "Cat","b" => "Dog", "c" => "Horse");
extract($my_array);
echo "\$a = $a; \$b = $b; \$c = $c";
//$a = Cat; $b = Dog; $c = Horse

$a = "Original";
$my_array = array("a" => "Cat", "b" => "Dog", "c" => "Horse");
extract($my_array, EXTR_PREFIX_SAME, "dup");
echo "\$a = $a; \$b = $b; \$c = $c; \$dup_a = $dup_a";
//$a = Original; $b = Dog; $c = Horse; $dup_a = Cat

in_array(search,array,type)

search      必需。規定要在數組搜索的值。

array    必需。規定要搜索的數組。

type    可選。若是設置該參數爲 true，則檢查搜索的數據與數組的值的類型是否相同。

搜索數組中是否存在指定的值。若是search參數是字符串且type參數被設置爲 TRUE，則搜索區分大小寫。

若是給定的值 search存在於數組 array 中則返回 true。若是第三個參數設置爲 true，函數只有在元素存在於數組中且數據類型與給定值相同時才返回 true。若是沒有在數組中找到參數，函數返回 false。

$people = array("Bill", "Steve", "Mark", "David");
if (in_array("Mark", $people))
  {
  echo "匹配已找到";
  }
else
  {
  echo "匹配未找到";
  }
//匹配已找到

$people = array("Bill", "Steve", "Mark", "David");
if (in_array("23", $people, TRUE))
  {
  echo "匹配已找到 ";
  }
else
  {
  echo "匹配未找到 ";
  }
if (in_array("Mark",$people, TRUE))
  {
  echo "匹配已找到 ";
  }
else
  {
  echo "匹配未找到 ";
  }

if (in_array(23,$people, TRUE))
  {
  echo "匹配已找到 ";
  }
else
  {
  echo "匹配未找到 ";
  }
//匹配未找到 匹配已找到 匹配未找到

array_merge(array1,array2,array3...)

array1    必需。規定數組。array2   可選。規定數組。    array3   可選。規定數組。

把一個或多個數組合併爲一個數組。您能夠向函數輸入一個或者多個數組。若是兩個或更多個數組元素有相同的鍵名，則最後的元素會覆蓋其餘元素。若是您僅向 array_merge() 函數輸入一個數組，且鍵名是整數，則該函數將返回帶有整數鍵名的新數組，其鍵名以 0 開始進行從新索引。

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2));
//Array ( [a] => red [b] => yellow [c] => blue )

$a=array(3=>"red",4=>"green");
print_r(array_merge($a));
//Array ( [0] => red [1] => green )

array_merge_recursive(array1,array2,array3...) 

array1    必需。規定數組。array2   可選。規定數組。    array3   可選。規定數組。

把一個或多個數組合併爲一個數組。

該函數與 array_merge()  函數的區別在於處理兩個或更多個數組元素有相同的鍵名時。array_merge_recursive() 不會進行鍵名覆蓋，而是將多個相同鍵名的值遞歸組成一個數組。

若是您僅僅向 array_merge_recursive() 函數輸入一個數組，結果與 array_merge() 相同，函數將返回帶有整數鍵名的新數組，其鍵名以 0 開始進行從新索引。

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge_recursive($a1,$a2));
//Array ( [a] => red [b] => Array ( [0] => green [1] => yellow ) [c] => blue )

array_pad(array,size,value)     

array    必需。規定數組。size  必需。規定從函數返回的數組中元素的個數。    value   必需。規定從函數返回的數組中新元素的值。

將指定數量的帶有指定值的元素插入到數組中。若是您將size參數設置爲負數，該函數會在原始數組以前插入新的元素 。若是 size參數小於原始數組的長度，該函數不會刪除任何元素。

$a=array("red","green");
print_r(array_pad($a,5,"blue"));
//Array ( [0] => red [1] => green [2] => blue [3] => blue [4] => blue )

$a=array("red","green");
print_r(array_pad($a,-5,"blue"));
//Array ( [0] => blue [1] => blue [2] => blue [3] => red [4] => green )

array_product(array)

array    必需。規定數組。

計算並返回數組的乘積。

$a=array(5,5);
echo(array_product($a));
//25

array_sum(array)

array    必需。規定數組。

返回數組中全部值的和。若是全部值都是整數，則返回一個整數值。若是其中有一個或多個值是浮點數，則返回浮點數。

$a=array(5,15,25);
echo array_sum($a);
//45

array_pop(array)    出棧

array    必需。規定數組。

刪除數組中的最後一個元素。

$a=array("red","green","blue");
array_pop($a);
print_r($a);
//Array ( [0] => red [1] => green )

array_push(array,value1,value2...)    入棧

array    必需。規定數組。    value1    必需。規定要添加的值。     value2    可選。規定要添加的值。

向第一個參數的數組尾部添加一個或多個元素（入棧），而後返回新數組的長度。該函數等於屢次調用 $array[] = $value。

即便數組中有字符串鍵名，您添加的元素也始終是數字鍵。

若是用 array_push() 來給數組增長一個單元，還不如用 $array[] =，由於這樣沒有調用函數的額外負擔。

若是第一個參數不是數組，array_push() 將發出一條警告。這和 $var[] 的行爲不一樣，後者會新建一個數組。

$a=array("red","green");
array_push($a,"blue","yellow");
print_r($a);
//Array ( [0] => red [1] => green [2] => blue [3] => yellow )

$a=array("a"=>"red","b"=>"green");
array_push($a,"blue","yellow");
print_r($a)
//Array ( [a] => red [b] => green [0] => blue [1] => yellow )

array_shift(array)     

array    必需。規定數組。 

刪除數組中第一個元素，並返回被刪除元素的值。

若是鍵名是數字的，全部元素都會得到新的鍵名，從 0 開始，並以 1 遞增。

$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_shift($a);
print_r ($a);
//redArray ( [b] => green [c] => blue )

$a=array(0=>"red",1=>"green",2=>"blue");
echo array_shift($a);
print_r ($a);
//redArray ( [0] => green [1] => blue )

array_unshift(array,value1,value2,value3...)    

array    必需。規定數組。     value1    必需。規定要插入的值。

value2    可選。規定要插入的值。    value3    可選。規定要插入的值。

用於向數組插入新元素。新數組的值將被插入到數組的開頭。 

被加上的元素做爲一個總體添加，這些元素在數組中的順序和在參數中的順序同樣。

該函數會返回數組中元素的個數。數值鍵名將從 0 開始，以 1 遞增。字符串鍵名將保持不變。

$a=array("a"=>"red","b"=>"green");
array_unshift($a,"blue");
print_r($a);
//Array ( [0] => blue [a] => red [b] => green )

$a=array("a"=>"red","b"=>"green");
print_r(array_unshift($a,"blue"));
//3

$a=array(0=>"red",1=>"green");
array_unshift($a,"blue");
print_r($a);
//Array ( [0] => blue [1] => red [2] => green )

array_reduce(array,myfunction,initial)    

array  必需。規定數組。  myfunction  必需。規定函數的名稱。 initial  可選。規定發送到函數的初始值。

向用戶自定義函數發送數組中的值，並返回一個字符串。

若是數組是空的且未傳遞 initial 參數，該函數返回 NULL。

array_reduce() 函數用回調函數迭代地將數組簡化爲單一的值。若是指定第三個參數，則該參數將被當成是數組中的第一個值來處理，或者若是數組爲空的話就做爲最終返回值。

function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction"));
//-Dog-Cat-Horse

function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction",5));
//5-Dog-Cat-Horse

function myfunction($v1,$v2)
{
return $v1+$v2;
}
$a=array(10,15,20);
print_r(array_reduce($a,"myfunction",5));
//50

array_replace(array1,array2,array3...)    

array1  必需。規定數組。  array2  可選。指定要替換 array1 的值的數組。array3… 可選。指定多個要替換array1和 array2, ... 的值的數組。後面數組的值將覆蓋以前數組的值。

使用後面數組的值替換第一個數組的值。

您能夠向函數傳遞一個數組，或者多個數組。若是一個鍵存在於第一個數組 array1 同時也存在於第二個數組 array2，第一個數組 array1 中的值將被第二個數組 array2 中的值替換。若是一個鍵僅存在於第一個數組 array1，它將保持不變。若是一個鍵存在於第二個數組 array2，可是不存在於第一個數組 array1，則會在第一個數組 array1 中建立這個元素。若是傳遞了多個替換數組，它們將被按順序依次處理，後面數組的值將覆蓋以前數組的值。

 

$a1=array("red","green");
$a2=array("blue","yellow");
print_r(array_replace($a1,$a2));
//Array ( [0] => blue [1] => yellow )

$a1=array("a"=>"red","b"=>"green");
$a2=array("a"=>"orange","burgundy");
print_r(array_replace($a1,$a2));
//Array ( [a] => orange [b] => green [0] => burgundy )

array_replace_recursive(array1,array2,array3...)

array1  必需。規定數組。  array2  可選。指定要替換 array1 的值的數組。array3… 可選。指定多個要替換array1和 array2, ... 的值的數組。後面數組的值將覆蓋以前數組的值。

遞歸地使用後面數組的值替換第一個數組的值。

$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
print_r(array_replace_recursive($a1,$a2));
//Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black [1] => blue ) )

$a1=array("a"=>array("red"),"b"=>array("green","blue"));
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$a3=array("a"=>array("orange"),"b"=>array("burgundy"));
print_r(array_replace_recursive($a1,$a2,$a3));
//Array ( [a] => Array ( [0] => orange ) [b] => Array ( [0] => burgundy [1] => blue ) )

$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$result=array_replace_recursive($a1,$a2);
print_r($result);
$result=array_replace($a1,$a2);
print_r($result);
//Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black [1] => blue ) ) Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black ) )

 array_reverse(array,preserve)       

array1  必需。規定數組。preserve    可選。規定是否保留原始數組的鍵名。這個參數是 PHP 4.0.3 中新加的。可能的值：true/false

以相反的元素順序返回數組。將原數組中的元素順序翻轉，建立新的數組並返回。若是第二個參數指定爲 true，則元素的鍵名保持不變，不然鍵名將丟失。

$a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
print_r(array_reverse($a));
//Array ( [c] => Toyota [b] => BMW [a] => Volvo )

$a=array("Volvo","XC90",array("BMW","Toyota"));
$reverse=array_reverse($a);
$preserve=array_reverse($a,true);
print_r($a);
print_r($reverse);
print_r($preserve);
//Array ( [0] => Volvo [1] => XC90 [2] => Array ( [0] => BMW [1] => Toyota ) ) 
//Array ( [0] => Array ( [0] => BMW [1] => Toyota ) [1] => XC90 [2] => Volvo )
//Array ( [2] => Array ( [0] => BMW [1] => Toyota ) [1] => XC90 [0] => Volvo )

以相反的順序返回數組。對於整數鍵名，若是第二個參數指定爲 true，則元素的鍵名保持不變，不然鍵名將丟失。

array_search(value,array,strict)

value  必需。規定須要搜素的鍵值。    array    必需。規定被搜索的數組。

strict    可選。若是該參數被設置爲 TRUE，則函數在數組中搜索數據類型和值都一致的元素。可能的值：true/false（默認）若是設置爲 true，則在數組中檢查給定值的類型，數字 5 和字符串 5 是不一樣的。

在數組中搜索某個鍵值，並返回對應的鍵名。在數組中查找一個鍵值。若是找到了該值，匹配元素的鍵名會被返回。若是沒找到，則返回 false。若是在數組中找到鍵值超過一次，則返回第一次找到的鍵值所匹配的鍵名。

$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_search("red",$a);
//a

$a=array("a"=>"5","b"=>5,"c"=>"5");
echo array_search(5,$a,true);
//b

array_slice(array,start,length,preserve)

array    必需。規定數組。    

start    必需。數值。規定取出元素的開始位置。 0 = 第一個元素。若是該值設置爲正數，則從前日後開始取。若是該值設置爲負數，則從後向前取 start 絕對值。 -2 意味着從數組的倒數第二個元素開始。

length    可選。數值。規定被返回數組的長度。若是該值設置爲整數，則返回該數量的元素。若是該值設置爲負數，則函數將在舉例數組末端這麼遠的地方終止取出。若是該值未設置，則返回從 start 參數設置的位置開始直到數組末端的全部元素。

preserve    可選。規定函數是保留鍵名仍是重置鍵名。可能的值：true - 保留鍵名。false - 默認。重置鍵名

在數組中根據條件取出一段值，並返回。若是數組有字符串鍵，所返回的數組將保留鍵名。

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,2));
//Array ( [0] => blue [1] => yellow [2] => brown )

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,1,2));
//Array ( [0] => green [1] => blue )

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,-2,1));
//Array ( [0] => yellow )

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,1,2,true));
//Array ( [1] => green [2] => blue )

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"brown");
print_r(array_slice($a,1,2));
$a=array("0"=>"red","1"=>"green","2"=>"blue","3"=>"yellow","4"=>"brown");
print_r(array_slice($a,1,2));
//Array ( [b] => green [c] => blue ) Array ( [0] => green [1] => blue )

array_splice(array,start,length,array)

array    必需。規定數組。    

start    必需。數值。規定取出元素的開始位置。 0 = 第一個元素。若是該值設置爲正數，則從前日後開始取。若是該值設置爲負數，則從後向前取 start 絕對值。 -2 意味着從數組的倒數第二個元素開始。

length    可選。數值。規定被返回數組的長度。若是該值設置爲整數，則返回該數量的元素。若是該值設置爲負數，則函數將在舉例數組末端這麼遠的地方終止取出。若是該值未設置，則返回從 start 參數設置的位置開始直到數組末端的全部元素。

array    可選。規定帶有要插入原始數組中元素的數組。若是隻有一個元素，則能夠設置爲字符串，不須要設置爲數組。

從數組中移除選定的元素，並用新元素取代它。該函數也將返回包含被移除元素的數組。若是函數沒有移除任何元素（length=0），則將從 start 參數的位置插入被替換數組。不保留被替換數組中的鍵名。

array_splice() 函數與 array_slice() 函數相似，選擇數組中的一系列元素，但不返回，而是刪除它們並用其它值代替。若是提供了第四個參數，則以前選中的那些元素將被第四個參數指定的數組取代。最後生成的數組將會返回。

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
array_splice($a1,0,2,$a2);
print_r($a1);
//Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
print_r(array_splice($a1,0,2,$a2));
//Array ( [a] => red [b] => green )

$a1=array("0"=>"red","1"=>"green");
$a2=array("0"=>"purple","1"=>"orange");
array_splice($a1,1,0,$a2);
print_r($a1);
//Array ( [0] => red [1] => purple [2] => orange [3] => green )

array_unique(array)

array    必需。規定數組。 

sortingtype    可選。規定如何比較數組元素/項目。可能的值：SORT_STRING - 默認。把項目做爲字符串來比較。SORT_REGULAR - 把每一項按常規順序排列（Standard ASCII，不改變類型）。SORT_NUMERIC - 把每一項做爲數字來處理。SORT_LOCALE_STRING - 把每一項做爲字符串來處理，基於當前區域設置（可經過 setlocale() 進行更改）。

移除數組中的重複的值，並返回結果數組。當幾個數組元素的值相等時，只保留第一個元素，其餘的元素被刪除。返回的數組中鍵名不變。被保留的數組將保持第一個數組項的鍵名類型。

$a=array("a"=>"red","b"=>"green","c"=>"red");
print_r(array_unique($a));
//Array ( [a] => red [b] => green )

array_walk(array,myfunction,userdata...)    

array    必需。規定數組。 myfunction 必需。用戶自定義函數的名稱。

userdata…    可選。規定用戶自定義函數的參數。您可以向此函數傳遞任意多參數。

對數組中的每一個元素應用用戶自定義函數。在函數中，數組的鍵名和鍵值是參數。您能夠經過把用戶自定義函數中的第一個參數指定爲引用：&$value，來改變數組元素的值。如需操做更深的數組（一個數組中包含另外一個數組），請使用array_walk_recursive() 函數。

array_walk() 函數對數組中的每一個元素應用回調函數。若是成功則返回 TRUE，不然返回 FALSE。

典型狀況下 myfunction 接受兩個參數。array 參數的值做爲第一個，鍵名做爲第二個。若是提供了可選參數 userdata ，將被做爲第三個參數傳遞給回調函數。

若是 myfunction 函數須要的參數比給出的多，則每次 array_walk() 調用 myfunction 時都會產生一個 E_WARNING 級的錯誤。這些警告能夠經過在 array_walk() 調用前加上 PHP 的錯誤操做符 @ 來抑制，或者用 error_reporting()。

註釋：若是回調函數須要直接做用於數組中的值，能夠將回調函數的第一個參數指定爲引用：&$value。

註釋：將鍵名和 userdata 傳遞到 myfunction 中是 PHP 4.0 新增長的。

function myfunction($value,$key)
{
echo "The key $key has the value $value ";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");
//The key a has the value red The key b has the value green The key c has the value blue

function myfunction($value,$key,$p)
{
echo "$key $p $value<br>";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction","has the value");
//a has the value red b has the value green c has the value blue

function myfunction(&$value,$key)
{
$value="yellow";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");
print_r($a);
//Array ( [a] => yellow [b] => yellow [c] => yellow )

array_walk_recursive(array,myfunction,parameter...)   

array    必需。規定數組。 myfunction 必需。用戶自定義函數的名稱。

userdata…    可選。規定用戶自定義函數的參數。您可以向此函數傳遞任意多參數。

對數組中的每一個元素應用用戶自定義函數。在函數中，數組的鍵名和鍵值是參數。

該函數與 array_walk() 函數的不一樣在於能夠操做更深的數組（一個數組中包含另外一個數組）。

array_walk_recursive() 函數對數組中的每一個元素應用回調函數。不同的是，若是原數組中的元素也是數組，就會遞歸地調用回調函數，也就是說，會遞歸到更深層的數組中去。

典型狀況下，myfunction 接受兩個參數。array 參數的值做爲第一個，鍵名做爲第二個。若是提供了可選參數 userdata ，將被做爲第三個參數傳遞給回調函數。

若是回調函數須要直接做用於數組中的值，能夠將回調函數的第一個參數指定爲引用，這樣對這些單元的任何改變也將會改變原始數組自己。

function myfunction($value,$key)
{
echo "鍵 $key 的值是 $value 。<br>";
}
$a1=array("a"=>"red","b"=>"green");
$a2=array($a1,"1"=>"blue","2"=>"yellow");
array_walk_recursive($a2,"myfunction");
//鍵 a 的值是 red 。 鍵 b 的值是 green 。 鍵 1 的值是 blue 。 鍵 2 的值是 yellow 。

比較數組，返回差集

array_diff(array1,array2,array3...)     (只比較鍵值。在返回的數組中鍵名保持不變。)

array_diff_assoc(array1,array2,array3...)      （比較鍵名和鍵值）

array_diff_key(array1,array2,array3...)     （只比較鍵名）

array_diff_uassoc(array1,array2,array3...,myfunction)    （比較鍵名和鍵值，使用用戶自定義的鍵名比較函數。返回的數組中鍵名保持不變）

array_diff_ukey(array1,array2,array3...,myfunction)   （只比較鍵名，使用用戶自定義的鍵名比較函數）

array_udiff(array1,array2,array3...,myfunction)       （只比較值，使用一個用戶自定義的鍵名比較函數）

array_udiff_assoc(array1,array2,array3...,myfunction)    （比較鍵和值，使用內建函數比較鍵名，使用用戶自定義函數比較鍵值）

array_udiff_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)        （比較鍵和值，使用兩個用戶自定義的鍵名比較函數）

array1    必需。與其餘數組進行比較的第一個數組。

array2    必需。與第一個數組進行比較的數組。

array3    可選。與第一個數組進行比較的其餘數組。

myfunction     必需。定義可調用比較函數的字符串。若是第一個參數小於、等於或大於第二個參數，則該比較函數必須返回小於、等於或大於 0 的整數。

//array_diff(array1,array2,array3...)     (只比較鍵值。在返回的數組中，鍵名保持不變。)
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_diff($a1,$a2);
print_r($result);
//Array ( [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");
$result=array_diff($a1,$a2,$a3);
print_r($result);
//Array ( [b] => green [c] => blue )

//array_diff_assoc(array1,array2,array3...)      （比較鍵名和鍵值）
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
$result=array_diff_assoc($a1,$a2);
print_r($result);
//Array ( [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_diff_assoc($a1,$a2);
print_r($result);
//Array ( [a] => red [b] => green [c] => blue [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","f"=>"green","g"=>"blue");
$a3=array("h"=>"red","b"=>"green","g"=>"blue");
$result=array_diff_assoc($a1,$a2,$a3);
print_r($result);
//Array ( [c] => blue [d] => yellow )

//array_diff_key(array1,array2,array3...)     （只比較鍵名）
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
$result=array_diff_key($a1,$a2);
print_r($result);
//Array ( [b] => green )

$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");
$result=array_diff_key($a1,$a2,$a3);
print_r($result);
//Array ( [a] => red [b] => green )

function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("d"=>"red","b"=>"green","e"=>"blue");
$result=array_diff_uassoc($a1,$a2,"myfunction");
print_r($result);
//Array ( [a] => red [c] => blue )

//array_diff_uassoc(array1,array2,array3...,myfunction)    （比較鍵名和鍵值，使用用戶自定義的鍵名比較函數）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","d"=>"blue");
$a3=array("e"=>"yellow","a"=>"red","d"=>"blue");
$result=array_diff_uassoc($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [c] => blue )

//array_diff_ukey(array1,array2,array3...,myfunction)   （只比較鍵名，使用用戶自定義的鍵名比較函數）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_diff_ukey($a1,$a2,"myfunction");
print_r($result);
//Array ( [c] => blue )

function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"black","b"=>"yellow","d"=>"brown");
$a3=array("e"=>"purple","f"=>"white","a"=>"gold");
$result=array_diff_ukey($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [c] => blue )

//array_udiff(array1,array2,array3...,myfunction)       （只比較值，使用一個用戶自定義的鍵名比較函數）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_udiff($a1,$a2,"myfunction");
print_r($result);
//Array ( [a] => red [b] => green )

//array_udiff_assoc(array1,array2,array3...,myfunction)    （比較鍵和值，使用內建函數比較鍵名，使用用戶自定義函數比較鍵值）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_udiff_assoc($a1,$a2,"myfunction");
print_r($result);
//Array ( [b] => green [c] => blue )

//array_udiff_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)        （比較鍵和值，使用兩個用戶自定義的鍵名比較函數）
function myfunction_key($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
function myfunction_value($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_udiff_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result);
//Array ( [c] => blue )

比較數組，返回交集

array_intersect(array1,array2,array3...)     （只比較鍵值）。

array_intersect_assoc(array1,array2,array3...)      （比較鍵名和鍵值）。

array_intersect_key(array1,array2,array3...)      （只比較鍵名）。

array_intersect_uassoc(array1,array2,array3...,myfunction)      （比較鍵名和鍵值，使用用戶自定義的鍵名比較函數）。

array_intersect_ukey(array1,array2,array3...,myfunction)   （只比較鍵名，使用用戶自定義的鍵名比較函數）。

array_uintersect(array1,array2,array3...,myfunction)    （只比較值，使用一個用戶自定義的鍵名比較函數）。

array_uintersect_assoc(array1,array2,array3...,myfunction)（比較鍵和值，使用內建函數比較鍵名，使用用戶自定義函數比較鍵值）。

array_uintersect_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)（比較鍵和值，使用兩個用戶自定義的鍵名比較函數）。

array1    必需。與其餘數組進行比較的第一個數組。

array2    必需。與第一個數組進行比較的數組。

array3    可選。與第一個數組進行比較的其餘數組。

myfunction     必需。定義可調用比較函數的字符串。若是第一個參數小於、等於或大於第二個參數，則該比較函數必須返回小於、等於或大於 0 的整數。

#array_intersect(array1,array2,array3...)     （只比較鍵值）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_intersect($a1,$a2);
print_r($result);
//Array ( [a] => red [b] => green [c] => blue )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");
$result=array_intersect($a1,$a2,$a3);
print_r($result);
//Array ( [a] => red )

#array_intersect_assoc(array1,array2,array3...)      （比較鍵名和鍵值）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","g"=>"blue");
$a3=array("a"=>"red","b"=>"green","g"=>"blue");
$result=array_intersect_assoc($a1,$a2,$a3);
print_r($result);
//Array ( [a] => red [b] => green )

#array_intersect_key(array1,array2,array3...)      （只比較鍵名）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");
$result=array_intersect_key($a1,$a2,$a3);
print_r($result);
//Array ( [c] => blue )


#array_intersect_uassoc(array1,array2,array3...,myfunction)      （比較鍵名和鍵值，使用用戶自定義的鍵名比較函數）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","d"=>"blue");
$a3=array("e"=>"yellow","a"=>"red","d"=>"blue");
$result=array_intersect_uassoc($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [a] => red )

#array_intersect_ukey(array1,array2,array3...,myfunction)   （只比較鍵名，使用用戶自定義的鍵名比較函數）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"black","b"=>"yellow","d"=>"brown");
$a3=array("e"=>"purple","f"=>"white","a"=>"gold");
$result=array_intersect_ukey($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [a] => red )


#array_uintersect(array1,array2,array3...,myfunction)    （只比較值，使用一個用戶自定義的鍵名比較函數）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue","yellow");
$a2=array("A"=>"red","b"=>"GREEN","yellow","black");
$a3=array("a"=>"green","b"=>"red","yellow","black");
$result=array_uintersect($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [a] => red [0] => yellow )

#array_uintersect_assoc(array1,array2,array3...,myfunction)（比較鍵和值，使用內建函數比較鍵名，使用用戶自定義函數比較鍵值）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_uintersect_assoc($a1,$a2,"myfunction");
print_r($result);
//Array ( [a] => red )

#array_uintersect_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)（比較鍵和值，使用兩個用戶自定義的鍵名比較函數）。
function myfunction_key($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
function myfunction_value($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_uintersect_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result);
//Array ( [a] => red [b] => green )

數組排序

sort(array,sortingtype)    對索引數組進行升序排序。 本函數爲數組中的單元賦予新的鍵名。原有的鍵名將被刪除。

rsort(array,sortingtype)    對數值數組進行降序排序。該函數爲 array 中的單元賦予新的鍵名。這將刪除原有的鍵名而不只是從新排序。

asort(array,sortingtype)    對關聯數組按照鍵值進行升序排序。保持索引關係。（鍵，值沿用之前的）

arsort(array,sortingtype)    對關聯數組按照鍵值進行降序排序。保持索引關係。（鍵，值沿用之前的）

ksort(array,sortingtype)    對數組按照鍵名排序。爲數組值保留原來的鍵。（升序）

krsort(array,sortingtype)    對數組按照鍵名逆向排序。爲數組值保留原來的鍵。（降序）

natsort(array)    用「天然排序」算法對數組排序。（升序。鍵值保留它們原始的鍵名。）

natcasesort(array)    用「天然排序」算法對數組進行不區分大小寫字母的排序。（鍵值保留它們原始的鍵名。）

usort(array,myfunction)  經過用戶自定義的比較函數對數組進行排序。若是兩個元素比較結果相同，則它們在排序後的數組中的順序未經定義。到 PHP 4.0.6 以前，用戶自定義函數將保留這些元素的原有順序。可是因爲在 4.1.0 中引進了新的排序算法，結果將不是這樣了，由於對此沒有一個有效的解決方案。本函數爲 array 中的元素賦予新的鍵名。這會刪除原有的鍵名。

uasort(array,myfunction)   使用用戶自定義的比較函數對數組排序。保持索引關聯（不爲元素分配新的鍵）

uksort(array,myfunction)     使用用戶自定義的比較函數對數組中的鍵名進行排序。

array    必需。規定要進行排序的數組。

sortingtype    可選。規定如何排列數組的元素/項目。可能的值：

0=SORT_REGULAR - 默認。把每一項按常規順序排列（Standard ASCII，不改變類型）

1 = SORT_NUMERIC - 把每一項做爲數字來處理。

2 = SORT_STRING - 把每一項做爲字符串來處理。

3 = SORT_LOCALE_STRING - 把每一項做爲字符串來處理，基於當前區域設置（可經過 setlocale() 進行更改）。在 PHP 6 以前，使用了系統的區域設置，能夠用 setlocale() 來改變。自 PHP 6 起，必須用 i18n_loc_set_default() 函數。

4 = SORT_NATURAL - 把每一項做爲字符串來處理，使用相似 natsort() 的天然排序。

5 = SORT_FLAG_CASE - 能夠結合（按位或）SORT_STRING 或 SORT_NATURAL 對字符串進行排序，不區分大小寫。

myfunction    可選。定義可調用比較函數的字符串。若是第一個參數小於等於或大於第二個參數，那麼比較函數必須返回一個小於等於或大於 0 的整數。

若是成功則返回 TRUE，不然返回 FALSE。

天然排序，即數字從 1 到 9 的排序方法，字母從 a 到 z 的排序方法，短者優先。數組的索引與單元值保持關聯。

$cars=array("Volvo","BMW","Toyota");
sort($cars);
//BMW Toyota Volvo

$numbers=array(4,6,2,22,11);
rsort($numbers);
//22 11 6 4 2

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
arsort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=Bill, Value=60 Key=Steve, Value=56 Key=Mark, Value=31

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
asort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=Mark, Value=31 Key=Steve, Value=56 Key=Bill, Value=60

$age=array("Bill"=>"60","Steve"=>"56","mark"=>"31");
krsort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=mark, Value=31 Key=Steve, Value=56 Key=Bill, Value=60

$age=array("Bill"=>"60","Steve"=>"56","mark"=>"31");
ksort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=Bill, Value=60 Key=Steve, Value=56 Key=mark, Value=31

$temp_files = array("temp15.txt","temp10.txt","temp1.txt","temp22.txt","temp2.txt");
sort($temp_files);
echo "標準排序：";
print_r($temp_files);
echo "<br>";
natsort($temp_files);
echo "天然排序：";
print_r($temp_files);
//標準排序：Array ( [0] => temp1.txt [1] => temp10.txt [2] => temp15.txt [3] => temp2.txt [4] => temp22.txt ) 
//天然排序：Array ( [0] => temp1.txt [3] => temp2.txt [1] => temp10.txt [2] => temp15.txt [4] => temp22.txt )

$temp_files = array("temp15.txt","Temp10.txt",
"temp1.txt","Temp22.txt","temp2.txt");
natsort($temp_files);
echo "天然排序：";
print_r($temp_files);
echo "<br />";
natcasesort($temp_files);
echo "不區分大小寫的天然排序：";
print_r($temp_files);
//天然排序：Array([0] => Temp10.txt [1] => Temp22.txt [2] => temp1.txt [4] => temp2.txt [3] => temp15.txt)
//不區分大小寫的天然順序：Array([2] => temp1.txt [4] => temp2.txt [0] => Temp10.txt [3] => temp15.txt [1] => Temp22.txt)

function my_sort($a,$b)
{
if ($a==$b) return 0;
   return ($a<$b)?-1:1;
}
$a=array(4,2,8,6);
usort($a,"my_sort");
$arrlength=count($a);
for($x=0;$x<$arrlength;$x++)
   {
   echo $a[$x];
   echo "<br>";
   }
//2 4 6 8

function my_sort($a,$b)
{
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$arr=array("a"=>4,"b"=>2,"c"=>8,d=>"6");
uasort($arr,"my_sort");
foreach($arr as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=b, Value=2 Key=a, Value=4 Key=d, Value=6 Key=c, Value=8

function my_sort($a,$b)
{
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$arr=array("a"=>4,"b"=>2,"c"=>8,d=>"6");
uksort($arr,"my_sort");
foreach($arr as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=a, Value=4 Key=b, Value=2 Key=c, Value=8 Key=d, Value=6

數組指針移動

current(array)   返回數組中的當前元素的值。該函數不會移動數組內部指針。

pos(array)    current() 的別名。

each(array)   返回當前元素的鍵名和鍵值，並將內部指針向前移動。該元素的鍵名和鍵值會被返回帶有四個元素的數組中。兩個元素（1 和 Value）包含鍵值，兩個元素（0 和 Key）包含鍵名。

prev(array)    將內部指針指向數組中的上一個元素，並輸出。若是數組包含空的單元，或者單元的值是 0 則該函數碰到這些單元也返回 FALSE。要正確遍歷可能含有空單元或者單元值爲 0 的數組，請參見 each() 函數。

next(array)    將內部指針指向數組中的下一個元素，並輸出。若是移動指針的結果超出了數組單元的末端，則 next() 返回 FALSE。

reset(array)    將內部指針指向數組中的第一個元素，並輸出。

end(array)    將數組內部指針指向最後一個元素，並返回該元素的值（若是成功）。

array    必需。規定要進行排序的數組。

每一個數組中都有一個內部的指針指向它的"當前"元素，初始指向插入到數組中的第一個元素。

key(array)    返回數組內部指針當前指向元素的鍵名。該函數與 current() 相似，只是返回的結果不一樣。current() 函數返回的是元素的值，而 key() 函數返回的是元素的鍵名。   

$people = array("Bill", "Steve", "Mark", "David");
echo "鍵的當前位置是：" . key($people)
//鍵的當前位置是：0

$people = array("Bill", "Steve", "Mark", "David");
echo current($people) . "<br>"; // 當前元素是 Bill
echo next($people) . "<br>"; // Bill 的下一個元素是 Steve
echo current($people) . "<br>"; // 如今當前元素是 Steve
echo prev($people) . "<br>"; // Steve 的上一個元素是 Bill
echo end($people) . "<br>"; // 最後一個元素是 David
echo prev($people) . "<br>"; // David 以前的元素是 Mark
echo current($people) . "<br>"; // 目前的當前元素是 Mark
echo reset($people) . "<br>"; // 把內部指針移動到數組的首個元素，即 Bill
echo next($people) . "<br>"; // Bill 的下一個元素是 Steve
print_r (each($people)); // 返回當前元素的鍵名和鍵值（目前是 Steve），並向前移動內部指針
//Bill Steve Steve Bill David Mark Mark Bill Steve
//Array ( [1] => Steve [value] => Steve [0] => 1 [key] => 1 )