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




arrays (24)

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

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


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

यदि आपको किसी एसोसिएटिव सरणी से कई तत्वों को निकालना है, तो आप array_diff_key() उपयोग कर सकते हैं (यहां array_flip() साथ प्रयोग किया जाता है):

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

आउटपुट:

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

मान लें कि आपके पास ऐसी सरणी है:

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

storage हटाने के लिए, करें:

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

और आपको मिलता है:

Array
(
    [user_id] => 193
)

unset($array[$index]);

सहयोगी सरणी

सहयोगी सरणी के लिए, unset() उपयोग करें:

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

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

संख्यात्मक सरणी

संख्यात्मक सरणी के लिए, array_splice() उपयोग array_splice() :

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

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

ध्यान दें

संख्यात्मक सरणी के लिए unset() का उपयोग करने से कोई त्रुटि उत्पन्न नहीं होगी, लेकिन यह आपकी अनुक्रमणिका को गड़बड़ कर देगा:

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

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

इस कार्य को करने के लिए दो तरीके हैं

अनसेट () और array_splice ()

आइए दो एरे मान लें

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


    echo $arrayName['500']; 
    //somevalue500
    array_splice($arrayName, 1,2);

    print_r( $arrayName );
    //Array ( [0] => somevalue [1] => somevalue500 )



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


    echo $arrayName['500']; 
    //somevalue500
    unset($arrayName[1]);

    print_r( $arrayName );
    //Array ( [0] => somevalue [1] => somevalue500 )

अनसेट के साथ ()

$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // here is key to be delete
echo '<br>';
array_values($x);
var_dump($x);
  • सरणी तत्व सरणी अनुक्रमणिका को हटाने के बाद बदल नहीं है

array_splice () के साथ

 syntax - array_splice(array, index, length) array_splice($array_1,1,1); // remove 1 element from $array_1 from index 1 array_splice($array_2,3,1); // remove 1 element from $array_2 from index 3 
  • सरणी से तत्व को हटाने के बाद सभी सरणी तत्वों को फिर से अनुक्रमित किया जाता है

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

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

परिवर्तनीय $ सरणी में अपनी सरणी बनाएं और फिर जहां मैंने 'तत्व जिसे आप हटाना चाहते हैं' डाल दिया है, तो आप कुछ ऐसा कहते हैं: "ए"। और यदि आप एकाधिक को हटाना चाहते हैं तो: "ए", "बी"।


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

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

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

समाधान की:

  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 () का उपयोग करें।


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

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

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

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

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

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

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

नीचे की तरह 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
)

*/

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

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

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

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

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


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

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


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

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

unset($anArray[0]);

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

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

unset($array["elementName"]);

एक सरणी के एक तत्व को नष्ट करें

unset()

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

आउटपुट होगा:

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

यदि आपको सरणी को फिर से अनुक्रमणित करने की आवश्यकता है:

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

फिर आउटपुट होगा:

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

सरणी के अंत से तत्व को पॉप करें - हटाए गए तत्व का मान वापस करें

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

आउटपुट होगा

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

किसी सरणी से पहले तत्व (लाल) को हटाएं , - हटाए गए तत्व का मान वापस करें

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

आउटपुट होगा:

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

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

    echo $fruit;
?>

आउटपुट:

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

fruit1

यदि आपको किसी सरणी में एकाधिक मानों को हटाना है और उस सरणी में प्रविष्टियां ऑब्जेक्ट्स या संरचित डेटा हैं, [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_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() का उपयोग कर सकते हैं और फिर सभी तत्वों को हटा सकते हैं।


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




arrays