¿Existe algún método como array_unique para objetos? Tengo un montón de matrices con objetos 'Role' que fusiono, y luego quiero eliminar los duplicados :)
Bueno, array_unique()
compara el valor de cadena de los elementos:
Nota : Dos elementos se consideran iguales si y solo si,
(string) $elem1 === (string) $elem2
es decir, cuando la representación de la cadena es la misma, se utilizará el primer elemento.
Así que asegúrese de implementar el __toString()
método en su clase y que genere el mismo valor para roles iguales, por ejemplo
class Role {
private $name;
//.....
public function __toString() {
return $this->name;
}
}
Esto consideraría dos roles como iguales si tuvieran el mismo nombre.
array_unique
ni __toString()
comparo nada. __toString()
define cómo se supone que se comporta una instancia de objeto cuando se usa en un contexto de cadena y array_unique
devuelve la matriz de entrada con los valores duplicados eliminados. Solo usa la comparación para esto internamente.
echo $object
también utiliza el __toString
método.
__toString()
métodos a todos sus objetos es mucho más doloroso que simplemente agregar una SORT_REGULAR
bandera a array_unique, vea Matthieu Napoli su respuesta. Además, un __toString()
método tiene muchos otros casos de uso que se utilizan para la comparación de objetos, por lo que es posible que esto ni siquiera sea posible.
array_unique
funciona con una variedad de objetos usando SORT_REGULAR
:
class MyClass {
public $prop;
}
$foo = new MyClass();
$foo->prop = 'test1';
$bar = $foo;
$bam = new MyClass();
$bam->prop = 'test2';
$test = array($foo, $bar, $bam);
print_r(array_unique($test, SORT_REGULAR));
Imprimirá:
Array (
[0] => MyClass Object
(
[prop] => test1
)
[2] => MyClass Object
(
[prop] => test2
)
)
Véalo en acción aquí: http://3v4l.org/VvonH#v529
Advertencia : utilizará la comparación "==", no la comparación estricta ("===").
Entonces, si desea eliminar duplicados dentro de una matriz de objetos, tenga en cuenta que comparará las propiedades de cada objeto, no comparará la identidad del objeto (instancia).
==
) o identidad ( ===
) debido a $bam->prop = 'test2';
(debería ser 'test1'
para mostrar la diferencia). Consulte codepad.viper-7.com/8NxWhG para ver un ejemplo.
Esta respuesta utiliza in_array()
ya que la naturaleza de comparar objetos en PHP 5 nos permite hacerlo. Hacer uso de este comportamiento de comparación de objetos requiere que la matriz solo contenga objetos, pero ese parece ser el caso aquí.
$merged = array_merge($arr, $arr2);
$final = array();
foreach ($merged as $current) {
if ( ! in_array($current, $final)) {
$final[] = $current;
}
}
var_dump($final);
in_array
debería usar el $strict
parámetro! De lo contrario, puede comparar objetos usando "==" en lugar de "===". Más aquí: fr2.php.net/manual/fr/function.in-array.php
Aquí hay una forma de eliminar objetos duplicados en una matriz:
<?php
// Here is the array that you want to clean of duplicate elements.
$array = getLotsOfObjects();
// Create a temporary array that will not contain any duplicate elements
$new = array();
// Loop through all elements. serialize() is a string that will contain all properties
// of the object and thus two objects with the same contents will have the same
// serialized string. When a new element is added to the $new array that has the same
// serialized value as the current one, then the old value will be overridden.
foreach($array as $value) {
$new[serialize($value)] = $value;
}
// Now $array contains all objects just once with their serialized version as string.
// We don't care about the serialized version and just extract the values.
$array = array_values($new);
También puede serializar primero:
$unique = array_map( 'unserialize', array_unique( array_map( 'serialize', $array ) ) );
A partir de PHP 5.2.9, puede usar opcional sort_flag SORT_REGULAR
:
$unique = array_unique( $array, SORT_REGULAR );
También puede usar la función array_filter, si desea filtrar objetos en función de un atributo específico:
//filter duplicate objects
$collection = array_filter($collection, function($obj)
{
static $idList = array();
if(in_array($obj->getId(),$idList)) {
return false;
}
$idList []= $obj->getId();
return true;
});
Desde aquí: http://php.net/manual/en/function.array-unique.php#75307
Este también funcionaría con objetos y matrices.
<?php
function my_array_unique($array, $keep_key_assoc = false)
{
$duplicate_keys = array();
$tmp = array();
foreach ($array as $key=>$val)
{
// convert objects to arrays, in_array() does not support objects
if (is_object($val))
$val = (array)$val;
if (!in_array($val, $tmp))
$tmp[] = $val;
else
$duplicate_keys[] = $key;
}
foreach ($duplicate_keys as $key)
unset($array[$key]);
return $keep_key_assoc ? $array : array_values($array);
}
?>
Si tiene una matriz indexada de objetos y desea eliminar los duplicados comparando una propiedad específica en cada objeto, remove_duplicate_models()
se puede usar una función como la que se muestra a continuación.
class Car {
private $model;
public function __construct( $model ) {
$this->model = $model;
}
public function get_model() {
return $this->model;
}
}
$cars = [
new Car('Mustang'),
new Car('F-150'),
new Car('Mustang'),
new Car('Taurus'),
];
function remove_duplicate_models( $cars ) {
$models = array_map( function( $car ) {
return $car->get_model();
}, $cars );
$unique_models = array_unique( $models );
return array_values( array_intersect_key( $cars, $unique_models ) );
}
print_r( remove_duplicate_models( $cars ) );
El resultado es:
Array
(
[0] => Car Object
(
[model:Car:private] => Mustang
)
[1] => Car Object
(
[model:Car:private] => F-150
)
[2] => Car Object
(
[model:Car:private] => Taurus
)
)
de forma sana y rápida si necesita filtrar instancias duplicadas (es decir, comparación "===") fuera de la matriz y:
es:
//sample data
$o1 = new stdClass;
$o2 = new stdClass;
$arr = [$o1,$o1,$o2];
//algorithm
$unique = [];
foreach($arr as $o){
$unique[spl_object_hash($o)]=$o;
}
$unique = array_values($unique);//optional - use if you want integer keys on output
Esta es una solución muy simple:
$ids = array();
foreach ($relate->posts as $key => $value) {
if (!empty($ids[$value->ID])) { unset($relate->posts[$key]); }
else{ $ids[$value->ID] = 1; }
}
array_unique funciona convirtiendo los elementos en una cadena y haciendo una comparación. A menos que sus objetos se conviertan únicamente en cadenas, no funcionarán con array_unique.
En su lugar, implemente una función de comparación con estado para sus objetos y use array_filter para descartar cosas que la función ya ha visto.
array_unique
usado con trabajos SORT_REGULAR, vea mi respuesta a continuación.
Esta es mi forma de comparar objetos con propiedades simples y al mismo tiempo recibir una colección única:
class Role {
private $name;
public function __construct($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
}
$roles = [
new Role('foo'),
new Role('bar'),
new Role('foo'),
new Role('bar'),
new Role('foo'),
new Role('bar'),
];
$roles = array_map(function (Role $role) {
return ['key' => $role->getName(), 'val' => $role];
}, $roles);
$roles = array_column($roles, 'val', 'key');
var_dump($roles);
Saldrá:
array (size=2)
'foo' =>
object(Role)[1165]
private 'name' => string 'foo' (length=3)
'bar' =>
object(Role)[1166]
private 'name' => string 'bar' (length=3)
Si tiene una matriz de objetos y desea filtrar esta colección para eliminar todos los duplicados, puede usar array_filter con la función anónima:
$myArrayOfObjects = $myCustomService->getArrayOfObjects();
// This is temporary array
$tmp = [];
$arrayWithoutDuplicates = array_filter($myArrayOfObjects, function ($object) use (&$tmp) {
if (!in_array($object->getUniqueValue(), $tmp)) {
$tmp[] = $object->getUniqueValue();
return true;
}
return false;
});
Importante: recuerde que debe pasar la $tmp
matriz como referencia a su función de devolución de llamada de filtro, de lo contrario no funcionará