PHP: किसी सरणी से तत्व हटाएं




arrays (20)

PHP का उपयोग कर किसी सरणी से तत्व को हटाने का कोई आसान तरीका है, जैसे कि foreach ($array) अब उस तत्व को शामिल नहीं किया गया है?

मैंने सोचा कि इसे null करने के लिए इसे स्थापित करना होगा, लेकिन स्पष्ट रूप से यह काम नहीं करता है।

https://code.i-harness.com


अनसेट करें इंडेक्स को न बदलें लेकिन array_splice करता है

$anArray = array("X", "Y", "Z");

unset($anArray[0]);

//'dumps' the content of $anArray to the page:
var_dump($anArray);  

एक सरणी से कई, खंडित तत्व अनसेट ()

अनसेट () का उल्लेख कई बार किया गया है, लेकिन अभी तक यह उल्लेख नहीं किया गया है कि अनसेट () कई चर स्वीकार करता है जिससे एक ऑपरेशन में एक सरणी से एकाधिक, गैर-विशिष्ट तत्वों को हटाना आसान हो जाता है:

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

गतिशील रूप से अनसेट ()

अनसेट () को हटाने के लिए कुंजियों की एक सरणी स्वीकार नहीं करता है, इसलिए नीचे दिया गया कोड असफल हो जाएगा (हालांकि यह गतिशील रूप से अनसेट () को उपयोग करने में थोड़ा आसान बना देता है)।

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

इसके बजाय, अनसेट () को फ़ोरैच लूप में गतिशील रूप से उपयोग किया जा सकता है:

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

सरणी की प्रतिलिपि करके सरणी कुंजियां निकालें

एक और अभ्यास भी है जिसका अभी तक उल्लेख किया जाना बाकी है। कभी-कभी, कुछ सरणी कुंजियों से छुटकारा पाने का सबसे आसान तरीका है $ array1 को $ array2 में कॉपी करना।

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

जाहिर है, वही अभ्यास पाठ तारों पर लागू होता है:

$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' ]

आप सरणी को हटाने के लिए बस unset() का उपयोग कर सकते हैं।

याद रखें कि foreach फ़ंक्शन के बाद सरणी को अनसेट होना चाहिए।


इसके अलावा, नामित तत्व के लिए:

unset($array["elementName"]);

गैर पूर्णांक कुंजी के साथ, सहयोगी सरणी के लिए:

बस, unset($array[$key]) काम करेगा।

पूर्णांक कुंजी वाले सरणी के लिए और यदि आप अपनी चाबियाँ बनाए रखना चाहते हैं:

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

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

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

डिफ़ॉल्ट कार्यों का पालन करें

i)

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

मैं बस कहना चाहूंगा कि मेरे पास एक विशेष ऑब्जेक्ट था, जिसमें परिवर्तनीय गुण थे (यह मूल रूप से एक टेबल मैप कर रहा था और मैं तालिका में कॉलम बदल रहा था, इसलिए तालिका में प्रतिबिंबित करने वाले ऑब्जेक्ट में गुण अलग-अलग होंगे

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

$ फ़ील्ड का पूरा उद्देश्य बस इतना था कि जब कोड बदलते हैं तो मुझे कोड में हर जगह देखने की ज़रूरत नहीं है, मैं बस कक्षा की शुरुआत को देखता हूं और गुणों की सूची बदलता हूं और $ फ़ील्ड सरणी सामग्री को प्रतिबिंबित करता हूं नए गुण

इसे समझने के लिए मुझे थोड़ी देर लग गई। उम्मीद है कि यह किसी की मदद कर सकता है।


यदि आपके पास संख्यात्मक रूप से अनुक्रमित सरणी है जहां सभी मान अद्वितीय हैं (या वे अनूठे हैं लेकिन आप किसी विशेष मान के सभी उदाहरणों को हटाना चाहते हैं), तो आप मिलान तत्व को निकालने के लिए array_diff () का उपयोग कर सकते हैं, जैसे:

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

उदाहरण के लिए:

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

यह निम्नलिखित प्रदर्शित करता है:

4
3

इस उदाहरण में, 'चार्ल्स' मान वाले तत्व को हटा दिया गया है जिसे आकार () कॉल द्वारा सत्यापित किया जा सकता है जो प्रारंभिक सरणी के लिए 4 के आकार की रिपोर्ट करता है, और हटाने के बाद 3।


यदि आपको किसी सरणी में एकाधिक मानों को हटाना है और उस सरणी में प्रविष्टियां ऑब्जेक्ट्स या संरचित डेटा हैं, [array_filter][1] आपकी सबसे अच्छी शर्त है। वे प्रविष्टियां जो कॉलबैक फ़ंक्शन से सत्य लौटती हैं उन्हें बरकरार रखा जाएगा।

$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']]

यह ध्यान दिया जाना चाहिए कि unset() इंडेक्स को छूटे रखेगा, जो स्ट्रिंग इंडेक्स (हैशटेबल के रूप में सरणी) का उपयोग करते समय आप अपेक्षा करेंगे, लेकिन पूर्णांक अनुक्रमित सरणी से निपटने पर काफी आश्चर्यजनक हो सकता है:

$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)
} */

इसलिए यदि आप अपनी पूर्णांक कुंजी को सामान्य करना चाहते हैं तो array_splice() का उपयोग किया जा सकता है। एक और विकल्प unset() बाद array_values() का उपयोग कर रहा है:

$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)
} */

सरणी तत्व को हटाने के विभिन्न तरीके हैं, जहां कुछ दूसरों के मुकाबले कुछ विशिष्ट कार्यों के लिए अधिक उपयोगी होते हैं।

एक सरणी तत्व हटाएं

यदि आप केवल एक सरणी तत्व को हटाना चाहते हैं तो आप unset() या वैकल्पिक array_splice() उपयोग कर सकते हैं।

इसके अलावा यदि आपके पास मूल्य है और तत्व को हटाने की कुंजी नहीं है तो आप कुंजी प्राप्त करने के लिए array_search() का उपयोग कर सकते हैं।

unset() विधि

ध्यान दें कि जब आप unset() का उपयोग करते हैं तो सरणी कुंजियां / reindex नहीं बदलेगी। यदि आप कुंजी को array_values() करना चाहते हैं तो आप unset() बाद array_values() उपयोग कर सकते हैं जो सभी कुंजियों को 0 से शुरू होने वाली संख्यात्मक गणना वाली कुंजी में परिवर्तित कर देगा।

कोड

<?php

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

?>

उत्पादन

Array (
    [0] => a
    [2] => c
)

array_splice() विधि

यदि आप array_splice() का उपयोग करते हैं तो कुंजी स्वचालित रूप से array_values() हो array_values() , लेकिन एसोसिएटिव कुंजी array_values() विपरीत नहीं बदलेगी जो सभी कुंजियों को संख्यात्मक कुंजी में परिवर्तित कर देगी।

इसके अलावा array_splice() ऑफसेट की आवश्यकता है, कुंजी नहीं! दूसरे पैरामीटर के रूप में।

कोड

<?php

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

?>

उत्पादन

Array (
    [0] => a
    [1] => c
)

array_splice() को unset() समान unset() संदर्भ के अनुसार सरणी लेते हैं, इसका मतलब है कि आप उन कार्यों के रिटर्न मानों को सरणी में वापस असाइन नहीं करना चाहते हैं।

एकाधिक सरणी तत्व हटाएं

यदि आप एकाधिक सरणी तत्वों को हटाना चाहते हैं और unset() या array_splice() कई बार कॉल नहीं करना चाहते हैं तो आप तत्वों के मान या कुंजी को जानते हैं, तो आप कार्यों array_diff() या array_diff_key() उपयोग कर सकते हैं। आप हटाना चाहते हैं।

array_diff() विधि

यदि आप उन सरणी तत्वों के मानों को जानते हैं जिन्हें आप हटाना चाहते हैं, तो आप array_diff() उपयोग कर सकते हैं। पहले से unset() यह सरणी की चाबियाँ / reindex नहीं बदलेगा।

कोड

<?php

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

?>

उत्पादन

Array (
    [1] => b
)

array_diff_key() विधि

यदि आप उन तत्वों की कुंजी जानते हैं जिन्हें आप हटाना चाहते हैं, तो आप array_diff_key() का उपयोग करना चाहते हैं। यहां आपको यह सुनिश्चित करना होगा कि आप कुंजी को दूसरे पैरामीटर में चाबियों के रूप में पास करें और मान के रूप में नहीं। अन्यथा, आपको array_flip() साथ सरणी को फ़्लिप करना होगा। और यहां भी चाबियाँ / रीइन्डेक्स नहीं बदलेगी।

कोड

<?php

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

उत्पादन

Array (
    [1] => b
)

इसके अलावा यदि आप एक ही मान वाले एकाधिक तत्वों को हटाने के लिए unset() या array_splice() का उपयोग करना चाहते हैं तो आप एक विशिष्ट मान के लिए सभी कुंजी प्राप्त करने के लिए array_keys() का उपयोग कर सकते हैं और फिर सभी तत्वों को हटा सकते हैं।


unset() निर्दिष्ट चर को नष्ट कर देता है।

फ़ंक्शन के अंदर unset() का व्यवहार इस प्रकार के भिन्नता के आधार पर भिन्न हो सकता है कि आप किस प्रकार के चर को नष्ट करने का प्रयास कर रहे हैं।

यदि एक वैश्वीकृत चर एक फ़ंक्शन के अंदर unset() है, तो केवल स्थानीय चर नष्ट हो जाता है। कॉलिंग वातावरण में परिवर्तनीय वही मान बनाए रखेगा जैसा कि पहले unset() कहा जाता था।

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

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

उपरोक्त कोड का उत्तर बार होगा

फ़ंक्शन के अंदर एक वैश्विक चर को unset() करने के लिए

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

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

कुंजी के आधार पर एक सरणी तत्व निकालें:

नीचे की तरह unset फ़ंक्शन का उपयोग करें:

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

unset( $a[1] );

print_r( $a );

/*

Output:

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

*/

मूल्य के आधार पर एक सरणी तत्व निकालें:

तत्व कुंजी प्राप्त करने के लिए array_search फ़ंक्शन का उपयोग करें और नीचे दिए गए सरणी तत्व को निकालने के लिए उपरोक्त तरीके से उपयोग करें:

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

*/

समाधान की:

  1. एक तत्व को हटाने के लिए, unset() उपयोग करें:
unset($array[3]);
unset($array['foo']);
  1. एकाधिक गैर-संयोजी तत्वों को हटाने के लिए, unset() का भी उपयोग करें:
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. एकाधिक संगत तत्वों को हटाने के लिए, array_splice() उपयोग करें:
array_splice($array, $offset, $length);

आगे की व्याख्या:

इन कार्यों का उपयोग PHP से इन तत्वों के सभी संदर्भों को हटा देता है। यदि आप सरणी में एक कुंजी रखना चाहते हैं, लेकिन खाली मान के साथ, तत्व को खाली स्ट्रिंग असाइन करें:

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

वाक्यविन्यास के अलावा, unset() का उपयोग करने और तत्व को '' असाइन करने के बीच एक तार्किक अंतर है। पहला कहता है कि This doesn't exist anymore, जबकि दूसरा कहता है कि This still exists, but its value is the empty string.

यदि आप संख्याओं से निपट रहे हैं, तो 0 असाइन करना बेहतर विकल्प हो सकता है। इसलिए, अगर किसी कंपनी ने मॉडल एक्सएल 1000 स्पॉकेट के उत्पादन को रोक दिया है, तो यह इसके साथ अपनी सूची अपडेट करेगा:

unset($products['XL1000']);

हालांकि, अगर यह अस्थायी रूप से एक्सएल 1000 स्पॉकेट से बाहर हो गया, लेकिन इस सप्ताह के अंत में संयंत्र से नया शिपमेंट प्राप्त करने की योजना बना रहा था, तो यह बेहतर है:

$products['XL1000'] = 0;

यदि आप एक तत्व को unset() , तो PHP सरणी को समायोजित करता है ताकि लूपिंग अभी भी सही तरीके से काम करे। यह लापता छेद भरने के लिए सरणी को कॉम्पैक्ट नहीं करता है। यह हमारा मतलब है जब हम कहते हैं कि सभी सरणी सहयोगी हैं, भले ही वे संख्यात्मक दिखाई दें। यहां एक उदाहरण दिया गया है:

// 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 new element
$animals[ ] = 'gnu'; // add 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

सरणी को घनी भरे संख्यात्मक सरणी में कॉम्पैक्ट करने के लिए, array_values() उपयोग करें:

$animals = array_values($animals);

वैकल्पिक रूप से, array_splice() स्वचालित रूप से छेद छोड़ने से बचने के लिए सरणी को array_splice() :

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

यह उपयोगी है यदि आप कतार के रूप में सरणी का उपयोग कर रहे हैं और कतार से आइटम्स को हटाना चाहते हैं, जबकि अभी भी यादृच्छिक पहुंच की अनुमति है। सरणी से पहले या अंतिम तत्व को सुरक्षित रूप से हटाने के लिए, क्रमशः array_shift () और array_pop () का उपयोग करें।


array(2) { [1]=> string(1) "Y" [2]=> string(1) "Z" }


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

यह उपरोक्त कोड से आउटपुट है:

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
)

अब, array_values ​​() अच्छी तरह से एक संख्यात्मक सरणी reindex जाएगा, लेकिन सरणी से सभी कुंजी तारों को हटा देगा और उन्हें संख्याओं के साथ प्रतिस्थापित करेगा। यदि आपको कुंजी नाम (तार) को संरक्षित करने की आवश्यकता है, या सरणी को फिर से संशोधित करें यदि सभी कुंजी संख्यात्मक हैं, तो array_merge () का उपयोग करें:

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

आउटपुट

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

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

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

    echo $fruit;
?>

आउटपुट:

Array
(
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
)

fruit1

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

उत्पादन

 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 ) 

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




arrays