matches - PHP-Comprueba si dos matrices son iguales

php if array intersect

Question

Me gustaría comprobar si dos matrices son iguales. Quiero decir: mismo tamaño, mismo índice, mismos valores. ¿Cómo puedo hacer eso?

Usando === según lo sugerido por un usuario, espero que se imprima lo siguiente ingrese si al menos un elemento en la matriz (s) es diferente, pero en realidad no lo es.

if (($_POST[''atlOriginal''] !=== $oldAtlPosition)
or ($_POST[''atl''] !=== $aext)
or ($_POST[''sidesOriginal''] !=== $oldSidePosition)
or ($_POST[''sidesOriginal''] !=== $sideext)) {
echo "enter";
}

Answer 1

Compáralos como otros valores:

if($array_a == $array_b) {
//they are the same
}

Puede leer sobre todos los operadores de matrices aquí: http://php.net/manual/en/language.operators.array.php Tenga en cuenta, por ejemplo, que === también comprueba que los tipos y el orden de los elementos en las matrices son los mismo.

Answer 2

Otro método para verificar la igualdad independientemente del orden de valor funciona mediante el uso de http://php.net/manual/en/function.array-intersect.php , así:

$array1 = array(2,5,3);
$array2 = array(5,2,3);
if($array1 === array_intersect($array1, $array2) && $array2 === array_intersect($array2, $array1)) {
echo ''Equal'';
} else {
echo ''Not equal'';
}

Aquí hay una versión que también funciona con matrices multidimensionales usando http://php.net/manual/en/function.array-uintersect.php :

$array1 = array(
array(5, 2),
array(3, 6),
array(2, 9, 4)
);
$array2 = array(
array(3, 6),
array(2, 9, 4),
array(5, 2)
);
if($array1 === array_uintersect($array1, $array2, ''compare'') && $array2 === array_uintersect($array2, $array1, ''compare'')) {
echo ''Equal'';
} else {
echo ''Not equal'';
}
function compare($v1, $v2) {
if ($v1===$v2) {
return 0;
}
if ($v1 > $v2) return 1;
return -1;
}

Answer 3

Problema de sintaxis en tus arreglos

$array1 = array(
''a'' => ''value1'',
''b'' => ''value2'',
''c'' => ''value3'',
);
$array2 = array(
''a'' => ''value1'',
''b'' => ''value2'',
''c'' => ''value3'',
);
$diff = array_diff($array1, $array2);
var_dump($diff);

Answer 4

Puede usar array_diff_assoc para verificar las diferencias entre los dos.

Answer 5

Según esta página .

NOTA: La respuesta aceptada funciona para matrices asociativas, pero no funcionará como se esperaba con matrices indexadas (se explica a continuación). Si desea comparar alguno de ellos, use esta solución. Además, esta función puede no funcionar con matrices multidimensionales (debido a la naturaleza de la función array_diff).

La prueba de dos matrices indexadas, cuyos elementos están en orden diferente, usando $a == $b o $a === $b falla, por ejemplo:

<?php
(array("x","y") == array("y","x")) === false;
?>

Eso es porque lo anterior significa:

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

Para resolver ese problema, utilice:

<?php
function array_equal($a, $b) {
return (
is_array($a)
&& is_array($b)
&& count($a) == count($b)
&& array_diff($a, $b) === array_diff($b, $a)
);
}
?>

Se agregó la comparación de tamaños de matriz (sugerido por super_ton) ya que puede mejorar la velocidad.

Answer 6

Solución corta de trabajo que funciona incluso con matrices cuyas claves se dan en orden diferente:

public static function arrays_are_equal($array1, $array2)
{
array_multisort($array1);
array_multisort($array2);
return ( serialize($array1) === serialize($array2) );
}

Answer 7

Trate de serializar. Esto también verificará subarreglos anidados.

$foo =serialize($array_foo);
$bar =serialize($array_bar);
if ($foo == $bar) echo "Foo and bar are equal";

Answer 8

Una forma: (implementando ''considerado igual'' para http://tools.ietf.org/html/rfc6902#section-4.6 )

De esta manera, se pueden crear matrices asociativas cuyos miembros están ordenados de manera diferente, por ejemplo, serían considerados iguales en todos los idiomas, excepto en php :)

// recursive ksort
function rksort($a) {
if (!is_array($a)) {
return $a;
}
foreach (array_keys($a) as $key) {
$a[$key] = ksort($a[$key]);
}
// SORT_STRING seems required, as otherwise
// numeric indices (e.g. "0") aren''t sorted.
ksort($a, SORT_STRING);
return $a;
}
// Per http://tools.ietf.org/html/rfc6902#section-4.6
function considered_equal($a1, $a2) {
return json_encode(rksort($a1)) === json_encode(rksort($a2));
}

Answer 9

Utilice la función php array_diff (array1, array2);

Volverá a la diferencia entre matrices. Si está vacío, entonces son iguales.

ejemplo:

$array1 = array(
''a'' => ''value1'',
''b'' => ''value2'',
''c'' => ''value3''
);
$array2 = array(
''a'' => ''value1'',
''b'' => ''value2'',
''c'' => ''value4''
);
$diff = array_diff(array1, array2);
var_dump($diff);
//it will print array = (0 => [''c''] => ''value4'' )

Ejemplo 2:

$array1 = array(
''a'' => ''value1'',
''b'' => ''value2'',
''c'' => ''value3'',
);
$array2 = array(
''a'' => ''value1'',
''b'' => ''value2'',
''c'' => ''value3'',
);
$diff = array_diff(array1, array2);
var_dump($diff);
//it will print empty;

Answer 10

array_diff - Calcula la diferencia de matrices

http://php.net/manual/en/function.array-diff.php

array array_diff ( array $array1 , array $array2 [, array $... ] )

Compara array1 contra una o más otras matrices y devuelve los valores en array1 que no están presentes en ninguna de las otras matrices.

Answer 11

!=== no funcionará porque es un error de sintaxis. La forma correcta es !== (no tres símbolos "iguales a")

Answer 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.

Consulte Operadores de matrices .

EDITAR

El operador de desigualdad es != Mientras que el operador sin identidad es !== para coincidir con el operador de igualdad == y el operador de identidad === .

Answer 13

if (array_diff($a,$b) == array_diff($b,$a)) {
// Equals
}
if (array_diff($a,$b) != array_diff($b,$a)) {
// Not Equals
}

Desde mi punto de vista, es mejor usar array_diff que array_intersect porque con las comprobaciones de esta naturaleza, las diferencias devueltas generalmente son menores que las similitudes, de esta manera la conversión de bool no necesita más memoria.

Editar Tenga en cuenta que esta solución es para matrices simples y complementa las == y === publicadas anteriormente que solo son válidas para los diccionarios.