PHP比较数组

在php中，除了执行某种循环外，是否还可以使用内置函数比较数组

$a1 = array(1,2,3);
$a2 = array(1,2,3);

if (array_are_same($a1, $a2)) {
    // code here
}

---

顺便说一句，数组值的顺序并不总是相同的。

只需检查一下

$a1==$a2

——这有什么不对？

返回一个包含所有公共值的数组。

@Cleanshooter很抱歉，这不符合预期的操作要求：（本文中提到的数组也不一样）

if ( $a == $b ) {
    echo 'We are the same!'
}

（注释：不能在函数上使用空） 在这种情况下，结果是正确的，尽管数组不同

array_diff[…]返回一个数组，该数组包含array1中任何其他数组中都不存在的所有条目

这并不意味着

array\u diff

类似于：

array\u get\u all\u difference

。以其计算的数学集解释：

{'one','two'} \ {'one','two','three'} = {}

这意味着类似于第一个集合中的所有元素，而第二个集合中的所有元素都在第一个集合中。 所以

计算到

array(1) { [2]=> string(5) "three" } 

结论是，您必须以“两种方式”执行

数组_diff

，以获得两个数组的所有“差异”

希望这有帮助：）

试试这个：

$array1 = array("street" => array("Althan"), "city"   => "surat", "state"  => "guj", "county" => "india");
        $array2  = array("street" => array("Althan"), "city"   => "surat", "state"  => "guj", "county" => "india");

    if (array_compare($array1, $array2))
    {
             echo "<pre>";
             print_r("succsses..!");
             echo "</pre>";
             exit;

    }
    else
    {
            echo "<pre>";
            print_r("Faild..!");
            echo "</pre>";
            exit;
    }

    function array_compare($op1, $op2)
    {

            foreach ($op1 as $key => $val)
            {
                    if (is_array($val))
                    {
                            if (array_compare($val, $op2[$key]) === FALSE)
                                    return false;
                    }
                    else
                    {

                            if (!array_key_exists($key, $op2))
                            {
                                    return false; // uncomparable
                            }
                            elseif ($val < $op2[$key])
                            {
                                    return false;
                            }
                            elseif ($val > $op2[$key])
                            {
                                    return false;
                            }
                    }
            }
            return true; // $op1 == $op2
    }

$array1=数组（“街道”=>数组（“阿尔坦”）、“城市”=>“苏拉特”、“州”=>“古吉”、“县”=>“印度”）；
$array2=数组（“街道”=>数组（“阿尔坦”），“城市”=>苏拉特”，“州”=>古吉”，“县”=>印度”）；
if（数组_比较（$array1，$array2））
{
回声“；
function arrays_are_same($array1, $array2) {
    sort($array1);
    sort($array2);
    return $array1==$array2;
}

    $array1 = array('audio', 'video', 'image');
    $array2 = array('video', 'image', 'audio');

打印（“成功…”）；
回声“；
function arrays_are_same($array1, $array2) {
    sort($array1);
    sort($array2);
    return $array1==$array2;
}

    $array1 = array('audio', 'video', 'image');
    $array2 = array('video', 'image', 'audio');

出口
}
其他的
{
回声“；
function arrays_are_same($array1, $array2) {
    sort($array1);
    sort($array2);
    return $array1==$array2;
}

    $array1 = array('audio', 'video', 'image');
    $array2 = array('video', 'image', 'audio');

打印（“失败…”）；
回声“；
function arrays_are_same($array1, $array2) {
    sort($array1);
    sort($array2);
    return $array1==$array2;
}

    $array1 = array('audio', 'video', 'image');
    $array2 = array('video', 'image', 'audio');

出口
}
函数数组\u比较（$op1，$op2）
{
foreach（$op1作为$key=>$val）
{
if（is_数组（$val））
{
if（数组比较（$val，$op2[$key]）==FALSE）
返回false；
}
其他的
{
如果（！array_key_存在（$key，$op2））
{
返回false；//不可压缩
}
elseif（$val<$op2[$key]）
{
返回false；
}
elseif（$val>$op2[$key]）
{
返回false；
}
}
}
返回true；//$op1==$op2
}

一种快速比较数组值的方法，可以是任意顺序

if (count($a) == count($b) && (!count(array_diff($a, $b))) {
  // The arrays are the same
}

所以对于

array_values($a1) == array_values($a2)

---

arrays\u是相同的（$array1，$array2）

将返回

TRUE

据我所知，没有一个内置函数可以为您实现这一点，但是，类似于：

array_values($a1) == array_values($a2) && array_keys($a1) == array_keys($a2)

---

应该做到这一点

从这里的评论中得出结论：

数组值相等（类型转换后）且顺序相同时的比较：

$intersections = array_intersect($a1, $a2);
$equality = (count($a1) == count($a2)) && (count($a2) == count($intersections)) ? true : false;

数组值相等（类型转换后）且顺序相同与数组键相同且顺序相同的比较：

$a = array(1,2,3);
$b = array(1,3,2);

if (array_diff($a, $b) || array_diff($b, $a)) {
    echo 'Not equal';
}else{
    echo 'Equal';
}

---

验证交点计数是否与两个源阵列相同

!array_diff($a, $b) && !array_diff($b, $a);

---

比较两个数组的值：

function array_equal_values(array $a, array $b) {
    return !array_diff($a, $b) && !array_diff($b, $a);
}

array_equal_values([1], []);            # FALSE
array_equal_values([], [1]);            # FALSE
array_equal_values(['1'], [1]);         # TRUE
array_equal_values(['1'], [1, 1, '1']); # TRUE

---

将两个数组进行比较以使其具有相等的值（复制或不复制，考虑到类型转换），可以通过在两个方向上使用来完成：

array_count_values($a) == array_count_values($b);

如果两个数组具有相同的值（在类型转换之后），则会给出

TRUE

<代码>错误否则。示例：

function array_equal_values(array $a, array $b) {
    return array_count_values($a) == array_count_values($b);
}

array_equal_values([2, 1], [1, 2]);           # TRUE
array_equal_values([2, 1, 2], [1, 2, 2]);     # TRUE
array_equal_values(['2', '2'], [2, '2.0']);   # FALSE
array_equal_values(['2.0', '2'], [2, '2.0']); # TRUE

    $table = [];
    $count = function (array $array) use (&$table) {
        $exit   = (bool)$table;
        $result = [];
        foreach ($array as $value) {
            $key = array_search($value, $table, true);

            if (FALSE !== $key) {
                if (!isset($result[$key])) {
                    $result[$key] = 1;
                } else {
                    $result[$key]++;
                }
                continue;
            }

            if ($exit) {
                break;
            }

            $key          = count($table);
            $table[$key]  = $value;
            $result[$key] = 1;
        }

        return $result;
    };

if(serialize($a1) == serialize($a2))

如本例所示，

array_diff

将数组键排除在等式之外，不关心值的顺序，也不关心值是否重复

---

如果复制必须有所不同，这将变得更加棘手。就“简单”值而言（只有字符串和整数值起作用），用于收集关于哪个值在数组中的频率的信息。此信息可以很容易地与

==

进行比较：

$count($a) == $count($b);

如果两个数组在相同的时间内具有相同的值（在类型转换之后），则这将给出

TRUE

<代码>错误否则。示例：

function array_equal_values(array $a, array $b) {
    return array_count_values($a) == array_count_values($b);
}

array_equal_values([2, 1], [1, 2]);           # TRUE
array_equal_values([2, 1, 2], [1, 2, 2]);     # TRUE
array_equal_values(['2', '2'], [2, '2.0']);   # FALSE
array_equal_values(['2.0', '2'], [2, '2.0']); # TRUE

    $table = [];
    $count = function (array $array) use (&$table) {
        $exit   = (bool)$table;
        $result = [];
        foreach ($array as $value) {
            $key = array_search($value, $table, true);

            if (FALSE !== $key) {
                if (!isset($result[$key])) {
                    $result[$key] = 1;
                } else {
                    $result[$key]++;
                }
                continue;
            }

            if ($exit) {
                break;
            }

            $key          = count($table);
            $table[$key]  = $value;
            $result[$key] = 1;
        }

        return $result;
    };

if(serialize($a1) == serialize($a2))

这可以通过首先比较两个阵列的计数来进一步优化，这相对便宜，并且当计数值重复造成差异时，可以通过快速测试来区分大多数阵列

---

到目前为止，这些示例部分限于字符串和整数值，并且无法与

array_diff

进行严格比较。更专门用于严格比较的是。因此，需要对值进行计数和索引，以便对它们进行比较，因为仅仅将它们转换为一个键（正如

array\u search

所做的那样）是不可能的

这是一个多一点的工作。但是，最后的比较与前面的相同：

function array_equal_values(array $a, array $b, $strict = FALSE, $allow_duplicate_values = TRUE) {

    $add = (int)!$allow_duplicate_values;

    if ($add and count($a) !== count($b)) {
        return FALSE;
    }

    $table = [];
    $count = function (array $array) use (&$table, $add, $strict) {
        $exit   = (bool)$table;
        $result = [];
        foreach ($array as $value) {
            $key = array_search($value, $table, $strict);

            if (FALSE !== $key) {
                if (!isset($result[$key])) {
                    $result[$key] = 1;
                } else {
                    $result[$key] += $add;
                }
                continue;
            }

            if ($exit) {
                break;
            }

            $key          = count($table);
            $table[$key]  = $value;
            $result[$key] = 1;
        }

        return $result;
    };

    return $count($a) == $count($b);
}

正是

$count

起了作用：

array_equal_values(['2.0', '2', 2], ['2', '2.0', 2], TRUE);           # TRUE
array_equal_values(['2.0', '2', 2, 2], ['2', '2.0', 2], TRUE);        # TRUE
array_equal_values(['2.0', '2', 2, 2], ['2', '2.0', 2], TRUE, FALSE); # FALSE
array_equal_values(['2'], ['2'], TRUE, FALSE);                        # TRUE
array_equal_values([2], ['2', 2]);                                    # TRUE
array_equal_values([2], ['2', 2], FALSE);                             # TRUE
array_equal_values([2], ['2', 2], FALSE, TRUE);                       # FALSE

这将保留一个值表，以便两个数组可以使用相同的索引。此外，在第二个数组中第一次遇到新值时，也可以提前退出

此函数还可以通过具有附加参数来添加严格上下文。然后，通过添加另一个附加参数，可以启用是否查找重复项。完整示例：

sort($a1);
sort($a2);
echo (($a1==$a2) ? "arrays are equal" : "arrays are not equal");

用法示例：

function array_equal_values(array $a, array $b) {
    return array_count_values($a) == array_count_values($b);
}

array_equal_values([2, 1], [1, 2]);           # TRUE
array_equal_values([2, 1, 2], [1, 2, 2]);     # TRUE
array_equal_values(['2', '2'], [2, '2.0']);   # FALSE
array_equal_values(['2.0', '2'], [2, '2.0']); # TRUE

    $table = [];
    $count = function (array $array) use (&$table) {
        $exit   = (bool)$table;
        $result = [];
        foreach ($array as $value) {
            $key = array_search($value, $table, true);

            if (FALSE !== $key) {
                if (!isset($result[$key])) {
                    $result[$key] = 1;
                } else {
                    $result[$key]++;
                }
                continue;
            }

            if ($exit) {
                break;
            }

            $key          = count($table);
            $table[$key]  = $value;
            $result[$key] = 1;
        }

        return $result;
    };

if(serialize($a1) == serialize($a2))

---

从用户处获取数组或输入数组值。使用sort函数对两个数组进行排序。使用三元运算符进行检查。如果两个数组相等，则打印数组相等，否则打印数组不相等。这里没有循环迭代

$mag = '{"1":"1","2":"2","3":"3","4":"3"}';
$mag_evo = '1|2|3';

$test1 = array_values(json_decode($mag, true));
$test2 = array_values(explode('|', $mag_evo));

if($test1 == $test2) {
    echo 'true';
}

---

您也可以这样尝试：

$test1 = json_decode($mag, true);
$test2 = explode('|', $mag_evo);

// There is no difference in either array.  
if(!array_diff($test1, $test2) && !array_diff($test2, $test1)) { 
    echo 'true';
}

---

如果您不关心键，而只关心值，那么这是比较值并确保重复计数的最佳方法

/**
@return array
*/
function createCache()
{
    $cache = [];
    foreach ($this->listOfUrl() as $url => $args)
    {
        ksort($args);
        $cache['url'][$url] = $args;
        $cache['arr'][crc32(serialize($args))] = $url;
    }
    return $cache;
}

/**
@param array $args
@return string
*/
function searchUrl($args)
{
    ksort($params);
    $crc = crc32(serialize($params));        
    return isset($this->cache['arr'][$crc]) ? $this->cache['arr'][$crc] : NULL;                
} 

/**
@param string $url
@return array
*/
function searchArgs($url)
{
    return isset($this->cache['url'][$url]) ? $this->cache['url'][$url] : NULL;
}

由于$mag在数组中有2个值等于3，因此这不会回显true

function arrays_are_same($array1, $array2) {
    sort($array1);
    sort($array2);
    return $array1==$array2;
}

    $array1 = array('audio', 'video', 'image');
    $array2 = array('video', 'image', 'audio');

如果您只需要