Php равны ли массивы

PHP — Проверьте, равны ли два массива

Я хотел бы проверить, равны ли два массива. Я имею в виду: тот же самый размер, тот же индекс, одинаковые значения. Как я могу это сделать? Используя === , как было предложено пользователем, я ожидаю, что следующее будет печатать enter, если хотя бы один элемент в массиве (-ах) отличается, но на самом деле это не так.

if (($_POST['atlOriginal'] !=== $oldAtlPosition) or ($_POST['atl'] !=== $aext) or ($_POST['sidesOriginal'] !=== $oldSidePosition) or ($_POST['sidesOriginal'] !=== $sideext))

Просто для записи (поскольку мое редактирование было изменено на «пользователь»), это «пользователь»: english.stackexchange.com/questions/105116/…

@ DávidHorváth, свободное сравнение не только в PHP. Если вы посмотрите на JS, вы будете удивлены. Просто не используйте, пока не поймете вещи лучше.

12 ответов

$arraysAreEqual = ($a == $b); // TRUE if $a and $b have the same key/value pairs. $arraysAreEqual = ($a === $b); // TRUE if $a and $b have the same key/value pairs in the same order and of the same types. 

Оператор неравенства != , а нетождественный оператор !== соответствует равенству оператор == и тождественный оператор === .

Примечание: этот подход работает и для многомерных массивов (раньше это не было так очевидно для меня).

Не работает, когда индексы не совпадают . Пример: мой дамп — array(3) < [0]=>int(1) [1]=>int(2) [4]=>int(5) > (индексы 0,1,4), но другие массивы используют ожидаемые индексы (0,1,2). Это ошибка PHP?

PS: решение состоит в том, чтобы использовать array_values($a)==array_values($b) . Другая обычная проблема array_values($a)==array_values($b) уникальными значениями, поэтому помните, что существует array_unique() .

Сказать == проверки на совпадение пар ключ / значение немного вводит в заблуждение. Похоже, на самом деле проверить значения == друг друга. Таким образом, вы можете быть удивлены, обнаружив, что массив (0) == массив («не ноль») является истинным.

Этот ответ неверен. == работает независимо от порядка только для типичных словарей, таких как [1 => ‘a’, 2 => ‘b’] . Например, [1 => ‘a’, 2 => ‘b’] == [2 => ‘b’, 1 => ‘a’] . Для индексированных массивов, таких как [‘a’, ‘b’] == , не работает, как указано. Например, [‘a’, ‘b’] != [‘b’, ‘a’] .

@nawfal: Ваше предположение неверно. [‘a’, ‘b’] — это массив [0 => ‘a’, 1 => ‘b’] , а [‘b’, ‘a’] — это массив [0 => ‘b’, 1 => ‘a’] . Вот почему у них нет тех же пар ключ / значение, как указано в моем ответе, и поэтому == не работает между ними.

@StefanGehrig о, ты прав. Я оставлю свой комментарий как таковой, чтобы сделать мою глупость очевидной 🙂

+1 за same order . И это работает с === даже если ключи в одном массиве имеют числовые ограничения, заключенные в кавычки. (например, «0», «1»).

Обратите внимание, что === требует, чтобы значения имели только одинаковые типы, и не требует ключей, что означает ([0 => ‘a’, 1 => ‘b’] === [false => ‘a’, ‘1’ => ‘b’]) === true .

Кто-нибудь может сослаться на объяснение того, почему === быстрее в больших массивах, чем == (массивы по 100 тыс. символов)

ПРИМЕЧАНИЕ. Принятый ответ работает для ассоциативных массивов, но он не будет работать так, как ожидалось, с индексированными массивами (поясняется ниже). Если вы хотите сравнить любой из них, используйте это решение. Кроме того, эта функция может не работать с многомерными массивами (из-за характера функции array_diff).

Тестирование двух индексированных массивов, элементы которых находятся в другом порядке, с ошибками $a == $b или $a === $b , например:

Это потому, что это означает:

array(0 => «x», 1 => «y») vs. array(0 => «y», 1 => «x») .

Чтобы решить эту проблему, используйте:

Было добавлено сравнение размеров массива (предложенное super_ton), поскольку оно может улучшить скорость.

Источник

Php равны ли массивы

Оператор + возвращает левый массив, к которому был присоединён правый массив. Для ключей, которые существуют в обоих массивах, будут использованы значения из левого массива, а соответствующие им элементы из правого массива будут проигнорированы.

$a = array( «a» => «apple» , «b» => «banana» );
$b = array( «a» => «pear» , «b» => «strawberry» , «c» => «cherry» );

$c = $a + $b ; // Объединение $a и $b
echo «Объединение \$a и \$b: \n» ;
var_dump ( $c );

$c = $b + $a ; // Объединение $b и $a
echo «Объединение \$b и \$a: \n» ;
var_dump ( $c );

$a += $b ; // Объединение $a += $b, это $a и $b
echo «Объединение \$a += \$b: \n» ;
var_dump ( $a );
?>

Объединение $a и $b: array(3) < ["a"]=>string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" > Объединение $b и $a: array(3) < ["a"]=>string(4) "pear" ["b"]=> string(10) "strawberry" ["c"]=> string(6) "cherry" > Объединение $a += $b: array(3) < ["a"]=>string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" >

При сравнении элементы массива считаются идентичными, если совпадает и ключ, и соответствующее ему значение.

Пример #1 Сравнение массивов

$a = array( «apple» , «banana» );
$b = array( 1 => «banana» , «0» => «apple» );

var_dump ( $a == $b ); // bool(true)
var_dump ( $a === $b ); // bool(false)
?>

Смотрите также

User Contributed Notes 14 notes

The union operator did not behave as I thought it would on first glance. It implements a union (of sorts) based on the keys of the array, not on the values.

For instance:
$a = array( ‘one’ , ‘two’ );
$b =array( ‘three’ , ‘four’ , ‘five’ );

//not a union of arrays’ values
echo ‘$a + $b : ‘ ;
print_r ( $a + $b );

//a union of arrays’ values
echo «array_unique(array_merge( $a , $b )):» ;
// cribbed from http://oreilly.com/catalog/progphp/chapter/ch05.html
print_r ( array_unique ( array_merge ( $a , $b )));
?>

//output

$a + $b : Array
(
[0] => one
[1] => two
[2] => five
)
array_unique(array_merge(Array,Array)):Array
(
[0] => one
[1] => two
[2] => three
[3] => four
[4] => five
)

The example may get u into thinking that the identical operator returns true because the key of apple is a string but that is not the case, cause if a string array key is the standart representation of a integer it’s gets a numeral key automaticly.

The identical operator just requires that the keys are in the same order in both arrays:

$a = array ( 0 => «apple» , 1 => «banana» );
$b = array ( 1 => «banana» , 0 => «apple» );

var_dump ( $a === $b ); // prints bool(false) as well

$b = array ( «0» => «apple» , «1» => «banana» );

var_dump ( $a === $b ); // prints bool(true)
?>

Note that + will not renumber numeric array keys. If you have two numeric arrays, and their indices overlap, + will use the first array’s values for each numeric key, adding the 2nd array’s values only where the first doesn’t already have a value for that index. Example:

$a = array(‘red’, ‘orange’);
$b = array(‘yellow’, ‘green’, ‘blue’);
$both = $a + $b;
var_dump($both);

array(3) < [0]=>string(3) «red» [1]=> string(6) «orange» [2]=> string(4) «blue» >

To get a 5-element array, use array_merge.

It should be mentioned that the array union operator functions almost identically to array_replace with the exception that precedence of arguments is reversed.

The reason for the above output is that EVERY array in PHP is an associative one.
Since the 3 elements in $b have the same keys( or numeric indices ) as those in $a, those elements in $b are ignored by the union operator.

[]= could be considered an Array Operator (in the same way that .= is a String Operator).
[]= pushes an element onto the end of an array, similar to array_push:
$array= array(0=>»Amir»,1=>»needs»);
$array[]= «job»;
print_r($array);
?>
Prints: Array ( [0] => Amir [1] => needs [2] => job )

The note about array comparison by Q1712 is not entirely accurate.

«The identical operator just requires that the keys are in the same order in both arrays:»

This may have been the case in past (I cannot verify it). It requires that the keys are in the same order AND that the values match

$a = array ( 0 => «apple» , 1 => «banana» );
$b = array ( 1 => «banana» , 0 => «apple» );

var_dump ( $a === $b ); // prints bool(false) as well

$b = array ( «0» => «apple» , «1» => «banana» );

var_dump ( $a === $b ); // prints bool(true)

$b = array ( «0» => «apple-1» , «1» => «banana-1» );

var_dump ( $a === $b ); // prints bool(false)

Merge two arrays and retain only unique values.
Append values from second array.
Do not care about keys.

$array2 = [
0 => ‘melon’ ,
1 => ‘orange’ ,
2 => ‘banana’ ,
];

$result = array_keys (
array_flip ( $array1 ) + array_flip ( $array2 )
);
?>

Result:
[
[0] => «apple»,
[1] => «orange»,
[2] => «pear»,
[3] => «melon»,
[4] => «banana»,
>

Simple array arithmetic:
A more compact way of adding or subtracting the elements at identical keys.

function array_add ( $a1 , $a2 ) < // .
// adds the values at identical keys together
$aRes = $a1 ;
foreach ( array_slice ( func_get_args (), 1 ) as $aRay ) foreach ( array_intersect_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] += $val ;
$aRes += $aRay ; >
return $aRes ; >

function array_subtract ( $a1 , $a2 ) < // .
// adds the values at identical keys together
$aRes = $a1 ;
foreach ( array_slice ( func_get_args (), 1 ) as $aRay ) foreach ( array_intersect_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] -= $val ;
foreach ( array_diff_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] = — $val ; >
return $aRes ; >

Example :
$a1 = array( 9 , 8 , 7 );
$a2 = array( 1 => 7 , 6 , 5 );
$a3 = array( 2 => 5 , 4 , 3 );

$aSum = array_add ( $a1 , $a2 , $a3 );
$aDiff = array_subtract ( $a1 , $a2 , $a3 );

// $aSum => [9, 15, 18, 9, 3]// $aDiff => [9, 1, -4, -9, -3]
?>

To make a similar function, array_concatenate(), change only the first of the two ‘+=’ in array_add() to ‘.=’
Csaba Gabor from Vienna

When comparing arrays that have (some or all) element-values that are themselves array, then in PHP5 it seems that == and === are applied recursively — that is
* two arrays satisfy == if they have the same keys, and the values at each key satisfy == for whatever they happen to be (which might be arrays);
* two arrays satisfy === if they have the same keys, and the values at each key satisfy === for whatever (etc.).

Which explains what happens if we compare two arrays of arrays of arrays of.

Likewise, the corresponding inversions for != <> and !==.

I’ve tested this to array-of-array-of-array, which seems fairly convincing. I’ve not tried it in PHP4 or earlier.

Look out use + with array combine.

$arr = array(1, 2, 3);
$int=345;
$arr=$arr+$int;

Of couse,use + to combine array is easy and readable.
But if one of the variable is not array type(like above code) ,that would make a PHP Fatal Error:
PHP Fatal error: Unsupported operand types
Maybe should do check before.

hi just see one more example of union.

$a = array( 1 , 2 , 3 );
$b = array( 1 , 7 , 8 , 9 , 10 );
$c = $a + $b ; // Union of $a and $b
echo «Union of \$a and \$b: \n» ;
//echo $c
print_r ( $c );
?>
//output
Union of $a and $b: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 9 [4] => 10 )

«The + operator appends the right elements in the array from left, whereas duplicated keys are NOT overwritten»

$a = array(«a» => ‘A’, «b» => ‘B’);
$b = array(«a» => ‘A’, «b» => ‘B’, «c» => ‘C’);

$c = $a + $b // or $b + a is the same output;

//Output for $a + b or $b + a
Array (
[a] => A
[b] => B
[c] => C
)

• Операторы
  • Приоритет оператора
  • Арифметические операторы
  • Оператор присваивания
  • Побитовые операторы
  • Операторы сравнения
  • Оператор управления ошибками
  • Операторы исполнения
  • Операторы инкремента и декремента
  • Логические операторы
  • Строковые операторы
  • Операторы, работающие с массивами
  • Оператор проверки типа

  Источник