Есть ли способ сравнить массивы в php с помощью встроенной функции, не выполняя какой-то цикл?
$a1 = array(1,2,3);
$a2 = array(1,2,3);
if (array_are_same($a1, $a2)) {
// code here
}
Btw, значения массива не всегда будут в одном порядке.
Массив сравнения PHP
Ответ 1
if ( $a == $b ) {
echo 'We are the same!'
}
Ответ 2
Сравнение двух массивов с одинаковыми значениями (дублируемыми или нет, с учетом ввода-манипуляции) может быть выполнено с помощью 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;
};
Это сохраняет таблицу значений, чтобы оба массива могли использовать один и тот же индекс. Также возможно выйти с первого раза в первый раз во втором массиве с новым значением.
Эта функция также может добавить строгий контекст, добавив дополнительный параметр. И добавив еще один дополнительный параметр, вы можете позволить искать дубликаты или нет. Полный пример:
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
Ответ 3
@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 [...] Возвращает массив, содержащий все записи из массива, которые не присутствуют ни в одном из других массивов.
что не означает, что 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 в "обоих направлениях", чтобы получить все "отличия" от двух массивов.
надеюсь, что это поможет:)
Ответ 4
Также вы можете попробовать следующим образом:
if(serialize($a1) == serialize($a2))
Ответ 5
Просто проверьте $a1 == $a2 - что с этим не так?
Ответ 6
array_intersect() возвращает массив, содержащий все общие значения.
Ответ 7
Быстрый метод сравнения значений массива, который может быть в любом порядке...
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
Ответ 8
Заключение из комментария здесь:
Сравнение значений массива равным (после жонглирования типа) и только в том же порядке:
array_values($a1) == array_values($a2)
Сравнение значений массива, равное (после жонглирования типа) и в том же порядке и ключи массива являются одинаковыми и в том же порядке:
array_values($a1) == array_values($a2) && array_keys($a1) == array_keys($a2)
Ответ 9
получить массив от пользователя или ввести значения массива. Используйте функцию сортировки для сортировки обоих массивов. проверьте с помощью тернарного оператора. Если оба массива равны, то они будут печатать массивы равными, иначе они будут печатать массивы, не равные. здесь нет итерации цикла.
sort($a1);
sort($a2);
echo (($a1==$a2) ? "arrays are equal" : "arrays are not equal");
Ответ 10
убедитесь, что количество пересечений совпадает с обоими массивами источников
$intersections = array_intersect($a1, $a2);
$equality = (count($a1) == count($a2)) && (count($a2) == count($intersections)) ? true : false;
Ответ 11
Сравните значения двух массивов:
$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';
}
Ответ 12
Если вы не заботитесь о клавишах и что только значения, то это лучший метод для сравнения значений и убедитесь, что дубликаты подсчитаны.
$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, так как все значения будут найдены в обоих массивах, но, как указано выше, он не заботится о дублировании.
Ответ 13
Если вы хотите найти некоторый массив внутри большого массива массивов ( > 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;
}
Ответ 14
попробуйте следующее:
$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
}
Ответ 15
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';
Ответ 16
Насколько я могу судить, нет никакой встроенной функции, которая сделает это для вас, однако, что-то вроде:
if (count($a) == count($b) && (!count(array_diff($a, $b))) {
// The arrays are the same
}
Должен сделать трюк