PHP kullanarak bir diziden bir öğeyi silmenin kolay bir yolu var mı foreach ($array)?

Bunu nullyapmanın bunu yapacağını düşündüm , ama görünüşe göre işe yaramıyor.

Bazıları belirli görevler için diğerlerinden daha yararlı olan bir dizi öğesini silmenin farklı yolları vardır.

Bir dizi öğesini silme

Yalnızca bir dizi öğesini silmek isterseniz unset()veya alternatif olarak kullanabilirsiniz \array_splice().

Ayrıca değere sahipseniz ve öğeyi silmek için anahtarı bilmiyorsanız, anahtarı \array_search()almak için kullanabilirsiniz .

unset()

unset()Dizi tuşlarını kullandığınızda / reindex değişmeyeceğini unutmayın. Daha \array_values()sonra kullanabileceğiniz tuşları yeniden endekslemek isterseniz, unset()tüm tuşları 0'dan başlayarak sayısal numaralandırılmış tuşlara dönüştürür.

kod

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    unset($array[1]);
                //↑ Key which you want to delete

?>

Çıktı

[
    [0] => a
    [2] => c
]

\array_splice() yöntem

Eğer \array_splice()anahtarları kullanırsanız otomatik olarak yeniden endekslenir, ancak ilişkilendirilebilir anahtarlar aksine \array_values()tüm anahtarları sayısal anahtarlara dönüştürür.

Ayrıca \array_splice()ofset, anahtar değil ihtiyacı var! ikinci parametre olarak.

kod

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    \array_splice($array, 1, 1);
                        //↑ Offset which you want to delete

?>

Çıktı

[
    [0] => a
    [1] => c
]

array_splice()unset()diziyi başvuru ile almakla aynıdır ve bu, bu işlevlerin dönüş değerlerini diziye geri atamak istemediğiniz anlamına gelir.

Birden çok dizi öğesini silme

Birden çok dizi öğesini silmek istiyorsanız unset()ve \array_splice()birden fazla kez aramak istemiyorsanız , işlevleri kullanmak için \array_diff()veya \array_diff_key()silmek istediğiniz öğelerin değerlerini veya tuşlarını biliyor olmanıza bağlı olarak kullanabilirsiniz .

\array_diff() yöntem

Silmek istediğiniz dizi öğelerinin değerlerini biliyorsanız, kullanabilirsiniz \array_diff(). Daha önce olduğu unset()gibi dizinin anahtarlarını değiştirmez / yeniden endekslemez.

kod

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff($array, ["a", "c"]);
                               //└────────┘→ Array values which you want to delete

?>

Çıktı

[
    [1] => b
]

\array_diff_key() yöntem

Silmek istediğiniz öğelerin tuşlarını biliyorsanız, kullanmak istersiniz \array_diff_key(). Burada, anahtarları değer olarak değil, ikinci parametrede anahtar olarak ilettiğinizden emin olmalısınız. Aksi takdirde, diziyi ile çevirmeniz gerekir \array_flip(). Ve ayrıca burada anahtarlar değişmez / yeniden endekslenmez.

kod

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
                                    //↑           ↑ Array keys which you want to delete
?>

Çıktı

[
    [1] => b
]

Ayrıca , aynı değere sahip birden çok öğeyi kullanmak unset()veya \array_splice()silmek istiyorsanız, \array_keys()belirli bir değerin tüm anahtarlarını almak ve sonra tüm öğeleri silmek için kullanabilirsiniz.

unset()Dize dizinlerini dokunulmadan tutacağına dikkat edilmelidir; bu, dize dizinlerini (hashtable olarak dizi) kullanırken beklediğiniz şeydir, ancak tamsayı dizinlenmiş dizilerle uğraşırken oldukça şaşırtıcı olabilir:

$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [3]=>
  int(3)
} */

$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

Yani array_splice()size tamsayı tuşları normalleştirmek isterseniz kullanılabilir. Başka bir seçenek kullanıyor array_values()sonra unset():

$array = array(0, 1, 2, 3);

unset($array[2]);
$array = array_values($array);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

  // Our initial array
  $arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");
  print_r($arr);

  // Remove the elements who's values are yellow or red
  $arr = array_diff($arr, array("yellow", "red"));
  print_r($arr);

Bu, yukarıdaki kodun çıktısıdır:

Array
(
    [0] => blue
    [1] => green
    [2] => red
    [3] => yellow
    [4] => green
    [5] => orange
    [6] => yellow
    [7] => indigo
    [8] => red
)

Array
(
    [0] => blue
    [1] => green
    [4] => green
    [5] => orange
    [7] => indigo
)

Şimdi, array_values ​​() sayısal bir diziyi güzel bir şekilde yeniden dizine ekler, ancak dizideki tüm anahtar dizeleri kaldırır ve sayılarla değiştirir. Anahtar adlarını (dizeleri) korumanız veya tüm anahtarlar sayısalsa diziyi yeniden endekslemeniz gerekiyorsa, array_merge () kullanın:

$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);

çıktılar

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)

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

unset($array[$index]);

Tüm değerlerin benzersiz olduğu (veya benzersiz olmayan ancak belirli bir değerin tüm örneklerini kaldırmak istediğiniz) sayısal olarak dizine alınmış bir diziniz varsa, bunun gibi eşleşen bir öğeyi kaldırmak için array_diff () yöntemini kullanabilirsiniz:

$my_array = array_diff($my_array, array('Value_to_remove'));

Örneğin:

$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);

Bu aşağıdakileri görüntüler:

4
3

Bu örnekte, 'Charles' değerine sahip öğe, ilk dizi için 4 ve kaldırıldıktan sonra 3 boyut bildiren sizeof () çağrıları ile doğrulanabildiği gibi kaldırılmıştır.

Ayrıca, adlandırılmış bir öğe için:

unset($array["elementName"]);

Bir dizinin tek bir öğesini yok etme

unset()

$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);

Çıktı şöyle olacaktır:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [3]=>
  string(1) "D"
  [4]=>
  string(1) "E"
}

Diziyi yeniden dizine eklemeniz gerekirse:

$array1 = array_values($array1);
var_dump($array1);

Sonra çıktı:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [2]=>
  string(1) "D"
  [3]=>
  string(1) "E"
}

Öğeyi dizinin sonuna getir - kaldırılan öğenin değerini döndür

mixed array_pop(array &$array)

$stack = array("orange", "banana", "apple", "raspberry");
$last_fruit = array_pop($stack);
print_r($stack);
print_r('Last Fruit:'.$last_fruit); // Last element of the array

Çıktı

Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
Last Fruit: raspberry

Bir dizideki ilk öğeyi (kırmızı) kaldırın , - kaldırılan öğenin değerini döndürün

mixed array_shift ( array &$array )

$color = array("a" => "red", "b" => "green" , "c" => "blue");
$first_color = array_shift($color);
print_r ($color);
print_r ('First Color: '.$first_color);

Çıktı şöyle olacaktır:

Array
(
    [b] => green
    [c] => blue
)
First Color: red

<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Çıktı:

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

Bir arama yapmaktan kaçınmak için aşağıdakilerle oynayabilirsiniz array_diff:

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

Bu durumda anahtarın aranması / kullanılması gerekmez.

Bir dizideki birden çok değeri silmeniz gerekiyorsa ve bu dizideki girdiler nesne veya yapılandırılmış verilerse, [array_filter][1]en iyi seçenektir. Geri arama işlevinden true döndüren girişler korunur.

$array = [
    ['x'=>1,'y'=>2,'z'=>3], 
    ['x'=>2,'y'=>4,'z'=>6], 
    ['x'=>3,'y'=>6,'z'=>9]
];

$results = array_filter($array, function($value) {
    return $value['x'] > 2; 
}); //=> [['x'=>3,'y'=>6,z=>'9']]

İlişkilendirilebilir diziler

İlişkilendirilebilir diziler için şunu kullanın unset:

$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);

// RESULT: array('a' => 1, 'c' => 3)

Sayısal diziler

Sayısal diziler için şunu kullanın array_splice:

$arr = array(1, 2, 3);
array_splice($arr, 1, 1);

// RESULT: array(0 => 1, 1 => 3)

Not

unsetSayısal diziler için kullanmak hata üretmez, ancak dizinlerinizi bozar:

$arr = array(1, 2, 3);
unset($arr[1]);

// RESULT: array(0 => 1, 2 => 3)

İlişkilendirilebilir bir diziden birden çok öğeyi kaldırmanız gerekirse, array_diff_key () (burada array_flip () ile birlikte kullanılır ) kullanabilirsiniz:

$my_array = array(
  "key1" => "value 1",
  "key2" => "value 2",
  "key3" => "value 3",
  "key4" => "value 4",
  "key5" => "value 5",
);

$to_remove = array("key2", "key4");

$result = array_diff_key($my_array, array_flip($to_remove));

print_r($result);

Çıktı:

Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 ) 

unset() belirtilen değişkenleri yok eder.

unset()Bir işlevin içindeki davranışı, yok etmeye çalıştığınız değişken türüne bağlı olarak değişebilir.

Genelleştirilmiş bir değişken unset()bir işlevin içindeyse, yalnızca yerel değişken yok edilir. Çağıran ortamdaki değişken, önceki çağrıyla aynı değeri korur unset().

<?php
    function destroy_foo()
    {
        global $foo;
        unset($foo);
    }

    $foo = 'bar';
    destroy_foo();
    echo $foo;
?>

Yukarıdaki kodun cevabı bar olacaktır .

To unset()fonksiyonun global bir değişken iç:

<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

    $bar = "something";
    foo();
?>

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

Dizin belirtilirse:

$arr = ['a', 'b', 'c'];
$index = 0;    
unset($arr[$index]);  // $arr = ['b', 'c']

Dizin belirtilmezse:

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

ifÇünkü eğer koşul gereklidir indexbulunamazsa, unset()otomatik istediğimiz değil budur dizinin ilk elemanını siler

Çözümler:

1. Bir öğeyi silmek için unset () kullanın :

unset($array[3]);
unset($array['foo']);

2. Birden fazla bitişik olmayan öğeyi silmek için ayrıca unset () kullanın :

unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);

3. Birden fazla bitişik öğeyi silmek için array_splice () kullanın :

array_splice($array, $offset, $length);

Daha fazla açıklama:

Bu işlevlerin kullanılması, bu öğelere yapılan tüm başvuruları PHP'den kaldırır. Dizide bir anahtarı ancak boş bir değerle tutmak istiyorsanız, öğeye boş dizeyi atayın:

$array[3] = $array['foo'] = '';

Sözdiziminin yanı sıra, unset () kullanımı ile öğeye '' atama arasında mantıklı bir fark vardır . İlk söylerken This doesn't exist anymore,ikinci söylerkenThis still exists, but its value is the empty string.

Rakamlarla uğraşıyorsanız, 0 atamak daha iyi bir alternatif olabilir. Dolayısıyla, bir şirket XL1000 zincir dişlisinin üretimini durdurduysa, envanterini şu şekilde güncelleyecektir:

unset($products['XL1000']);

Bununla birlikte, geçici olarak XL1000 zincir dişlileri tükendiyse, ancak bu haftadan sonra tesisden yeni bir sevkiyat almayı planlıyordu, bu daha iyi:

$products['XL1000'] = 0;

Bir öğeyi unset () yaparsanız , PHP diziyi döngü hala düzgün çalışacak şekilde ayarlar. Eksik delikleri doldurmak için diziyi sıkıştırmaz. Tüm dizilerin birleştirici olduğunu söylediğimizde, sayısal gibi görünseler de bunu kastediyoruz. İşte bir örnek:

// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
print $animals[1];  // Prints 'bee'
print $animals[2];  // Prints 'cat'
count($animals);    // Returns 6

// unset()
unset($animals[1]); // Removes element $animals[1] = 'bee'
print $animals[1];  // Prints '' and throws an E_NOTICE error
print $animals[2];  // Still prints 'cat'
count($animals);    // Returns 5, even though $array[5] is 'fox'

// Add a new element
$animals[ ] = 'gnu'; // Add a new element (not Unix)
print $animals[1];  // Prints '', still empty
print $animals[6];  // Prints 'gnu', this is where 'gnu' ended up
count($animals);    // Returns 6

// Assign ''
$animals[2] = '';   // Zero out value
print $animals[2];  // Prints ''
count($animals);    // Returns 6, count does not decrease

Diziyi yoğun olarak doldurulmuş bir sayısal diziye sıkıştırmak için dizi_değerleri () kullanın :

$animals = array_values($animals);

Alternatif olarak, array_splice () , delik bırakmamak için dizileri otomatik olarak yeniden dizine ekler :

// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
array_splice($animals, 2, 2);
print_r($animals);
Array
(
    [0] => ant
    [1] => bee
    [2] => elk
    [3] => fox
)

Diziyi kuyruk olarak kullanıyorsanız ve hala rasgele erişime izin verirken öğeleri kuyruktan kaldırmak istiyorsanız bu yararlıdır. Bir dizideki ilk veya son öğeyi güvenle kaldırmak için , sırasıyla array_shift () ve array_pop () kullanın .

Aşağıdaki diziye sahip olduğunuzu varsayalım:

Array
(
    [user_id] => 193
    [storage] => 5
)

Silmek storageiçin şunları yapın:

unset($attributes['storage']);
$attributes = array_filter($attributes);

Ve şunu elde edersiniz:

Array
(
    [user_id] => 193
)

Ben sadece değişken özniteliklere sahip belirli bir nesne olduğunu söylemek istiyorum (temelde bir tablo eşleme ve tablodaki sütunları değiştiriyordum, bu yüzden nesneyi, tabloyu yansıtan öznitelikleri de değişir):

class obj {
    protected $fields = array('field1','field2');
    protected $field1 = array();
    protected $field2 = array();
    protected loadfields(){}
    // This will load the $field1 and $field2 with rows of data for the column they describe
    protected function clearFields($num){
        foreach($fields as $field) {
            unset($this->$field[$num]);
            // This did not work the line below worked
            unset($this->{$field}[$num]); // You have to resolve $field first using {}
        }
    }
}

Tüm amacı $fieldssadece, bu yüzden onlar değiştiğinde kodun her yerine bakmak zorunda değilsiniz, ben sadece sınıfın başlangıcına bakmak ve yeni ve yansıtmak için öznitelikler listesini ve $ fields dizi içeriği değiştirmek Öznitellikler.

Varsayılan işlevleri izleyin:

ben)

$Array = array("test1", "test2", "test3", "test3");

unset($Array[2]);

ii)

$Array = array("test1", "test2", "test3", "test3");

array_pop($Array);

iii)

$Array = array("test1", "test2", "test3", "test3");

array_splice($Array,1,2);

iv)

$Array = array("test1", "test2", "test3", "test3");

array_shift($Array);

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Değişkeni içinde dizinizi oluşturun $arrayve sonra 'silmek istediğiniz öğeyi' koyduğunuz yere şöyle bir şey koyarsınız: "a". Birden çok öğeyi silmek istiyorsanız: "a", "b".

Anahtarı almak için array_search komutunu kullanın ve bulunursa unset ile kaldırın:

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

bir diziden çoklu, parçalanmış öğeleri unset ()

İken unset()burada sözü edilen birkaç kez edilmiştir vardır, bu henüz o sözü zorundadır unset()birden değişkenler silme birden, tek operasyonda bir diziden bitişik olmayan elemanların kolay yapma kabul etmektedir:

// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]

dinamik olarak unset ()

unset (), kaldırılacak bir anahtar dizisini kabul etmez, bu nedenle aşağıdaki kod başarısız olur (unset () öğesini dinamik olarak kullanmayı biraz daha kolay hale getirir).

$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);

Bunun yerine, unset () bir foreach döngüsünde dinamik olarak kullanılabilir:

$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
    unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]

Diziyi kopyalayarak dizi anahtarlarını kaldırma

Daha önce değinilmemiş başka bir uygulama daha vardır. Bazen, belirli dizi anahtarlarından kurtulmanın en basit yolu $ array1'i $ array2'ye kopyalamaktır.

$array1 = range(1,10);
foreach ($array1 as $v) {
    // Remove all even integers from the array
    if( $v % 2 ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 1, 3, 5, 7, 9 ];

Açıkçası, aynı uygulama metin dizeleri için de geçerlidir:

$array1 = [ 'foo', '_bar', 'baz' ];
foreach ($array1 as $v) {
    // Remove all strings beginning with underscore
    if( strpos($v,'_')===false ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 'foo', 'baz' ]

Bir anahtara dayalı olarak bir dizi öğesini kaldırma:

unsetAşağıdaki gibi işlevi kullanın :

$a = array(
       'salam',
       '10',
       1
);

unset($a[1]);

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

Bir dizi öğesini değere göre kaldırın:

array_searchBir eleman anahtarı almak için işlevi kullanın ve aşağıdaki gibi bir dizi öğesini kaldırmak için yukarıdaki yolu kullanın:

$a = array(
       'salam',
       '10',
       1
);

$key = array_search(10, $a);

if ($key !== false) {
    unset($a[$key]);
}

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

Dizinin ilk öğesini dizinin sırasına göre kaldırmak için ve ayrıca ilk öğenin anahtar adını bilmiyorsanız iki yol.

Çözüm # 1

// 1 is the index of the first object to get
// NULL to get everything until the end
// true to preserve keys
$array = array_slice($array, 1, null, true);

Çözüm # 2

// Rewinds the array's internal pointer to the first element
// and returns the value of the first array element.
$value = reset($array);
// Returns the index element of the current array position
$key = key($array);
unset($array[$key]);

Bu örnek veriler için:

$array = array(10 => "a", 20 => "b", 30 => "c");

Bu sonuca sahip olmalısınız:

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}

Aşağıdaki kodu kullanın:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);

<?php
    // If you want to remove a particular array element use this method
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");

    print_r($my_array);
    if (array_key_exists("key1", $my_array)) {
        unset($my_array['key1']);
        print_r($my_array);
    }
    else {
        echo "Key does not exist";
    }
?>

<?php
    //To remove first array element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1);
    print_r($new_array);
?>


<?php
    echo "<br/>    ";
    // To remove first array element to length
    // starts from first and remove two element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1, 2);
    print_r($new_array);
?>

Çıktı

 Array ( [key1] => value 1 [key2] => value 2 [key3] =>
 value 3 ) Array (    [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )

Tamsayı olmayan tuşlarla ilişkilendirilebilir diziler için:

Basitçe, unset($array[$key])işe yarar.

Tamsayı tuşlarına sahip diziler için ve anahtarlarınızı korumak istiyorsanız:

1. $array = [ 'mango', 'red', 'orange', 'grapes'];

   unset($array[2]);
   $array = array_values($array);

2. array_splice($array, 2, 1);

Bu yardımcı olabilir ...

<?php
    $a1 = array("a"=>"red", "b"=>"green", "c"=>"blue", "d"=>"yellow");
    $a2 = array("a"=>"purple", "b"=>"orange");
    array_splice($a1, 0, 2, $a2);
    print_r($a1);
?>

Sonuç:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);