Suppression de tableau PHP par valeur (pas par clé)

J'ai un tableau PHP comme suit:

$messages = [312, 401, 1599, 3, ...];

Je veux supprimer l'élément contenant la valeur $del_val(par exemple, $del_val=401), mais je ne connais pas sa clé. Cela pourrait aider: chaque valeur ne peut être présente qu'une seule fois .

Je recherche la fonction la plus simple pour effectuer cette tâche, s'il vous plaît.

À l'aide de array_search()et unset, essayez ce qui suit:

if (($key = array_search($del_val, $messages)) !== false) {
    unset($messages[$key]);
}

array_search()renvoie la clé de l'élément qu'il trouve, qui peut être utilisée pour supprimer cet élément du tableau d'origine à l'aide de unset(). Il retournera FALSEen cas d'échec, mais il peut retourner une valeur faux-y en cas de succès (votre clé peut être 0par exemple), c'est pourquoi l' !==opérateur de comparaison strict est utilisé.

L' if()instruction vérifie si array_search()une valeur a été renvoyée et n'exécute une action que si elle l'a fait.

Eh bien, la suppression d'un élément du tableau est fondamentalement juste la différence avec un élément.

array_diff( [312, 401, 15, 401, 3], [401] ) // removing 401 returns [312, 15, 3]

Il généralise bien, vous pouvez supprimer autant d'éléments que vous le souhaitez en même temps, si vous le souhaitez.

Avertissement: Notez que ma solution produit une nouvelle copie du tableau tout en conservant l'ancien contrairement à la réponse acceptée qui mute. Choisissez celui dont vous avez besoin.

Une façon intéressante consiste à utiliser array_keys():

foreach (array_keys($messages, 401, true) as $key) {
    unset($messages[$key]);
}

La array_keys()fonction prend deux paramètres supplémentaires pour renvoyer uniquement les clés pour une valeur particulière et si une vérification stricte est requise (c'est-à-dire en utilisant === pour la comparaison).

Cela peut également supprimer plusieurs éléments de tableau avec la même valeur (par exemple [1, 2, 3, 3, 4]).

Si vous savez pour sûr que votre tableau ne contiendra qu'un seul élément avec cette valeur, vous pouvez le faire

$key = array_search($del_val, $array);
if (false !== $key) {
    unset($array[$key]);
}

Si, cependant, votre valeur peut apparaître plusieurs fois dans votre tableau, vous pouvez le faire

$array = array_filter($array, function($e) use ($del_val) {
    return ($e !== $del_val);
});

Remarque: La deuxième option ne fonctionne que pour PHP5.3 + avec fermetures

$fields = array_flip($fields);
unset($fields['myvalue']);
$fields = array_flip($fields);

Jetez un œil au code suivant:

$arr = array('nice_item', 'remove_me', 'another_liked_item', 'remove_me_also');

Tu peux faire:

$arr = array_diff($arr, array('remove_me', 'remove_me_also'));

Et cela vous donnera ce tableau:

array('nice_item', 'another_liked_item')

La meilleure façon est array_splice

array_splice($array, array_search(58, $array ), 1);

Reason for Best est ici sur http://www.programmerinterview.com/index.php/php-questions/how-to-delete-an-element-from-an-array-in-php/

Ou simplement, de manière manuelle:

foreach ($array as $key => $value){
    if ($value == $target_value) {
        unset($array[$key]);
    }
}

C'est le plus sûr d'entre eux car vous avez un contrôle total sur votre baie

Par le code suivant, les valeurs répétitives seront supprimées des messages $.

$messages = array_diff($messages, array(401));

Si vous avez PHP 5.3+, il y a le code d'une ligne:

$array = array_filter($array, function ($i) use ($value) { return $i !== $value; }); 

function array_remove_by_value($array, $value)
{
    return array_values(array_diff($array, array($value)));
}

$array = array(312, 401, 1599, 3);

$newarray = array_remove_by_value($array, 401);

print_r($newarray);

Production

Array ( [0] => 312 [1] => 1599 [2] => 3 )

tu peux faire:

unset($messages[array_flip($messages)['401']]);

Explication : supprimez l'élément qui possède la clé 401après avoir inversé le tableau.

Pour supprimer plusieurs valeurs, essayez celle-ci:

while (($key = array_search($del_val, $messages)) !== false) 
{
    unset($messages[$key]);
}

Emprunté la logique de underscore.JS _.reject et créé deux fonctions (les gens préfèrent les fonctions !!)

array_reject_value: Cette fonction rejette simplement la valeur spécifiée (fonctionne également pour PHP4,5,7)

function array_reject_value(array &$arrayToFilter, $deleteValue) {
    $filteredArray = array();

    foreach ($arrayToFilter as $key => $value) {
        if ($value !== $deleteValue) {
            $filteredArray[] = $value;
        }
    }

    return $filteredArray;
}

array_reject: Cette fonction rejette simplement la méthode appelable (fonctionne pour PHP> = 5.3)

function array_reject(array &$arrayToFilter, callable $rejectCallback) {

    $filteredArray = array();

    foreach ($arrayToFilter as $key => $value) {
        if (!$rejectCallback($value, $key)) {
            $filteredArray[] = $value;
        }
    }

    return $filteredArray;
}

Ainsi, dans notre exemple actuel, nous pouvons utiliser les fonctions ci-dessus comme suit:

$messages = [312, 401, 1599, 3, 6];
$messages = array_reject_value($messages, 401);

ou encore mieux: (car cela nous donne une meilleure syntaxe à utiliser comme celle de array_filter )

$messages = [312, 401, 1599, 3, 6];
$messages = array_reject($messages, function ($value) {
    return $value === 401;
});

Ce qui précède peut être utilisé pour des choses plus compliquées comme disons que nous aimerions supprimer toutes les valeurs supérieures ou égales à 401, nous pourrions simplement le faire:

$messages = [312, 401, 1599, 3, 6];
$greaterOrEqualThan = 401;
$messages = array_reject($messages, function ($value) use $greaterOrEqualThan {
    return $value >= $greaterOrEqualThan;
});

$array = array("apple", "banana",'mango');
$array = array_filter($array, function($v) { return $v != "apple"; });

Essayez ceci, c'est le moyen le meilleur et le plus rapide pour supprimer l'élément par valeur

La réponse @Bojangles m'a aidé. Je vous remercie.

Dans mon cas, le tableau peut être associatif ou non, j'ai donc ajouté la fonction suivante

function test($value, $tab) {

 if(($key = array_search($value, $tab)) !== false) {
    unset($tab[$key]); return true;

 } else if (array_key_exists($value, $tab)){
        unset($tab[$value]); return true;

 } else {
    return false; // the $value is not in the array $tab
 }

}

Cordialement

code simple (grâce à array_diff () ), utilisez ce qui suit:

$messages = array_diff($messages, array(401));

La réponse acceptée convertit le tableau en tableau associatif, donc, si vous souhaitez le conserver en tant que tableau non associatif avec la réponse acceptée, vous devrez peut-être array_valueségalement l' utiliser .

if(($key = array_search($del_val, $messages)) !== false) {
    unset($messages[$key]);
    $arr = array_values($messages);
}

La référence est ici

Selon votre exigence " chaque valeur ne peut être là que pour une fois " si vous êtes simplement intéressé à conserver des valeurs uniques dans votre tableau, alors c'est array_unique()peut-être ce que vous recherchez.

Contribution:

$input = array(4, "4", "3", 4, 3, "3");
$result = array_unique($input);
var_dump($result);

Résultat:

array(2) {
  [0] => int(4)
  [2] => string(1) "3"
}

Si les valeurs que vous souhaitez supprimer sont ou peuvent être dans un tableau. Utilisez la fonction array_diff . Semble fonctionner très bien pour des choses comme ça.

array_diff

$arrayWithValuesRemoved = array_diff($arrayOfData, $arrayOfValuesToRemove);

Je sais que ce n'est pas efficace du tout mais c'est simple, intuitif et facile à lire.
Donc, si quelqu'un cherche une solution pas si sophistiquée qui peut être étendue pour fonctionner avec plus de valeurs ou des conditions plus spécifiques .. voici un code simple:

$result = array();
$del_value = 401;
//$del_values = array(... all the values you don`t wont);

foreach($arr as $key =>$value){
    if ($value !== $del_value){
        $result[$key] = $value;
    }

    //if(!in_array($value, $del_values)){
    //    $result[$key] = $value;
    //}

    //if($this->validete($value)){
    //      $result[$key] = $value;
    //}
}

return $result

Obtenez la clé du tableau avec array_search().

Si vous ne connaissez pas sa clé, cela signifie que cela n'a pas d'importance.

Vous pouvez placer la valeur comme clé, cela signifie qu'elle trouvera instantanément la valeur. Mieux que d'utiliser la recherche dans tous les éléments encore et encore.

$messages=array();   
$messages[312] = 312;    
$messages[401] = 401;   
$messages[1599] = 1599;   
$messages[3] = 3;    

unset($messages[3]); // no search needed

Un one-liner utilisant l' oropérateur:

($key = array_search($del_val, $messages)) !== false or unset($messages[$key]);

vous pouvez référer cette URL : pour la fonction

array-diff-key()

<?php
$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);

var_dump(array_diff_key($array1, $array2));
?>

La sortie devrait alors être,

array(2) {
  ["red"]=>
  int(2)
  ["purple"]=>
  int(4)
}

Une autre idée pour supprimer la valeur d'un tableau, utilisez array_diff. Si je veux

$my_array = array(1=>"a", "second_value"=>"b", 3=>"c", "d");
$new_array_without_value_c = array_diff($my_array, array("c"));

(Doc: http://php.net/manual/fr/function.array-diff.php )

Je pense que la manière la plus simple serait d'utiliser une fonction avec une boucle foreach:

//This functions deletes the elements of an array $original that are equivalent to the value $del_val
//The function works by reference, which means that the actual array used as parameter will be modified.

function delete_value(&$original, $del_val)
{
    //make a copy of the original, to avoid problems of modifying an array that is being currently iterated through
    $copy = $original;
    foreach ($original as $key => $value)
    {
        //for each value evaluate if it is equivalent to the one to be deleted, and if it is capture its key name.
        if($del_val === $value) $del_key[] = $key;
    };
    //If there was a value found, delete all its instances
    if($del_key !== null)
    {
        foreach ($del_key as $dk_i)
        {
            unset($original[$dk_i]);
        };
        //optional reordering of the keys. WARNING: only use it with arrays with numeric indexes!
        /*
        $copy = $original;
        $original = array();
        foreach ($copy as $value) {
            $original[] = $value;
        };
        */
        //the value was found and deleted
        return true;
    };
    //The value was not found, nothing was deleted
    return false;
};

$original = array(0,1,2,3,4,5,6,7,4);
$del_val = 4;
var_dump($original);
delete_value($original, $del_val);
var_dump($original);

La sortie sera:

array(9) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(2)
  [3]=>
  int(3)
  [4]=>
  int(4)
  [5]=>
  int(5)
  [6]=>
  int(6)
  [7]=>
  int(7)
  [8]=>
  int(4)
}
array(7) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(2)
  [3]=>
  int(3)
  [5]=>
  int(5)
  [6]=>
  int(6)
  [7]=>
  int(7)
}

Avec PHP 7.4 en utilisant les fonctions fléchées:

$messages = array_filter($messages, fn ($m) => $m != $del_val);

Pour le conserver dans un tableau non associatif, enveloppez-le avec array_values():

$messages = array_values(array_filter($messages, fn ($m) => $m != $del_val));