PHP-Array nach Wert löschen (nicht Schlüssel)

Ich habe ein PHP-Array wie folgt:

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

Ich möchte das Element löschen, das den Wert enthält $del_val(zum Beispiel $del_val=401), aber ich kenne seinen Schlüssel nicht. Dies könnte helfen: Jeder Wert kann nur einmal vorhanden sein .

Ich suche nach der einfachsten Funktion, um diese Aufgabe auszuführen.

Mit array_search()und unset, versuchen Sie Folgendes:

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

array_search()Gibt den Schlüssel des gefundenen Elements zurück, mit dem dieses Element mithilfe von aus dem ursprünglichen Array entfernt werden kann unset(). Es wird FALSEbei einem Fehler zurückgegeben, kann jedoch bei Erfolg einen Falsch-Y-Wert zurückgeben (Ihr Schlüssel kann 0beispielsweise sein), weshalb der strikte Vergleichsoperator !==verwendet wird.

Die if()Anweisung prüft, ob array_search()ein Wert zurückgegeben wurde, und führt nur dann eine Aktion aus, wenn dies der Fall ist.

Nun, das Löschen eines Elements aus einem Array ist im Grunde nur ein Unterschied zwischen einem Element.

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

Es verallgemeinert sich gut, Sie können so viele Elemente gleichzeitig entfernen, wie Sie möchten, wenn Sie möchten.

Haftungsausschluss: Beachten Sie, dass meine Lösung eine neue Kopie des Arrays erstellt, während die alte intakt bleibt, im Gegensatz zu der akzeptierten Antwort, die mutiert. Wählen Sie die aus, die Sie benötigen.

Ein interessanter Weg ist die Verwendung von array_keys():

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

Die array_keys()Funktion benötigt zwei zusätzliche Parameter, um nur Schlüssel für einen bestimmten Wert zurückzugeben und um festzustellen, ob eine strikte Überprüfung erforderlich ist (dh === zum Vergleich verwenden).

Dies kann auch mehrere Array-Elemente mit demselben Wert entfernen (z [1, 2, 3, 3, 4]. B. ).

Wenn Sie sicher wissen, dass Ihr Array nur ein Element mit diesem Wert enthält, können Sie dies tun

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

Wenn Ihr Wert jedoch möglicherweise mehrmals in Ihrem Array vorkommt, können Sie dies tun

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

Hinweis: Die zweite Option funktioniert nur für PHP5.3 + mit Closures

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

Schauen Sie sich folgenden Code an:

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

Du kannst tun:

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

Und das bringt dir dieses Array:

array('nice_item', 'another_liked_item')

Der beste Weg ist array_splice

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

Grund für das Beste finden Sie hier unter http://www.programmerinterview.com/index.php/php-questions/how-to-delete-an-element-from-an-array-in-php/

Oder einfach manuell:

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

Dies ist die sicherste davon, da Sie die volle Kontrolle über Ihr Array haben

Mit dem folgenden Code werden die sich wiederholenden Werte aus den $ -Nachrichten entfernt.

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

Wenn Sie PHP haben 5.3+, gibt es den einzeiligen Code:

$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);

Ausgabe

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

du kannst tun:

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

Erläuterung : Löschen Sie das Element mit dem Schlüssel 401nach dem Umdrehen des Arrays.

Um mehrere Werte zu löschen, versuchen Sie Folgendes:

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

Leihte sich die Logik von Unterstrich.JS _.reject und erstellte zwei Funktionen (Leute bevorzugen Funktionen !!)

array_reject_value: Diese Funktion lehnt einfach den angegebenen Wert ab (funktioniert auch für 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: Diese Funktion lehnt einfach die aufrufbare Methode ab (funktioniert für 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;
}

In unserem aktuellen Beispiel können wir die obigen Funktionen wie folgt verwenden:

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

oder noch besser: (da dies uns eine bessere Syntax gibt, die wir wie die von array_filter verwenden können )

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

Das Obige kann für kompliziertere Dinge verwendet werden, wie zum Beispiel, wenn wir alle Werte entfernen möchten, die größer oder gleich 401 sind. Wir könnten dies einfach tun:

$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"; });

Versuchen Sie Folgendes: Dies ist der beste und schnellste Weg, um Elemente nach Wert zu entfernen

@ Bojangles Antwort hat mir geholfen. Vielen Dank.

In meinem Fall kann das Array assoziativ sein oder nicht, daher habe ich die folgende Funktion hinzugefügt

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
 }

}

Grüße

Einzeiliger Code (dank array_diff () ), verwenden Sie Folgendes:

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

Die akzeptierte Antwort konvertiert das Array in ein assoziatives Array. Wenn Sie es also als nicht assoziatives Array mit der akzeptierten Antwort beibehalten möchten, müssen Sie es möglicherweise auch verwenden array_values.

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

Die Referenz ist hier

Gemäß Ihrer Anforderung " Jeder Wert kann nur einmal vorhanden sein ", wenn Sie nur daran interessiert sind, eindeutige Werte in Ihrem Array beizubehalten, ist dies array_unique()möglicherweise das, wonach Sie suchen.

Eingang:

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

Ergebnis:

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

Wenn sich Werte, die Sie löschen möchten, in einem Array befinden oder befinden können. Verwenden Sie die Funktion array_diff . Scheint für solche Dinge großartig zu funktionieren.

array_diff

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

Ich weiß, dass dies überhaupt nicht effizient ist, aber einfach, intuitiv und leicht zu lesen ist.
Wenn also jemand nach einer nicht so ausgefallenen Lösung sucht, die erweitert werden kann, um mit mehr Werten oder spezifischeren Bedingungen zu arbeiten, dann ist hier ein einfacher Code:

$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

Holen Sie sich den Array-Schlüssel mit array_search().

Wenn Sie den Schlüssel nicht kennen, bedeutet dies, dass es keine Rolle spielt.

Sie können den Wert als Schlüssel eingeben. Dies bedeutet, dass der Wert sofort gefunden wird. Besser als die Suche in allen Elementen immer und immer wieder zu verwenden.

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

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

Ein Einzeiler mit dem orOperator:

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

Sie können auf diese URL verweisen : für die Funktion

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));
?>

Dann sollte die Ausgabe sein,

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

Eine andere Idee, um den Wert eines Arrays zu löschen, ist array_diff. Wenn ich will

$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 )

Ich denke, der einfachste Weg wäre, eine Funktion mit einer foreach-Schleife zu verwenden:

//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);

Ausgabe wird sein:

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)
}

Mit PHP 7.4 mit Pfeilfunktionen:

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

Um es als nicht assoziatives Array beizubehalten, umschließen Sie es mit array_values():

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