php filtre les valeurs du tableau et supprime les doublons du tableau multidimensionnel

Question

Bonjour à tous, j'essaie de trouver les valeurs x en double de ce tableau, de les supprimer et de ne laisser que les valeurs uniques.Par exemple, mon tableau est

Array
(
[0] => Array
    (
        [x] => 0.5
        [y] => 23
    )

[1] => Array
    (
        [x] => 23
        [y] => 21.75
    )

[2] => Array
    (
        [x] => 14.25
        [y] => 21.875
    )

[3] => Array
    (
        [x] => 19.375
        [y] => 21.75
    )

[4] => Array
    (
        [x] => 9.125
        [y] => 21.875
    )

[5] => Array
    (
        [x] => 23
        [y] => 19.625
    )

[6] => Array
    (
        [x] => 19.375
        [y] => 19.625
    ) 
)

Donc, ce dont j'ai besoin, c'est de parcourir le tout et de voir la première valeur x comme 0,5, puis de continuer et tout ce qui a x comme 0,5, le supprimer du tableau afin qu'à la fin j'ai un tableau qui ressemble à ceci

 Array
   (
[0] => Array
    (
        [x] => 0.5
        [y] => 23
    )

[1] => Array
    (
        [x] => 23
        [y] => 21.75
    )

[2] => Array
    (
        [x] => 14.25
        [y] => 21.875
    )

[3] => Array
    (
        [x] => 19.375
        [y] => 21.75
    )

[4] => Array
    (
        [x] => 9.125
        [y] => 21.875
    )
)

où toutes les valeurs X sont uniques.J'ai cherché sur Internet et j'ai trouvé cette fonction à utiliser, mais cela ne semble pas fonctionner :

 $result = array_map("unserialize", array_unique(array_map("serialize", $array)));    

Answer 1

Parcourez simplement et trouvez des valeurs uniques au fur et à mesure :

$taken = array();

foreach($items as $key => $item) {
    if(!in_array($item['x'], $taken)) {
        $taken[] = $item['x'];
    } else {
        unset($items[$key]);
    }
}

Chaque fois pour la première fois, le x la valeur est utilisée, nous la sauvegardons - et les utilisations ultérieures sont unset du tableau.

Answer 2

array_unique compare les valeurs de chaîne, afin que vous puissiez créer des objets (avec un __toString fonction) comme étape intermédiaire.

class XKeyObj {
    public $x;
    public $y;

    public function XKeyObj($x, $y) {
        $this->x = $x;
        $this->y = $y;
    }

    public function __toString() { return strval($this->x); }
}

function array_to_xKey($arr) { return new XKeyObj($arr['x'], $arr['y']); }
function xKey_to_array($obj) { return array('x' => $obj->x, 'y' => $obj->y); }

$input = array(
    array('x' => 0.5, 'y' => 23),
    array('x' => 23, 'y' => 21.75),
    array('x' => 14.25, 'y' => 21.875),
    array('x' => 19.375, 'y' => 21.75),
    array('x' => 9.125, 'y' => 21.875),
    array('x' => 23, 'y' => 19.625),
    array('x' => 19.375, 'y' => 19.625)
);

$output = array_map('xKey_to_array',
                    array_unique(array_map('array_to_xKey', $input)));

print_r($output);

Le résultat:

Array
(
    [0] => Array
        (
            [x] => 0.5
            [y] => 23
        )

    [1] => Array
        (
            [x] => 23
            [y] => 21.75
        )

    [2] => Array
        (
            [x] => 14.25
            [y] => 21.875
        )

    [3] => Array
        (
            [x] => 19.375
            [y] => 21.75
        )

    [4] => Array
        (
            [x] => 9.125
            [y] => 21.875
        )

)

Answer 3

Lors de l'exécution de vérifications itératives sur les tableaux, les performances glissent avec in_array() s'aggravera progressivement à mesure que la taille de votre tableau de recherche temporaire augmente.

Dans cette optique, utilisez des clés associatives temporaires pour identifier les doublons ultérieurs afin que !isset() peut être appelé sur votre variable de résultat croissante.Étant donné que les tableaux php sont des cartes de hachage, cette technique surpassera systématiquement in_array().

Il y a un piège avec ces clés temporaires qui s'applique spécifiquement à vos valeurs de type float. Lorsque les flottants sont utilisés comme clés de tableau, php les convertira en entiers en les tronquant ("plancher" et non "arrondi").Pour éviter cet effet secondaire indésirable, ajoutez un caractère non numérique (autre qu'un trait d'union, bien sûr) aux touches temporaires afin que le flottant devienne une chaîne.

Code:(Démo)

$array = [
    ['x' => 0.5, 'y' => 23],
    ['x' => 23, 'y' => 21.75],
    ['x' => 14.25, 'y' => 21.875],
    ['x' => 19.375, 'y' => 21.75],
    ['x' => 9.125, 'y' => 21.875], 
    ['x' => 23, 'y' => 19.625],
    ['x' => 19.375, 'y' => 19.625],
];

foreach ($array as $row) {
    if (!isset($result['#' . $row['y']])) {
        $result['#' . $row['y']] = $row;
    }
}
var_export(array_values($result));

Sortir:

array (
  0 => 
  array (
    'x' => 0.5,
    'y' => 23,
  ),
  1 => 
  array (
    'x' => 23,
    'y' => 21.75,
  ),
  2 => 
  array (
    'x' => 14.25,
    'y' => 21.875,
  ),
  3 => 
  array (
    'x' => 23,
    'y' => 19.625,
  ),
)

p.s.Si vous traitez des valeurs de chaîne ou des nombres entiers comme clés temporaires, il n'est pas nécessaire d'ajouter des caractères au début.Si vous ne vous souciez pas de supprimer les clés temporaires du résultat (parce que vous accédez uniquement aux valeurs du sous-tableau "down script", alors vous n'avez pas besoin d'appeler array_values() après avoir itéré.

Answer 4

array_unique(my_array, SORT_REGULAR)