1

我有以下 PHP stdclass 对象数组（实际上我的有数百个索引，但目标是相同的）并且我无法找到最有效的方法来使用 PHP 以编程方式确定哪个 stdclass 对象最常出现在数组中。

例如，如果索引 0 处的标准类对象最常出现（显然它没有出现），那么我想回显 "1 , 1024" 或类似的东西。

大批
(
    [0] => 标准类对象
        (
            [一] => 1
            [b] => 1024
        )

    [1] => 标准类对象
        (
            [a] => 4
            [b] => 4096
        )

    [2] => 标准类对象
        (
            [a] => 4
            [b] => 4096
        )

    [3] => 标准类对象
        (
            [a] => 4
            [b] => 4096
        )

    [4] => 标准类对象
        (
            [a] => 4
            [b] => 4096
        )

    [5] => 标准类对象
        (
            [a] => 4
            [b] => 4096
        )

    [6] => 标准类对象
        (
            [a] => 4
            [b] => 4096
        )

    [7] => 标准类对象
        (
            [a] => 4
            [b] => 6144
        )

    [8] => 标准类对象
        (
            [a] => 4
            [b] => 6144
        )

    [9] => 标准类对象
        (
            [一] => 8
            [b] => 6144
        )

    [10] => 标准类对象
        (
            [一] => 8
            [b] => 6144
        )

    [11] => 标准类对象
        (
            [一] => 8
            [b] => 8192
        )

    [12] => 标准类对象
        (
            [一] => 8
            [b] => 8192
        )

    [13] => 标准类对象
        (
            [一] => 8
            [b] => 8192
        )

    [14] => 标准类对象
        (
            [一] => 8
            [b] => 8192
        )
)

谢谢！

4

4 回答 4

0

搜索所有寄存器，将出现的 [a] 存储在数组/映射中并按计数排序？

于 2013-04-30T22:08:01.437 回答
0

我认为你需要这样的东西吗？我认为这相当快。如果您需要检查同一对象或类似对象的实例，您可以使用 spl_object_hash 函数生成键，而不是像我一样连接值。

$foo = (object)['a' => 0, 'b' => 1024];
$bar = (object)['a' => 4, 'b' => 4096];
$qux = (object)['a' => 8, 'b' => 6144];

$array = [];
foreach(range(1, 1024) as $i) $array[] = $foo;
foreach(range(1, 4096) as $i) $array[] = $bar;
foreach(range(1, 6144) as $i) $array[] = $qux;

$result = [];
array_walk($array, function($obj) use (&$result) {
    $key = implode('|', get_object_vars($obj));
    if ( isset($result[$key]) ) $result[$key]++;
    else $result[$key] = 1;
});

arsort($result);
print_r($result);

回报：

Array
(
    [8|6144] => 6144
    [4|4096] => 4096
    [0|1024] => 1024
)

问候。

于 2013-04-30T22:10:26.920 回答
0

事实证明，==操作员会告诉你对象是否相等。因此，您可以循环遍历数组中的每个项目，并构建另一个数组来跟踪每个值出现的频率。然后您需要按计数对结果数组进行排序，这样您就知道哪个对象最常出现。

$orig = array(
    (object)array('a'=>3, 'b'=>'4096'),
    (object)array('a'=>2, 'b'=>'2048'),
    (object)array('a'=>2, 'b'=>'2048'),
    (object)array('a'=>1, 'b'=>'1024'),
    (object)array('a'=>1, 'b'=>'1024'),
    (object)array('a'=>2, 'b'=>'2048'),
    (object)array('a'=>1, 'b'=>'1024'),
    (object)array('a'=>2, 'b'=>'2048'),
);

$countArray = array();

foreach($orig as $obj) {
    $didCount = false;
    foreach($countArray as $counted) {
        if ($counted->value == $obj) {
            $counted->count++;
            // if we found a match, record that fact and 
            // break out of this loop early.
            $didCount = true;
            break;
        }
    }

    // If no match was found, then this is the first time 
    // we've seen this particular value
    if (!$didCount)
        $countArray[] = (object)array(
            'count' => 1,
            'value' => $obj,
        );
}

// To find the most frequent item, best way is to 
// sort $countArray by count.
usort($countArray, function($left, $right) {
    return $right->count - $left->count ;
});

print_r($countArray[0]);
于 2013-04-30T23:13:33.723 回答
0

虽然我没有选择任何一个答案，但具体来说，它们都非常有助于帮助我提出这个解决方案。

$x = array();
$count = 0;

for ($i = 0; $i < count($myArray); $i++) {
    if ($myArray[$i]->a != $myArray[$i - 1]->a 
        && $myArray[$i]->b != $myArray[$i - 1]->b) {
        $count = 0;
    }

    $x[$myArray[$i]->a . '|' . $myArray[$i]->b] = ++$count;
}

print_r($x);

这导致以下输出。

大批
(
    [1|1024] => 1
    [4|4096] => 5
    [4|6144] => 3
    [8|6144] => 2
    [8|8192] => 4
)

然后从该数组中获取最大值。

于 2013-05-02T20:26:28.917 回答