PHP dizi değerine göre silme (anahtar değil)

Aşağıdaki gibi bir PHP dizisi var:

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

Değeri içeren öğeyi silmek istiyorum $del_val(örneğin, $del_val=401), ama anahtarını bilmiyorum. Bu yardımcı olabilir: her değer yalnızca bir kez orada olabilir .

Bu görevi gerçekleştirmek için en basit işlevi arıyorum, lütfen.

Kullanılması array_search()ve unsetaşağıdakileri deneyin:

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

array_search()bu öğeyi kullanarak orijinal diziden kaldırmak için kullanılabilen bulduğu öğenin anahtarını döndürür unset(). FALSEBaşarısızlığa dönecektir , ancak başarı üzerine yanlış-y değeri döndürebilir (anahtarınız 0örneğin olabilir ), bu yüzden katı karşılaştırma !==operatörü kullanılır.

if()İfadesi olmadığını kontrol edecek array_search()bir değer döndü ve yaptım keşke bir eylem gerçekleştirir.

Bir öğeyi diziden silmek temelde sadece bir öğeyle ayarlanan farktır .

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

Güzelce genelleştirir, isterseniz aynı anda istediğiniz kadar öğeyi kaldırabilirsiniz.

Feragatname: Benim çözümüm, dizinin yeni bir kopyasını oluştururken, eskisini değiştiren kabul edilen cevabın aksine sağlam tutar. İhtiyacınız olanı seçin.

İlginç bir yol array_keys():

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

array_keys()Fonksiyonu (Karşılaştırma için yani === kullanarak) belirli bir değeri için ve sıkı kontrol gerekli olup olmadığını sadece anahtarlarını dönmek için iki ek parametre alır.

Bu, aynı değere sahip birden fazla dizi öğesini de kaldırabilir (örn. [1, 2, 3, 3, 4]).

Dizinizin bu değere sahip yalnızca bir öğe içereceğini kesin olarak biliyorsanız,

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

Bununla birlikte, değeriniz dizinizde birden fazla ortaya çıkabilirse, bunu yapabilirsiniz

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

Not: İkinci seçenek yalnızca Kapanışlarla PHP5.3 + için çalışır

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

Aşağıdaki koda bir göz atın:

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

Yapabilirsin:

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

Ve bu size şu diziyi verecektir:

array('nice_item', 'another_liked_item')

En iyi yol array_splice

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

En İyinin Nedeni http://www.programmerinterview.com/index.php/php-questions/how-to-delete-an-element-from-an-array-in-php/ adresinde.

Veya basitçe, manuel yolla:

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

Bu en güvenli olanıdır, çünkü diziniz üzerinde tam kontrole sahipsiniz.

Aşağıdaki kodla, yinelenen değerler $ iletilerinden kaldırılacaktır.

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

PHP'niz varsa 5.3+, bir satır kodu vardır:

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

Çıktı

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

yapabilirsin:

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

Açıklama : 401Diziyi çevirdikten sonra anahtarı olan öğeyi silin .

Birden çok değeri silmek için şunu deneyin:

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

Alt çizginin mantığını ödünç aldı.JS _.reject ve iki fonksiyon yarattı (insanlar fonksiyonları tercih ediyor !!)

array_reject_value: Bu işlev belirtilen değeri basitçe reddediyor (PHP4,5,7 için de çalışıyor)

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

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

    return $filteredArray;
}

array_reject: Bu işlev sadece çağrılabilir yöntemi reddediyor (PHP> = 5.3 için çalışıyor)

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

    $filteredArray = array();

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

    return $filteredArray;
}

Mevcut örneğimizde yukarıdaki işlevleri aşağıdaki gibi kullanabiliriz:

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

hatta daha iyi: (bu bize daha iyi bir sözdizimi vermek olarak gibi kullanmak array_filter biri)

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

Yukarıdakiler, 401'e eşit veya daha büyük olan tüm değerleri kaldırmak istediğimizi varsayalım gibi daha karmaşık şeyler için kullanılabilir:

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

Bunu deneyin, Öğeyi değere göre kaldırmanın en iyi ve en hızlı yolu

@Bojangles cevabı bana yardımcı oldu. Teşekkür ederim.

Benim durumumda, dizi ilişkilendirilebilir veya değil olabilir, bu yüzden aşağıdaki işlevi ekledi

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
 }

}

Saygılarımızla

tek satırlık kod ( array_diff () sayesinde ) aşağıdakileri kullanın:

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

Kabul edilen cevap diziyi ilişkisel diziye dönüştürür, bu nedenle, kabul edilen cevabı ile ilişkisel olmayan bir dizi olarak tutmak isterseniz, bunu da kullanmanız gerekebilir array_values.

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

Referans burada

İhtiyacınıza göre , dizinizde benzersiz değerleri tutmak istiyorsanız, " her değer yalnızca bir kez olabilir ", ardındanarray_unique() aradığınız şey olabilir.

Giriş:

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

Sonuç:

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

Silmek istediğiniz değerler bir dizideyse veya olabiliyorsa. Array_diff işlevini kullanın . Böyle şeyler için harika çalışıyor gibi görünüyor.

array_diff

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

Bunun hiç etkili olmadığını biliyorum ama basit, sezgisel ve okunması kolay.
Birisi daha fazla değer veya daha spesifik koşullarla çalışmak için genişletilebilecek kadar süslü olmayan bir çözüm arıyorsa .. İşte basit bir kod:

$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

Dizi anahtarını ile alın array_search().

Eğer anahtarını bilmiyorsanız bunun bir önemi yok demektir.

Değeri anahtar olarak yerleştirebilirsiniz, bu değeri anında bulacağı anlamına gelir. Tüm öğelerde aramayı tekrar tekrar kullanmaktan daha iyidir.

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

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

orOperatörü kullanan bir astar :

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

bu URL'ye başvurabilirsiniz : işlev için

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

Sonra çıktı,

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

Bir dizinin değerini silmek için başka bir fikir, array_diff kullanın. Eğer istersem

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

(Doküman: http://php.net/manual/fr/function.array-diff.php )

Ben en basit yolu bir foreach döngü ile bir işlevi kullanmak olacağını düşünüyorum:

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

Çıktı:

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

PHP 7.4 ile ok fonksiyonlarını kullanma:

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

İlişkili olmayan bir dizi olarak tutmak için aşağıdakilerle sarın array_values():

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