PHP 開發工程師基礎篇 (PHP 陣列)

WytheHuang發表於2019-11-20

PHP 開發工程師基礎篇 - PHP陣列

陣列(Array)

陣列是 PHP 中最重要的資料型別, 可以說是掌握陣列, 基本上PHP一大半問題都可以解決. PHP 陣列與其他程式語言陣列概念不一樣. 其他程式語言陣列是由相同型別的元素（element）的集合所組成的資料結構, 而PHP 陣列元素可以為不同型別的元素. 因此說PHP陣列不是純粹的陣列, 而是雜湊(字典)更為恰當.
PHP陣列可以當作真正的陣列，或列表（向量），雜湊表（是對映的一種實現），字典，集合，棧，佇列以及更多可能性. 陣列分為關聯陣列(類似字典)和索引陣列(純陣列, 鍵值從數字開始, 一般從0開始).

語法

array
```
$arr = array(1, 2, 3);
```
[]
```
$arr = [1, 2, 3];
```
陣列鍵值注意事項

PHP 陣列的鍵值僅支援字串(string)和整型(integer). 其他型別均會轉換數字或字串. 浮點型別會被轉換為整型型別的, 8.7->8. 布林型別則會轉換為整型型別的, true->1, false->0. Null會被轉換為空的字串, 陣列和物件則不會轉換成為字串型別和整型.會丟擲一個警告: Illegal offset type.

注意的是字串型別假如是有效十進位制數字的話, 則會轉換為整型. "8"->8. 若不想轉換則在數字前新增"+"符號.

// 02不是有效十進位制數字
$arr = ['1' => 'a', '+1' => 'b', '02' => 'c'];
/**
 array(3) {
  [1]=>
  string(1) "a"
  ["+1"]=>
  string(1) "b"
  ["02"]=>
  string(1) "c"
}
 */
var_dump($arr);
// 陣列的鍵值可以不用有鍵值, 下面這個陣列最大數字是6,所以在它後面的元素,則是在它基礎上+1
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
/**
 array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}
 */
var_dump($array);

陣列基本操作(增刪改查)

通過在方括號([])內指定鍵名來給陣列賦值實現的增加和修改元素, 也可以省略鍵名.

增加陣列的元素

// 索引陣列
$arr = [1, 2, 3];
$arr[] = 4; // [1, 2, 3, 4]
// 關聯陣列
$arr1 = ['a' => 1, 'b' => 2];
$arr1['c'] = 3; // ['a' => 1, 'b' => 2, 'c' => 3]
// 混合陣列
$arr3 = ['a' => 1, 'b' => 2];
$arr3[1] = 3; // ['a' => 1, 'b' => 2, 1 => 3]

刪除陣列的元素

$arr = [1, 2, 3];
// 刪除陣列中值為3的, 注意的是陣列不會被重新索引(索引陣列)
unset($arr[2]);
$arr[] = 3;
/**
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[3]=>
int(3)
}
*/
var_dump($arr);

改變陣列的元素

$arr = [1, 2, 3];
$arr[0] = 'a';
var_dump($arr); ['a', 2, 3]

查詢陣列的元素

$arr = [1, 2, 3];
var_dump($arr[0]); // 1

其他型別轉換為陣列

除了物件(Object)轉換陣列外, 對於對於任意 integer，float，string，boolean 和 resource 型別, 如果將一個值轉換為陣列, 將得到一個僅有一個元素的陣列,其下標為0.
(array)$scalarValue 與 array($scalarValue) 一樣. 而物件(object)型別轉換為array. 其單元為該物件的屬性。鍵名將為成員變數名，不過有幾點例外：整數屬性不可訪問；私有變數前會加上類名作字首；保護變數前會加上一個 '*' 做字首。這些字首的前後都各有一個 NULL 字元。這會導致一些不可預知的行為：

class A {
    private $A; // This will become '\0A\0A'
}

class B extends A {
    private $A; // This will become '\0B\0A'
    protected $B // This will \0*\0A
    public $AA; // This will become 'AA'
}
// 會有兩個鍵名為 'AA'，不過其中一個實際上是 '\0A\0A'。
/**
 array(4) {
  ["BA"]=>
  NULL
  ["*B"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}
 */
var_dump((array) new B());

整數屬性

陣列函式分類

建立陣列

array_combine ( array $keys , array $values ) : array — 建立一個陣列，用一個陣列的值作為其鍵名，另一個陣列的值作為其值
```
$key = ['a', 'b', 'c'];
$value = [1, 2, 3];
print_r(array_combine($key, $value)); // ['a' => 1, 'b' => 2, 'c' => 3]
```

array_fill_keys ( array $keys , mixed $value ) : array — 使用指定的鍵和值填充陣列

$keys = ['red', 'blue', 'green'];
var_dump(array_fill_keys($keys, 1)); // ['red' => 1, 'blue' => 1, 'green' => 1]

array_fill ( int $start_index , int $num , mixed $value ) : array — 用給定的值填充陣列

var_dump(array_fill(0, 0, 1)); // []
var_dump(array_fill(1, 3, 'red')); // [1=>'red', 2=>'red', 3=>'red']

array — 新建一個陣列

// array() 是語言結構, 不是常規函式
$a = array(1, 2, 3);

compact ( mixed $varname1 [, mixed $... ] ) : array — 建立一個陣列，包括變數名和它們的值

$a = 'apple';
$b = 'banana';
$d = 'lemon';
$sweet = ['b', 'd'];
$result = compact('a', $sweet); // ['a' => 'apple', 'b' => 'banana', 'd' => 'lemon']

range ( mixed $start , mixed $end [, number $step = 1 ] ) : array — 根據範圍建立陣列，包含指定的元素

var_dump(range(1, 5)); // [1, 2, 3, 4, 5]
var_dump(range(0, 100, 10)); // [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

陣列分割

array_chunk ( array $array , int $size [, bool $preserve_keys = FALSE ] ) : array — 將一個陣列分割成多個

$a = ['a' => 1, 'B' => 2, 3 => 'c', 'A' => 4, 'b' => 6];
print_r(array_chunk($a, 2)); // [[1, 2], ['c', 4], [6]]
print_r(array_chunk($a, 2, true)); // [['a' => 1, 'B' => 2], [3 => 'c', 'A' => 4], ['b' => 6]]

array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = FALSE ]] ) : array — 從陣列中取出一段

$input = ['a', 'b', 'c', 'e', 'f'];
var_dump(array_slice($a, 2)); // ['c', 'e', 'f']
var_dump(array_slice($a, 2, 1)); // ['c']
var_dump(array_slice($a, -1, 1)); // ['f']
var_dump(array_slice($a, -1, 1, true)); [4 => 'f']
var_dump(array_slice($a, 0, 6)); // ['a', 'b', 'c', 'e', 'f']

陣列佇列或棧操作
- array_pop ( array &$array ) : mixed — 彈出陣列最後一個單元（出棧）
```
$arr1 = ['yellow', 'green', 'red']
var_dump(array_pop($arr1)); // 'yellow'
```
- array_push ( array &$array [, mixed $... ] ) : int — 將一個或多個單元壓入陣列的末尾（入棧）
```
var_dump(array_push([1, 2, 3], 4, 5)) // 2 
```
- array_shift ( array &$array ) : mixed — 將陣列開頭的單元移出陣列
```
$a ['php', 'c', 'python'];
var_dump(array_shift($a));// 'php'
```
- array_unshift ( array &$array [, mixed $... ] ) : int — 在陣列開頭插入一個或多個單元
```
$queue = ['orange', 'banana'];
var_dump(array_unshift($queue, 'apple')); // 3
var_dump($queue);
```

陣列數學運算

array_count_values( array $array ): array — 統計陣列中所有的值

print_r(array_count_value([1, 'hello', 1, 'hello', 'world'])) // [1=>2, 'hello' => 2, 'world' => 1]

array_product ( array $array ) : number — 計算陣列中所有值的乘積

$a = array(2, 4, 6, 8);
var_dump(array_product($a));// 384
var_dump(array_product([])); // 1

array_reduce ( array $array , callable $callback [, mixed $initial = NULL ] ) : mixed

function sum ($carry, $item) {
$carry += $item;
return $carry;
}
$a = [1, 2, 3, 4, 5];
var_dump(array_reduce($a, 'sum')); // 15
var_dump(array_reduce($a, 'sum', 10)); // 25

array_sum ( array $array ) : number — 對陣列中所有值求和
```
var_dump(array_sum([1, 2, 3])); // 6
var_dump(array_sum([])); // 0
```

陣列鍵值操作
- array_change_key_case ( array $array [, int $case = CASE_LOWER ] ) : array — 將陣列中的所有鍵名修改為全大寫或小寫
```
$a = ['a' => 1, 'B' => 2, 3 => 'c', 'A' => 4];
print_r(array_change_key_case($a)); // ['a' => 4, 'b' => 2, 3 => 'c']
print_r(array_change_key_case($a, CASE_UPPER)); // ['A' => 4, 'B' => 2, 3 => 'c']
```
- array_key_exists ( mixed $key , array $array ) : bool — 檢查陣列裡是否有指定的鍵名或索引
```
var_dump(array_key_exists('first', ['first' => 1, 'second' => 2])); // true
```
- array_key_first ( array $array ) : mixed — 獲取陣列第一個鍵值
```
// php >= 7.3.0
var_dump(array_key_first(['a' => 1, 'b' => 2])); // 'a'
```
- array_key_last ( array $array ) : mixed — 獲取陣列最後一個鍵值
```
// php >= 7.3.0
var_dump(array_key_last(['a' => 1, 'b' => 2])); // 'b'
```
- array_keys ( array $array , mixed $search_value [, bool $strict = FALSE ] ) : array | array_keys ( array $array ) : array — 返回陣列中部分的或所有的鍵名
```
$a = ['a' => 1, 'b' => 2, 'c' => 3];
var_dump(array_keys($a)); // ['a', 'b', 'c']
var_dump(array_keys($a, '1')); // 'a'
var_dump(array_keys($a, '1', true)); // []
```
- key_exists — 別名 array_key_exists

陣列元素操作

array_pad ( array $array , int $size , mixed $value ) : array — 以指定長度將一個值填充進陣列

$input = [12, 10, 9];
var_dump(array_pad($input, 5, 2)); // [12, 10, 9, 2, 2]
var_dump(array_pad($input, -5, 2)); // [2, 2, 12, 10, 9]
var_dump(array_pad($input, 4, [1])); // [12, 10, 9, [1]]

array_rand ( array $array [, int $num = 1 ] ) : mixed — 從陣列中隨機取出一個或多個單元
```
var_dump(array_rand([1, 2, 3], 2)); // [1, 3]
```

array_search ( mixed $needle , array $haystack [, bool $strict = FALSE ] ) : mixed — 在陣列中搜尋給定的值，如果成功則返回首個相應的鍵名

$a = [1, 'blue', 'red', 'php', 0];
var_dump(array_search('php', $a)); // 2
var_dump(array_search(false, $a)); // 3
var_dump(array_search(false, $a, true)); // false

array_values ( array $array ) : array — 返回陣列中所有的值
```
$a = ['a' => 1, 'b' => 2];
var_dump(array_value($a)); // [1, 2]
```

in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] ) : bool 檢查陣列中是否存在某個值

// 字串比較是大小寫敏感
$os = ['Mac', 'NT', 'Irix', 'Linux', 1];
var_dump(in_array('Linux', $os)); // true
var_dump(in_array('1', $os)); //true
var_dump(in_array('1a', $os)); //true
// 開啟嚴格型別比較
var_dump(in_array('1', $os, true)); // false

陣列交集與差集, 合併

array_diff_assoc ( array $array1 , array $array2 [, array $... ] ) : array — 帶索引檢查計算陣列的差集

$array1 = ["a" => "green", "b" => "brown", "c" => "blue", "red"];
$array2 = ["a" => "green", "yellow", "red"];
print_r(array_diff_assoc($array1, $array2)); // ["b" => "brown", "c" => "blue", 0 => "red"]

array_diff_key ( array $array1 , array $array2 [, array $... ] ) : array — 使用鍵名比較計算陣列的差集

$array1 = ['blue' => 1, 'red' => 2]; 
$array2 = ['green' => 2, 'blue' => 1];
print_r(array_diff_key($array1, $array2)); // ['red' => 2];

array_diff_uassoc ( array $array1 , array $array2 [, array $... ], callable $key_compare_func ) : array — 用使用者提供的回撥函式做索引檢查來計算陣列的差集

function key_compare_func($a, $b)
{
 if ($a === $b) {
     return 0;
 }
return ($a > $b)? 1:-1;
}
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_uassoc($array1, $array2, "key_compare_func");
print_r($result); // ["b" => "brown", "c" => "blue", "red"]

array_diff_ukey ( array $array1 , array $array2 [, array $... ], callable $key_compare_func ) : array — 用回撥函式對鍵名比較計算陣列的差集

function key_compare_func($key1, $key2)
{
 if ($key1 == $key2) {
     return 0;
 } else if ($key1 > $key2) {
     return 1;
 } else {
     return -1;
 }
}
$array1 = ['blue' => 1, 'red' => 2, 'green' => 3];
$array2 = ['green' => 5, 'blue' => 6, 'yellow' => 8];
var_dump(array_diff_ukey($array1, $array2, 'key_compare_func')); // ['red' => 2]

array_diff ( array $array1 , array $array2 [, array $... ] ) : array — 計算陣列的差集

$array1 = ['red', 'blue', 'green'];
$array2 = ['red', 'yellow', 'hello'];
$array3 = ['green', 'world'];
var_dump(array_diff($array1, $array2, $array3)); // ['blue']

array_intersect_assoc ( array $array1 , array $array2 [, array $... ] ) : array — 帶索引檢查計算陣列的交集

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "b" => "yellow", "blue", "red");
$result_array = array_intersect_assoc($array1, $array2);
print_r($result_array); // ['a' => 'green']

array_intersect_key ( array $array1 , array $array2 [, array $... ] ) : array — 使用鍵名比較計算陣列的交集

$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);
var_dump(array_intersect_key($array1, $array2)); // ['blue' => 1, 'green'=>3]

array_intersect_uassoc ( array $array1 , array $array2 [, array $... ], callable $key_compare_func ) : array
— 帶索引檢查計算陣列的交集，用回撥函式比較索引

$array1 = ["a" => "green", "b" => "brown", "c" => "blue", "red"];
$array2 = ["a" => "GREEN", "B" => "brown", "yellow", "red"];
var_dump(array_intersect_uassoc($array1, $array2, 'strcasecmp')); // ['b' => 'brown']

array_intersect_ukey ( array $array1 , array $array2 [, array $... ], callable $key_compare_func ) : array — 用回撥函式比較鍵名來計算陣列的交集

$array1 = ["a" => "green", "b" => "brown", "c" => "blue", "red"];
$array2 = ["a" => "GREEN", "B" => "brown", "yellow", "red"];
var_dump(array_intersect_ukey($array1, $array2, 'strcasecmp')); // ['a' => 'green', 'b' => 'brown', 'red']

array_intersect ( array $array1 , array $array2 [, array $... ] ) : array — 計算陣列的交集

$a = ['a' => 'green', 'red', 'blue'];
$b = ['b' => 'green', 'yellow', 'red'];
var_dump(array_intersect($a, $b)); // ['a' => 'green', 'red']

array_merge_recursive ([ array $... ] ) : array — 遞迴地合併一個或多個陣列

$arr1 = ['color' => ['favorite' => 'red', 5]];
$arr2 = ['color' => ['favorite' => 'green', 6, 7]];
var_dump(array_merge_recursive($arr1, $arr2)); // ['color' => ['favorite' => ['red', 'green'], 5, 6, 7]]

array_merge ( array $array1 [, array $... ] ) : array — 合併一個或多個陣列

$arr1 = ['color' => ['favorite' => 'red', 5]];
$arr2 = ['color' => ['favorite' => 'green', 6, 7]];
var_dump(array_merge($arr1, $arr2)); // ['color' => ['favorite' => 'green', 6, 7]];
var_dump($arr1 + $arr2); // ['color' => ['favorite' => 'red', 5]]

array_udiff_assoc ( array $array1 , array $array2 [, array $... ], callable $value_compare_func ) : array — 帶索引檢查計算陣列的差集，用回撥函式比較資料

// https://segmentfault.com/q/1010000000364758/a-1020000000364791 array_udiff_assoc 和 array_diff_uassoc 區別
/**
* https://www.reddit.com/r/PHP/comments/1ncqc0/real_difference_between_array_udiff_assoc_and/
*/
$item1 = [ 1 => "a", "b", "c"];
$item2 = [-1 => 'a', -2 => 'b', -3 => 'c'];
$item3 = [1 => ['a'], ['b'], ['c']];
function compareKey($a, $b) {
  if(abs($a) == abs($b)) return 0;
  return (abs($a) > abs($b)) ? 1 : -1;
}
function compareValue($a, $b) {
 $tempA = is_array($a) ? $a[0] : $a;
$tempB = is_array($b) ? $b[0] : $b;
if($tempA == $tempB) return 0;
return ($tempA > $tempB) ? 1 : -1;
}
print_r(array_diff_uassoc($item1, $item2, 'compareKey')); // []
print_r(array_udiff_assoc($item1, $item2, 'compareKey')); // ['a', 'b', 'c']
print_r(array_diff_uassoc($item1, $item3, 'compareValue')); // ['a', 'b', 'c']
print_r(array_udiff_assoc($item1, $item3, 'compareValue')); // []

array_udiff_uassoc ( array $array1 , array $array2 [, array $... ], callable $value_compare_func , callable $key_compare_func ) : array — 帶索引檢查計算陣列的差集，用回撥函式比較資料和索引

$a = ['0.1' => 9, '0.5' => 12, 0 => 23, 1 => 4, 2 => -15];
$b = ['0.2' => 9, '0.5' => 22, 0 => 3, 1 => 4, 2 => -15];
function compareKey($a, $b) {
 if ($a === $b) return 0;
 return $a > $b ? 1 : -1;
}
function compareValue($a, $b) {
 if ($a === $b) return 0;
 return $a > $b ? 1 : -1;
}
print_r(array_udiff_uassoc($a, $b, 'compareValue', 'compareKey')); // ["0.1" => 9, "0.5" => 12, 0 => 23]

array_udiff ( array $array1 , array $array2 [, array $... ], callable $value_compare_func ) : array — 用回撥函式比較資料來計算陣列的差集

$a = [[1, 2], [7, 1], [2, 9]];
$b = [[1, 3], [8, 1], [2, 9]];
function compare($a, $b) {
 $areaA = $a[0] * $a[1];
 $areaB = $b[0] * $b[1];
 if ($areaA == $areaB) return 0;
 return $areaA > $areaB ? 1 : -1;
}
print_r(array_udiff($a, $b, 'compare')); // [[1, 2], [7, 1]]

array_uintersect_assoc ( array $array1 , array $array2 [, array $... ], callable $value_compare_func ) : array — 帶索引檢查計算陣列的交集，用回撥函式比較資料

$a = ['a' => 'green', 'b' => 'brown', 'c' => 'blue', 'red'];
$b = ['a' => 'GREEN', 'B' => 'brown', 'yellow', 'red'];
print_r(array_uintersect_assoc($a, $b, 'strcasecmp')); // ['a' => 'green']

array_uintersect_uassoc ( array $array1 , array $array2 [, array $... ], callable $value_compare_func , callable $key_compare_func ) : array — 帶索引檢查計算陣列的交集，用單獨的回撥函式比較資料和索引

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
print_r(array_uintersect_uassoc($array1, $array2, "strcasecmp", "strcasecmp")); // ['a' => 'green', 'b' => 'brown']

array_uintersect ( array $array1 , array $array2 [, array $... ], callable $value_compare_func ) : array — 計算陣列的交集，用回撥函式比較資料

$a = [[1, 2], [7, 1], [2, 9]];
$b = [[1, 3], [8, 1], [2, 9]];
function compare($a, $b) {
 $areaA = $a[0] * $a[1];
 $areaB = $b[0] * $b[1];
 if ($areaA == $areaB) return 0;
 return $areaA > $areaB ? 1 : -1;
}
print_r(array_uintersect($a, $b, 'compare')); // [[2, 9]]

陣列排序

array_multisort ( array &$array1 [, mixed $array1_sort_order = SORT_ASC [, mixed $array1_sort_flags = SORT_REGULAR [, mixed $... ]]] ) : bool — 對多個陣列或多維陣列進行排序

// 更多用法請看 https://www.php.net/manual/en/function.array-multisort.php
$ar1 = [10, 100, 100, 0];
$ar2 = [1, 3, 2, 4];
// $ar1 = [0, 10, 100, 100];
// $ar2 = [4, 1, 2, 3];
array_multisort($ar1, $ar2); 
// $ar1 = [100, 100, 10, 0];
// $ar2 = [2, 3, 1, 4];
array_multisort($ar1, SORT_DESC, SORT_NUMERIC, $ar2, SORT_ASC, SORT_NUMERIC); //

arsort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool — 對陣列進行逆向排序並保持索引關係

// 排序針對的是值, 而且會儲存原先索引
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
arsort($fruits);
print_r($fruits); // ['a' => 'orange', 'd' => 'lemon', 'b' => 'banana', 'c' => 'apple'];

asort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool — 對陣列進行排序並保持索引關係

$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
asort($fruits);
print_r($fruits); // ['c' => 'apple', 'b' => 'banana', 'd' => 'lemon', 'a' => 'orange'];

krsort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool — 對陣列按照鍵名逆向排序

$fruits = ['d' => 'lemon', 'a' => 'orange', 'b' => 'banana', 'c' => 'apple'];
krsort($fruits);//true
var_dump($fruits); // ['d' => 'lemon', 'c' => 'apple', 'b' => 'banana', 'a' => 'orange']

ksort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool — 對陣列按照鍵名排序

$fruits = ['d' => 'lemon', 'a' => 'orange', 'b' => 'banana', 'c' => 'apple'];
ksort($fruits);//true
var_dump($fruits); // ['a' => 'orange', 'b' => 'banana', 'c' => 'apple', 'd' => 'lemon']

rsort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool — 對陣列逆向排序

$fruits = array("lemon", "orange", "banana", "apple");
rsort($fruits); // true
var_dump($fruits); // ['orange', 'lemon', 'banana', 'apple']

sort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool — 對陣列排序

// https://bettercuicui.github.io/2018/04/01/PHP/php%20sort%E6%8E%92%E5%BA%8F%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86/
$fruits = array("lemon", "orange", "banana", "apple", 1);
sort($fruits);
var_dump($fruits); // ['apple', 'banana', 'lemon', 'orange', 1]
// 數字比較專案, 'a1' 轉換數字為 0, 所以排序順序如下
$arr1 = ['a1', 0, 2, '1a'];
sort($arr1, SORT_NUMERIC);
var_dump($arr1);  // ['a1', 0, '1a', 2]
// 被作為字串來比較
$fruits = array("lemon", "orange", "banana", "apple", 1);
sort($fruits, SORT_STRING);
var_dump($fruits); // [1, 'apple', 'banana', 'lemon', 'orange']
// 根據當前的區域（locale）設定來把單元當作字串比較，可以用 setlocale() 來改變
$fruits = array("lemon", "orange", "banana", "apple", 1);
sort($fruits, SORT_LOCALE_STRING);
var_dump($fruits); // [1, 'apple', 'banana', 'lemon', 'orange']
//  和 natsort() 類似對每個單元以“自然的順序”對字串進行排序
$arr = ['a1', 'A1', 'c2', 'c3', 'b4', 'b5', 'B1'];
sort($arr, SORT_NATURAL);  // true
var_dump($arr); // ['A1', 'B1', 'a1', 'b4', 'b5', 'c2', 'c3']
// 能夠與 SORT_STRING 或 SORT_NATURAL 合併（OR 位運算），不區分大小寫排序字串。
$fruits = array("lemon", "orange", "banana", "apple", "Apple", 1);
sort($fruits, SORT_FLAG_CASE|SORT_STRING);
var_dump($fruits); // [1, "apple", "Apple", "banana", "lemon", "orange"]

uasort ( array &$array , callable $value_compare_func ) : bool — 使用使用者自定義的比較函式對陣列中的值進行排序並保持索引關聯

// 使用者自定義值比較函式, 保持索引不變
function compare($a, $b) {
 if ($a === $b) {
     return 0;
 }
 return ($a < $b)  ? -1 : 1;
}
$arr = ['a' => 3, 'b' => 9, 'c' => 4, 'd' => 8, 'e' => -1];
uasort($arr, 'compare'); // true
var_dump($arr); // ['e' => -1, 'a' => 3, 'c' => 4, 'd' => 8, 'b' => 9]

uksort ( array &$array , callable $key_compare_func ) : bool — 使用使用者自定義的比較函式對陣列中的鍵名進行排序

// 使用者自定義值比較函式, 保持索引不變
function keyCompare($a, $b) {
 if ($a === $b) {
     return 0;
 }
 return ($a > $b)  ? -1 : 1;
}
$arr = ['a' => 3, 'b' => 9, 'c' => 4, 'e' => 8, 'd' => -1];
uksort($arr, 'keyCompare'); // true
var_dump($arr); // ['a' => 3, 'b' => 9, 'c' => 4, 'd' => -1, 'e' => 8]

usort ( array &$array , callable $value_compare_func ) : bool — 使用使用者自定義的比較函式對陣列中的值進行排序

// 對多維陣列排序時，$ a和$ b包含對陣列第一個索引的引用。
function cmp($a, $b)
{
return strcmp($a["fruit"], $b["fruit"]);
}
$fruits = [['fruit' => 'lemons'], ['fruit' => 'apples'], ['fruit' => 'grapes']];
usort($fruits, "cmp");
var_dump($fruits); // [['fruit' => 'apples'], ['fruit' => 'grapes'], ['fruit' => 'lemons']]

natcasesort ( array &$array ) : bool — 用“自然排序”演算法對陣列進行不區分大小寫字母的排序

// 自然排序, 以人們認知方式排序,不區分大小寫
$arr = ['a1', 'A1', 'c2', 'c3', 'b4', 'b5', 'B1'];
natcasesort($arr);  // true
var_dump($arr); // ['a1', 'A1', 'B1', 'b4', 'b5', 'c2', 'c3']

natsort ( array &$array ) : bool — 用“自然排序”演算法對陣列排序

// 自然排序, 以人們認知方式排序,區分大小寫
$arr = ['a1', 'A1', 'c2', 'c3', 'b4', 'b5', 'B1'];
natsort($arr);  // true
var_dump($arr); // ['A1', 'B1', 'a1', 'b4', 'b5', 'c2', 'c3']

回撥函式處理陣列

array_filter ( array $array [, callable $callback [, int $flag = 0 ]] ) : array — 用回撥函式過濾陣列中的單元

// 若沒有回撥函式, 則篩選值為false
$a = [1, 0, 'false', 'null', '0', 2, '', false];
var_dump(array_filter($a)); // [1, "false", "null", 2]
$b = [6, 7, 8, 9, 10, 11, 12];
function odd($var)
{
  return $var & 1;
}
var_dump(array_filter($b, 'odd')); // [7, 9, 11]

array_map ( callable $callback , array $array1 [, array $... ] ) : array — 為陣列的每個元素應用回撥函式

print_r(array_map('strtoupper', ['a', 'b', 'c'])); // ['A', 'B', 'C']
function demo($n, $m) {
  return strtoupper($n) . '-' . strtoupper($m);
}
print_r(array_map('demo', ['a', 'b', 'c'], ['d', 'e', 'f'])); // ['A-D', 'B-E', 'C-F']

array_walk_recursive ( array &$array , callable $callback [, mixed $userdata = NULL ] ) : bool — 對陣列中的每個成員遞迴地應用使用者函式

$sweet = ['a' => 'apple', 'b' => 'banana'];
$fruits = ['sweet' => $sweet, 'sour' => 'lemon'];
function testPrint($item, $key) {
  echo "$key holds $item\n";
}
/**
* a holds apple
* b holds banana
* sour holds lemon
*/
array_walk_recursive($fruits, 'testPrint');
function testPrint2($item, $key, $userData) {
  $item = strtoupper($item);
  echo "$key holds $item and $userData\n";
}
/**
* a holds apple and php
* b holds banana and php
* sour holds lemon and php
*/
array_walk_recursive($fruits, 'testPrint2', 'php');

array_walk ( array &$array , callable $callback [, mixed $userdata = NULL ] ) : bool — 使用使用者自定義函式對陣列中的每個元素做回撥處理

$sweet = ['a' => 'apple', 'b' => 'banana'];
function testPrint($item, $key) {
  echo "$key holds $item\n";
}
/**
* a holds apple
* b holds banana
*/
array_walk($sweet, 'testPrint');
function testPrint2($item, $key, $userData) {
  echo "$key holds $item and $userData\n";
}
/**
* a holds apple and php
* b holds banana and php
* sour holds lemon and php
*/
array_walk_recursive($sweet, 'testPrint2', 'php');

陣列替換

array_replace_recursive ( array $array1 [, array $... ] ) : array — 使用傳遞的陣列遞迴替換第一個陣列的元素

$base = ['citrus' => ['orange'], 'berries' => ['blackberry', 'raspberry']];
$replacements = ['citrus' => ['pineapple'], 'berries' => ['blueberry']];
var_dump(array_replace_recursive($base, $replacements));// ['citrus' => ['pineapple'], 'berries' => ['blueberry', 'raspberry']]

array_replace ( array $array1 [, array $... ] ) : array — 使用傳遞的陣列替換第一個陣列的元素

$base = ['citrus' => ['orange'], 'berries' => ['blackberry', 'raspberry']];
$replacements = ['citrus' => ['pineapple'], 'berries' => ['blueberry']];
var_dump(array_replace($base, $replacements));// ['citrus' => ['pineapple'], 'berries' => ['blueberry']]

array_splice ( array & $input , int $offset [, int $length = count($input) [, mixed $replacement = array() ]] ) : array — 去掉陣列中的某一部分並用其它值取代

$a = ['a', 'b', 'c'];
array_splice($a, 1, 2, ['B', 'C']);
var_dump($a); // ['a', 'B', 'C']
array_splice($a, -2, 2, ['b', 'c']); 
var_dump($a);// ['a', 'b', 'c']
array_splice($a, 3, 0, ['d', 'e']);
var_dump($a); // ['a', 'b', 'c', 'd', 'e']

陣列指標操作
- current ( array $array ) : mixed — 返回陣列中的當前單元
```
$a = [1, 2, 3];
var_dump(current($a)); // 1
```
- end ( array &$array ) : mixed — 將陣列的內部指標指向最後一個單元
```
$a = [1, 2, 3];
var_dump(end($a)); // 3
```
- key ( array $array ) : mixed — 從關聯陣列中取得鍵名
```
$arr = ['color' => 'red'];
var_dump(key($arr)); // color
```
- next ( array &$array ) : mixed — 將陣列中的內部指標向前移動一位
```
$arr = [1, 2, 3];
var_dump(next($arr)); // 2
```
- pos — current 的別名
- prev ( array &$array ) : mixed — 將陣列的內部指標倒回一位
```
$arr = [1, 2, 3];
next($arr); // 2
var_dump(prev($arr)); // 1
```
- reset ( array &$array ) : mixed — 將陣列的內部指標指向第一個單元
```
$arr = [1, 2, 3];
next($arr); // 2
next($arr); // 3
var_dump(reset($arr)); // 1
```

其他

array_column ( array $input , mixed $column_key [, mixed $index_key = NULL ] ) : array — 返回陣列中指定的一列

$a = [['id' => 1, 'first_name' => 'John', 'last_name' => 'Doe'], ['id' => 2, 'first_name' => 'Wythe', 'last_name' => 'Huang']];
print_r(array_column($a, 'first_name')); // ['John', 'Wythe']
print_r(array_column($a, 'first_name', 'id')); // [1=> 'John', 2 => 'Wythe']

array_flip ( array $array ) : array — 交換陣列中的鍵和值

$a = ['a' => 1, 'b' => 2, 'c' => 3];
var_dump(array_flip($a)); // [1 => 'a', 2 => 'b', 3 => 'c']

array_reverse ( array $array [, bool $preserve_keys = FALSE ] ) : array — 返回單元順序相反的陣列

$a = ['php', 4.0, ['green', 'red']];
var_dump(array_reverse($a)); // [['green', 'red'], 4, 'php']
var_dump(array_reverse($a, true)); // [2 => ['green', 'red'], 1 => 4, 0 => 'php']

array_unique ( array $array [, int $sort_flags = SORT_STRING ] ) : array — 移除陣列中重複的值

$a = ['4', 1, 4, '1', 2];
var_dump(array_unique($a)); // [0 => '4', 1 => 1, 4 => 2]
var_dump(array_unique($a, SORT_NUMERIC));// [0 => '4', 1 => 1, 4 => 2]

count ( mixed $array_or_countable [, int $mode = COUNT_NORMAL ] ) : int — 計算陣列中的單元數目，或物件中的屬性個數
```
$a = [1, 2, 3];
echo count($a); // 3
$b = [$a, 4, 5, 6];
echo count($b, COUNT_RECURSIVE) // 7
```

extract ( array &$array [, int $flags = EXTR_OVERWRITE [, string $prefix = NULL ]] ) : int — 從陣列中將變數匯入到當前的符號表

$size = 1;
$varArray = ['color' => 'blue', 'size' => 2, 'shape' => 'sphere'];

var_dump(extract($varArray)); // 3 若存在, 則覆蓋
echo "$color, $size, $shape\n"; // blue, 2, sphere

extract($varArray, EXTR_SKIP); // 若存在, 則不覆蓋
echo "$color, $size, $shape\n"; // blue, 1, sphere

extract($varArray, EXTR_PREFIX_SAME, 'prefix'); // 若存在, 則在變數名使用字首
echo "$color, $size, $shape, $prefix_size\n"; // blue, 1, sphere, 2

extract($varArray, EXTR_PREFIX_ALL, 'prefix'); // 若存在, 則在變數名使用字首
echo "$prefix_color, $size, $prefix_shape, $prefix_size\n"; // blue, 1, sphere, 2

var_dump(extract($varArray, EXTR_IF_EXISTS)); // 1 若存在, 則只覆蓋已有變數
/**
* Notice: Undefined variable: color
* Notice: Undefined variable: shape
*/
echo "$color, $size, $shape\n"; // , 2, 

extract($varArray, EXTR_PREFIX_IF_EXISTS, 'prefix'); // 僅噹噹前符號表中存在相同變數的非字首版本時，才建立帶字首的變數名稱。
/**
* Notice: Undefined variable: color
* Notice: Undefined variable: shape
*/
echo "$color, $size, $shape, $prefix_size\n"; // , 1, , 2

var_dump(extract($varArray, EXTR_REFS)); // 3 變數作為引用。這實際上意味著匯入的變數的值仍在引用陣列引數的值, 可以與其他引數結合
echo "$color, $size, $shape\n"; // blue, 2, sphere
$color = 'red';
var_dump($varArray); // ['color' => 'red', 'size' => 2, 'shape' => 'sphere'];

// 變數作為引用。這實際上意味著匯入的變數的值仍在引用陣列引數的值, 可以與其他引數結合, 若解析變數字首的, 則修改字首變數, 陣列變數則修改.
$size = 1;
$varArray = ['color' => 'blue', 'size' => 2, 'shape' => 'sphere'];
var_dump(extract($varArray, EXTR_REFS|EXTR_PREFIX_SAME, 'prefix')); // 3
echo "$color, $size, $shape, $prefix_size\n"; // blue, 1, sphere, 2
$color = 'red';
$prefix_size = 4;
var_dump($size); // 1
var_dump($varArray); // ['color' => 'red', 'size' => 4, 'shape' => 'sphere'];

$a = [1, 2, 3];
extract($a, EXTR_PREFIX_INVALID, 'prefix');
echo "$prefix_0, $prefix_1, $prefix_2\n"; // 1, 2, 3

list ( mixed $var1 [, mixed $... ] ) : array — 把陣列中的值賦給一組變數

// 語言結構, 並非函式
$info = ['coffee', 'brown', 'caffeine'];
list($drink, $color, $power) = $info;
echo "$drink, $color, $power"; // coffee, brown, caffeine
// 可以省略不想取的
list($drink, , $power) = $info;
echo "$drink, $power"; // coffee, caffeine
// 7.0 以上是從左到右賦值, 7.0以下是從右到左賦值
list($a[0], $a[1], $a[2]) = $info;
// 7.0 以上
var_dump($a); // ['coffee', 'brown', 'caffeine']
// 7.0 以下
var_dump($a); // ['caffeine', 'brown', 'coffee']
// 7.1 支援索引陣列
$info = ['a' => 'coffee', 'b' => 'brown', 'c' => 'caffeine'];
list('a' => $drink, 'c' => $power) = $info;
echo "$drink, $power"; // coffee, caffeine

shuffle ( array &$array ) : bool — 打亂陣列

$arr = [1, 2, 3, 4];
shuffle($arr); // 洗牌演算法, 打亂陣列

sizeof 等同於 count

本作品採用《CC 協議》，轉載必須註明作者和本文連結

PHP 開發工程師基礎篇 - PHP 字串
2020-08-11
PHP工程師字串
PHP 開發基礎
2021-03-22
PHP
PHP 系列：PHP Web 開發基礎
2016-01-16
PHPWeb
PHP常見陣列函式與例項[基礎]]
2021-03-19
PHP陣列函式
Php陣列
2017-11-01
PHP陣列
PHP專題-PHP陣列
2021-07-13
PHP陣列
***PHP陣列排序+php二維陣列排序方法（PHP比較器）
2016-06-05
PHP陣列排序
PHP 陣列系列
2019-03-21
PHP陣列
php 清空陣列
2021-09-09
PHP陣列
php陣列方法
2016-06-10
PHP陣列
PHP開發之自定義函式及陣列
2015-03-17
PHP函式陣列
PHP:常用PHP陣列操作函式
2021-07-13
PHP陣列函式
PHP基礎之物件導向篇
2020-09-19
PHP物件
php陣列問題
2019-02-16
PHP陣列
PHP 陣列合並
2018-10-07
PHP陣列
PHP基礎教程-04 開發環境搭建
2017-07-28
PHP開發環境
PHP陣列轉換為js陣列
2019-02-16
PHP陣列JS
javaScript學習基礎篇(1)(陣列)
2016-06-25
JavaScript陣列
PHP 基礎
2019-09-21
PHP
php手冊 php陣列的遍歷有哪幾種方式？php陣列如何遍歷？
2021-04-16
PHP陣列
PHP DIY 系列------基礎篇：3. 反射
2020-02-18
PHP反射
PHP 核心特性 - 生成器基礎篇
2019-11-13
PHP
W3C之PHP基礎篇
2013-11-02
PHP
PHP 陣列搜尋 sdk & 陣列分頁
2020-02-04
PHP陣列
PHP xml 轉陣列陣列轉 xml 操作
2020-06-02
PHPXML陣列
PHP二維陣列轉一維陣列
2017-11-07
PHP陣列
PHP 陣列常用函式
2020-07-01
PHP陣列函式
PHP入門之陣列
2020-08-06
PHP陣列
PHP 陣列 & 字串處理
2019-04-03
PHP陣列字串
php 二維陣列排序
2019-02-16
PHP陣列排序
巧用 PHP 陣列函式
2018-08-06
PHP陣列函式
PHP 陣列函式妙用
2018-10-31
PHP陣列函式
PHP學習3——陣列
2018-08-05
PHP陣列
php url傳遞陣列
2020-12-27
PHP陣列
PHP 陣列使用之道
2018-07-09
PHP陣列
[php]陣列建立方式
2014-12-08
PHP陣列
PHP基礎教程-01 PHP概述
2017-07-25
PHP
JS基礎入門篇（十）— 陣列方法
2018-05-22
JS陣列

PHP 開發工程師基礎篇 (PHP 陣列)