Массив сравнения PHP

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

Сравнение двух массивов с равными значениями (дублируемыми или нет, с учетом array_diff() ) может быть выполнено с помощью 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 делает 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; }; 

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

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

 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, извините, но это не делает, что ожидается todo: (так же упоминается в этом контексте 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 […] Возвращает массив, содержащий все записи из массива1, которые не присутствуют ни в одном из других массивов.

что не означает, что 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"); 

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

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

Это не будет отражать истину, так как $ 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, так как все значения будут найдены в обоих массивах, но, как отмечалось ранее, это не касается дублирования.

Если вы хотите найти некоторый массив внутри большого массива массивов (> 10k), то гораздо быстрее сравнивает сериализованные массивы (сохраненные в кеше). Пример из работы с 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; } 

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

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

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

 if(count($a1) == count($a2)){ $result= array_intersect($a1, $a2); if(count($a1) == count($result)) echo 'the same'; else echo 'a1 different than a2'; } else echo 'a1 different than a2';