PHP сравнить массив

Сравнение двух массивов на наличие одинаковых значений (дублированных или нет, с учетом жонглирования типами) можно выполнить с помощью array_diff(). в обе стороны:

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

Это дает TRUE, если оба массива имеют одинаковые значения (после жонглирования типами). FALSE иначе. Примеры:

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_diff исключает ключи массива из уравнения и не заботится ни о порядке значений, ни о том, дублируются значения или нет.

Если дублирование должно иметь значение, это становится более сложным. Что касается «простых» значений (работают только строковые и целочисленные значения), array_count_values() вступает в игру для сбора информации. о том, какое значение, как часто внутри массива. Эту информацию можно легко сравнить с ==:

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

Это дает TRUE, если оба массива имеют одинаковые значения (после жонглирования типами) за одинаковое количество времени. FALSE иначе. Примеры:

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

Это можно дополнительно оптимизировать, сначала сравнив количество двух массивов, что относительно дешево, и быстрый тест, чтобы отличить большинство массивов, когда дублирование значений подсчета имеет значение.

Пока что эти примеры частично ограничены строковыми и целочисленными значениями, и строгое сравнение с array_diff также невозможно. Для строгого сравнения больше подходит array_search. Поэтому значения необходимо подсчитывать и индексировать, чтобы их можно было сравнить, поскольку просто превратить их в ключ (как это делает array_search) не получится.

Это немного больше работы. Однако в конце сравнение такое же, как и раньше:

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

Разница только в $count:

    $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;
    };

Это сохраняет таблицу значений, чтобы оба массива могли использовать один и тот же индекс. Также можно выйти досрочно в первый раз, когда во втором массиве появляется новое значение.

Эта функция также может добавить контекст strict с помощью дополнительного параметра. А добавление еще одного дополнительного параметра позволило бы включить поиск дубликатов или нет. Полный пример:

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);
}

Примеры использования:

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

@Cleanshooter извините, но это не делает того, что ожидается: (так же, как и array_diff, упомянутый в этом контексте)

$a1 = array('one','two');
$a2 = array('one','two','three');

var_dump(count(array_diff($a1, $a2)) === 0); // returns TRUE

(аннотация: вы не можете использовать пусто для функций до PHP 5.5) в этом случае результат верен, хотя массивы разные.

array_diff [...] Возвращает массив, содержащий все записи из array1, которых нет ни в одном из других массивов.

что не означает, что array_diff что-то вроде: array_get_all_differences. Объясняется математическими наборами, которые он вычисляет:

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

что означает что-то вроде всех элементов из первого набора без всех элементов из второго набора, которые есть в первом наборе. Чтобы

var_dump(array_diff($a2, $a1));

вычисляет до

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

Вывод таков, что вам нужно сделать array_diff "в обоих направлениях", чтобы получить все "различия" из двух массивов.

надеюсь это поможет :)

Также вы можете попробовать так:

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

Просто проверьте $a1 == $a2 -- что в этом не так?

array_intersect() возвращает массив, содержащий все общие значения.

Быстрый метод сравнения значений массива, которые могут быть в любом порядке...

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

Таким образом, для...

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

arrays_are_same($array1, $array2) вернется TRUE

Вывод из комментария здесь:

Сравнение значений массива при равенстве (после жонглирования типами) и только в том же порядке:

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

Сравнение одинаковых значений массива (после жонглирования типами) и в том же порядке и одинаковых ключей массива и в том же порядке:

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

получить массив от пользователя или ввести значения массива. Используйте функцию сортировки для сортировки обоих массивов. проверить с помощью тернарного оператора. Если оба массива равны, он напечатает, что массивы равны, иначе он напечатает, что массивы не равны. здесь нет итерации цикла.

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

Если вы хотите найти какой-то массив внутри большого массива массивов (>10 КБ), то намного быстрее сравнивает сериализованные массивы (сохраненные в кеше). Пример из работы с URL:

/**
@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;
}

убедитесь, что количество пересечений совпадает с обоими исходными массивами

$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';
}

Если вам не нужны ключи, а только значения, то это лучший способ сравнить значения и убедиться, что дубликаты подсчитаны.

$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';
}

Это не будет эхо-сигналом true, так как $mag имеет 2 значения в массиве, равные 3.

Это работает лучше всего, если вы заботитесь только о значениях и ключах и не заботитесь о дублировании. $mag = '{"1":"1","2":"2","3":"3","4":"3"}'; $mag_evo = '1|2|3';

$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';
}

Это вернет true, так как все значения находятся в обоих массивах, но, как отмечалось ранее, не заботится о дублировании.

это простой способ получить разницу:

$array1 = [40,10,30,20,50];
$array2 = [10,30];
$result = array_filter(
                       $array1,
                       function($var) use($array2){
                                if(in_array($var, $array2)){
                                   return $var;
                                }
                         }
             );
print_r($result); //Array ( [0] => 10 [1] => 30 )

попробуй это :

$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
    }

Насколько я могу судить, нет ни одной встроенной функции, которая сделает это за вас, например:

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

Должен сделать трюк