[英]PHP array_merge that ignores key values that are not in the first/base array
[英]PHP array_merge() with preference of first array and unique values only?
我想将多个数组合并在一起,同时优先考虑第一个数组中的值,并且只有唯一值。 有没有比使用array_merge()
, array_unique()
和+
运算符更快的方法?
function foo(...$params) {
$a = [
'col1',
'col2_alias' => 'col2',
'col3'
];
$merged = array_merge($a, ...$params);
$unique = array_unique($merged);
print_r($merged);
print_r($unique);
print_r($a + $unique);
}
foo(
['col4', 'col5_alias' => 'col5', 'col6'],
['col7', 'col1', 'col5_alias' => 'col5', 'col2_alias' => 'col10']);
只是合并数组会给我重复的值,并覆盖第一个数组中的值:
Array
(
[0] => col1 // duplicate
[col2_alias] => col10 // overwritten
[1] => col3
[2] => col4
[col5_alias] => col5
[3] => col6
[4] => col7
[5] => col1 // duplicate
)
使用array_unique()
显然可以修复重复值,但不能修复覆盖的值:
Array
(
[0] => col1
[col2_alias] => col10
[1] => col3
[2] => col4
[col5_alias] => col5
[3] => col6
[4] => col7
)
使用+
运算符后,数组就是我想要的。
Array
(
[0] => col1
[col2_alias] => col2
[1] => col3
[2] => col4
[col5_alias] => col5
[3] => col6
[4] => col7
)
实际上我没有看到你的脚本有任何重大问题,我不知道你为什么要改进它。 但是我已经编写了我的函数实现,看起来它运行得快一点,看看(我还添加了一些参数来测试函数结果):
<?php
function foo(...$params) {
$a = [
'col1',
'col2_alias' => 'col2',
'col3'
];
$merged = array_merge($a, ...$params);
$unique = array_unique($merged);
return $a + $unique;
}
function foo2(...$params) {
$a = [
'col1',
'col2_alias' => 'col2',
'col3'
];
$merged = array_merge(array_diff(array_merge(...$params), $a), $a);
return $merged;
}
$timeFoo = microtime(true);
for($i = 0; $i < 1000000; $i++) {
foo(
['col13', 'col5_alias' => 'col3', 'col8'],
['col21', 'col5_alias' => 'col1', 'col9'],
['col4', 'col5_alias' => 'col5', 'col6'],
['col7', 'col1', 'col5_alias' => 'col5', 'col2_alias' => 'col10']);
}
$timeFoo = microtime(true) - $timeFoo;
$timeFoo2 = microtime(true);
for($i = 0; $i < 1000000; $i++) {
foo2(
['col13', 'col5_alias' => 'col3', 'col8'],
['col21', 'col5_alias' => 'col1', 'col9'],
['col4', 'col5_alias' => 'col5', 'col6'],
['col7', 'col1', 'col5_alias' => 'col5', 'col2_alias' => 'col10']);
}
$timeFoo2 = microtime(true) - $timeFoo2;
echo "'foo' time: $timeFoo \n";
echo "'foo2' time: $timeFoo2 \n";
结果不时有所不同,但不是很多:
'foo' time: 3.4310319423676
'foo2' time: 2.5314350128174
因此它为我们提供了近30%的性能提升。
你可以假设使用array_merge
, array_unique
函数和+
运算符会很慢。 我写了一些代码来测试每种组合的速度......
这是代码......
<?php
class ArraySpeeds
{
public $la = ['col1', 'col2_alias' => 'col2', 'col3'];
public $a = ['col4', 'col5_alias' => 'col5', 'col6'];
public $b = ['col7', 'col1', 'col5_alias' => 'col5', 'col2_alias' => 'col10'];
public $c = [];
public function executionTime ($callback)
{
$start = microtime (true);
for ($i = 0; $i < 1000000; $i++) {
$callback ();
}
return round ((microtime (true) - $start) * 1000) . '/ms' . PHP_EOL;
}
public function getTimes ()
{
$array_merge_time = $this->executionTime (function () {
$this->c[0] = array_merge ($this->la, $this->a, $this->b);
});
$array_unique_time = $this->executionTime (function () {
$merged = array_merge ($this->la, $this->a, $this->b);
$this->c[1] = array_unique ($merged);
});
$addition_time = $this->executionTime (function () {
$merged = array_merge ($this->la, $this->a, $this->b);
$unique = array_unique ($merged);
$this->c[2] = $this->la + $unique;
});
$array_diff_time = $this->executionTime (function () {
$merged = array_merge ($this->a, $this->b);
$diffed = array_diff ($merged, $this->la);
$this->c[3] = array_merge ($diffed, $this->la);
});
echo print_r ($this->c[0], true), PHP_EOL;
echo print_r ($this->c[1], true), PHP_EOL;
echo print_r ($this->c[2], true), PHP_EOL;
natsort ($this->c[3]);
echo print_r ($this->c[3], true), PHP_EOL;
echo 'array_merge: ', $array_merge_time;
echo 'array_unique: ', $array_unique_time;
echo 'addition: ', $addition_time;
echo 'array_diff: ', $array_diff_time;
}
}
$arrayspeeds = new ArraySpeeds ();
$arrayspeeds->getTimes ();
这是输出......
Array
(
[0] => col1
[col2_alias] => col10
[1] => col3
[2] => col4
[col5_alias] => col5
[3] => col6
[4] => col7
[5] => col1
)
Array
(
[0] => col1
[col2_alias] => col10
[1] => col3
[2] => col4
[col5_alias] => col5
[3] => col6
[4] => col7
)
Array
(
[0] => col1
[col2_alias] => col2
[1] => col3
[2] => col4
[col5_alias] => col5
[3] => col6
[4] => col7
)
Array
(
[3] => col1
[col2_alias] => col2
[4] => col3
[0] => col4
[col5_alias] => col5
[1] => col6
[2] => col7
)
array_merge: 403/ms
array_unique: 1039/ms
addition: 1267/ms
array_diff: 993/ms
您可以看到每次添加函数调用时执行时间变长, array_merge
, array_unique
函数和+
运算符最慢,速度超过两倍。
但是,使用array_diff
可以获得正确的输出,但没有正确的排序。 向数组添加natsort
函数调用可以解决这个问题。
例如...
function foo (...$params)
{
$a = [
'col1',
'col2_alias' => 'col2',
'col3'
];
$diff = array_diff (array_merge (...$params), $a);
$merged = array_merge ($diff, $a);
natsort ($merged);
print_r ($merged);
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.