下面我們一起研究一下 php 語言中陣列的合併（這裡先不考慮遞回合併）
四種合併陣列的方式對比
四種常見的合併陣列的方式對比
寫程式碼
我們知道 array_merge() 和 運算子 + 都可以拼接陣列
建立一個類
ArrayMerge()
● eachOne() 迴圈體使用 array_merge() 合併
● eachTwo() 迴圈體結束後使用 array_merge() 合併
● eachThree() 迴圈體巢狀實現陣列合併
● eachFour() 迴圈體使用 運算子 + 拼接合併
● getNiceFileSize() 將記憶體占用轉化成人類可讀的方式
/**
* Class ArrayMerge
*/
class ArrayMerge
{
/**
* @param int $times
* @return array
*/
public static function eachOne(int $times): array
{
$a = [];
$b = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for ($i = 0; $i < $times; $i++) {
$a = array_merge($a, $b);
}
return $a;
}
/**
* @param int $times
* @return array
*/
public static function eachTwo(int $times): array
{
$a = [[]];
$b = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for ($i = 0; $i < $times; $i++) {
$a[] = $b;
}
return array_merge(...$a);
}
/**
* @param int $times
* @return array
*/
public static function eachThree(int $times): array
{
$a = [];
$b = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for ($i = 0; $i < $times; $i++) {
foreach ($b as $item) {
$a[] = $item;
}
}
return $a;
}
/**
* @param int $times
* @return array
*/
public static function eachFour(int $times): array
{
$a = [];
$b = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for ($i = 0; $i < $times; $i++) {
$a = $b + $a;
}
return $a;
}
/**
* 轉化記憶體資訊
* @param $bytes
* @param bool $binaryPrefix
* @return string
*/
public static function getNiceFileSize(int $bytes, $binaryPrefix = true): ?string
{
if ($binaryPrefix) {
$unit = array('B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB');
if ($bytes === 0) {
return '0 ' . $unit[0];
}
return @round($bytes / (1024 ** ($i = floor(log($bytes, 1024)))),
2) . ' ' . ($unit[(int)$i] ?? 'B');
}
$unit = array('B', 'KB', 'MB', 'GB', 'TB', 'PB');
if ($bytes === 0) {
return '0 ' . $unit[0];
}
return @round($bytes / (1000 ** ($i = floor(log($bytes, 1000)))),
2) . ' ' . ($unit[(int)$i] ?? 'B');
}
}使用
先分配多點記憶體
輸出記憶體占用，合併後的陣列長度，並記錄每一步的用時
ini_set('memory_limit', '4000M');
$timeOne = microtime(true);
$a = ArrayMerge::eachOne(10000);
echo 'count eachOne Result | ' . count($a) . PHP_EOL;
echo 'memory eachOne Result | ' . ArrayMerge::getNiceFileSize(memory_get_usage(true)) . PHP_EOL;
$timeTwo = microtime(true);
$b = ArrayMerge::eachTwo(10000);
echo 'count eachTwo Result | ' . count($b) . PHP_EOL;
echo 'memory eachTwo Result | ' . ArrayMerge::getNiceFileSize(memory_get_usage(true)) . PHP_EOL;
$timeThree = microtime(true);
$c = ArrayMerge::eachThree(10000);
echo 'count eachThree Result | ' . count($c) . PHP_EOL;
echo 'memory eachThree Result | ' . ArrayMerge::getNiceFileSize(memory_get_usage(true)) . PHP_EOL;
$timeFour = microtime(true);
$d = ArrayMerge::eachFour(10000);
echo 'count eachFour Result | ' . count($d) . PHP_EOL;
echo 'memory eachFour Result | ' . ArrayMerge::getNiceFileSize(memory_get_usage(true)) . PHP_EOL;
$timeFive = microtime(true);
echo PHP_EOL;
echo 'eachOne | ' . ($timeTwo - $timeOne) . PHP_EOL;
echo 'eachTwo | ' . ($timeThree - $timeTwo) . PHP_EOL;
echo 'eachThree | ' . ($timeFour - $timeThree) . PHP_EOL;
echo 'eachFour | ' . ($timeFive - $timeFour) . PHP_EOL;
echo PHP_EOL;結果
count eachOne Result | 100000 memory eachOne Result | 9 MiB count eachTwo Result | 100000 memory eachTwo Result | 14 MiB count eachThree Result | 100000 memory eachThree Result | 18 MiB count eachFour Result | 10 #注意這裡 memory eachFour Result | 18 MiB eachOne | 5.21253490448 # 迴圈體中使用array_merge()最慢，而且耗費記憶體 eachTwo | 0.0071840286254883 # 迴圈體結束後使用array_merge()最快 eachThree | 0.037622928619385 # 迴圈體巢狀比迴圈體結束後使用array_merge()慢三倍 eachFour | 0.0072360038757324 # 看似也很快，但是合併的結果有問題
● 迴圈體中使用 array_merge () 最慢，而且耗費記憶體
● 迴圈體結束後使用 array_merge () 最快
● 迴圈體巢狀比迴圈體結束後使用 array_merge () 慢三倍
● 看似也很快，但是合併的結果有問題
合併陣列的坑
我們注意到剛剛的 eachFour 的結果長度只有 10
下面探究為什麼會出現這樣的結果
這裡拿遞回合並一起做下對比
程式碼
public static function test(): void
{
$testA = [
'111' => 'testA1',
'abc' => 'testA1',
'222' => 'testA2',
];
$testB = [
'111' => 'testB1',
'abc' => 'testB1',
'222' => 'testB2',
'www' => 'testB1',
];
echo 'array_merge($testA, $testB) | ' . PHP_EOL;
print_r(array_merge($testA, $testB));
echo '$testA + $testB | ' . PHP_EOL;
print_r($testA + $testB);
echo '$testB + $testA | ' . PHP_EOL;
print_r($testB + $testA);
echo 'array_merge_recursive($testA, $testB) | ' . PHP_EOL;
print_r(array_merge_recursive($testA, $testB));
}結果
+ 號拼接兩個陣列，後者只會補充前者沒有的 key，但是會保留數位索引
array_merge() 和 array_merge_recursive() 會抹去數位索引，所有的數位索引按順序從 0 開始了
array_merge($testA, $testB) | #數位索引強制從0開始了 字元key相同的以後者為準
Array
(
[0] => testA1
[abc] => testB1
[1] => testA2
[2] => testB1
[3] => testB2
[www] => testB1
)
$testA + $testB | #testA得到保留，testB補充了testA中沒有的key，數位索引得到保留
Array
(
[111] => testA1
[abc] => testA1
[222] => testA2
[www] => testB1
)
$testB + $testA | #testB得到保留，testA補充了testB中沒有的key，數位索引得到保留
Array
(
[111] => testB1
[abc] => testB1
[222] => testB2
[www] => testB1
)array_merge_recursive($testA, $testB) | #數位索引從0開始連續了，但陣列的順序沒有被破壞，相同的字串 `key` 合併為一個陣列
Array
(
[0] => testA1
[abc] => Array
(
[0] => testA1
[1] => testB1
)
[1] => testA2
[2] => testB1
[3] => testB2
[www] => testB1
)分析
看到這裡，你一定非常疑惑，沒想到 array_merge() 還有這樣的坑
我們先來看一看官方的手冊
array_merge ( array $array1 [, array $... ] ) : array
array_merge () 將一個或多個陣列的單元合併起來，一個陣列中的值附加在前一個陣列的後面。返回作為結果的陣列。
如果輸入的陣列中有相同的字串鍵名，則該鍵名後面的值將覆蓋前一個值。然而，如果陣列包含數位鍵名，後面的值將不會覆蓋原來的值，而是附加到後面。
如果只給了一個陣列並且該陣列是數位索引的，則鍵名會以連續方式重新索引。
只有相同的字串鍵名，後邊的值才會覆蓋前面的值。（但是手冊中沒有解釋為什麼數位鍵名的索引被重置了）
那麼我們來看一下原始碼
PHPAPI int php_array_merge(HashTable *dest, HashTable *src)
{
zval *src_entry;
zend_string *string_key;
if ((dest->u.flags & HASH_FLAG_PACKED) && (src->u.flags & HASH_FLAG_PACKED)) {
// 自然陣列的合併，HASH_FLAG_PACKED表示陣列是自然陣列（[0,1,2]） 參考http://ju.outofmemory.cn/entry/197064
zend_hash_extend(dest, zend_hash_num_elements(dest) + zend_hash_num_elements(src), 1);
ZEND_HASH_FILL_PACKED(dest) {
ZEND_HASH_FOREACH_VAL(src, src_entry) {
if (UNEXPECTED(Z_ISREF_P(src_entry)) &&
UNEXPECTED(Z_REFCOUNT_P(src_entry) == 1)) {
ZVAL_UNREF(src_entry);
}
Z_TRY_ADDREF_P(src_entry);
ZEND_HASH_FILL_ADD(src_entry);
} ZEND_HASH_FOREACH_END();
} ZEND_HASH_FILL_END();
} else {
//遍歷獲取key和vaule
ZEND_HASH_FOREACH_STR_KEY_VAL(src, string_key, src_entry) {
if (UNEXPECTED(Z_ISREF_P(src_entry) &&
Z_REFCOUNT_P(src_entry) == 1)) {
ZVAL_UNREF(src_entry);
}
Z_TRY_ADDREF_P(src_entry);
// 參考https://github.com/pangudashu/php7-internal/blob/master/7/var.md
if (string_key) {
// 字串key（zend_string） 插入或者更新元素，會增加key的計數
zend_hash_update(dest, string_key, src_entry);
} else {
//插入新元素，使用自動的索引值(破案了，索引被重置的原因在此)
zend_hash_next_index_insert_new(dest, src_entry);
}
} ZEND_HASH_FOREACH_END();
}
return 1;
}總結
綜上所述，合併陣列的不同方式都存在一定的缺陷，但是通過我們上面的探究，我們了解到
● 迴圈體中使用 array_merge() 合併陣列不可取，速度差距達百倍
● array_merge() 合併陣列要慎用，如果重視 key ，且 key 可能為數位，不能使用 array_merge() 來合併，我們可以採用迴圈體巢狀的方式（注意內層迴圈使用 key 進行賦值操作）
● 如果重視 key ，且 key 可能為數位，簡單合併陣列可以使用運算子 + ，但是一定不要在迴圈體中使用，因為每次運算的的結果都是生成了一個新的陣列
以上就是不要在迴圈體中使用 array_merge ()的詳細內容，更多請關注TW511.COM其它相關文章！