किसी तत्व को PHP में सरणी से हटाना


2513

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

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


14
मैं यह नहीं कहूंगा कि कोनराड उत्तर बताई गई समस्या के लिए सबसे सरल है। unset()सरणी पर पुनरावृत्तियों के साथ अब हटाए गए मान शामिल नहीं होंगे। OTOH, यह सच है कि स्टीवन जवाब पर्याप्त है और, वास्तव में, वह उत्तर था जिसकी मुझे तलाश थी - लेकिन ओपी :) नहीं
ब्रैंडज़ी जू

32
@danip मैन्युअल में खोजना आसान होने के कारण StackOverflow पर कोई प्रश्न नहीं बनता है। यदि प्रश्न एक डुप्लिकेट StackOverflow प्रश्न था, तो यह यहाँ नहीं हो सकता है। मैनुअल में देखने से पहले ही जवाब देने के लिए स्टैकऑवरफ्लो एक अच्छी जगह है।
दान निसेनबौम

5
@unset ($ सरणी [$ कुंजी]); $ सरणी = array_values ​​($ सरणी);
ट्रोजन

फ़ॉरवर्ड लूप में इसे हटाने के बारे में संबंधित प्रश्न: stackoverflow.com/questions/1949259/…
लेगोलस

यदि आप ऐरे (साहचर्य एरे) सरणी से कुंजियाँ निकालना चाहते हैं, तो stackoverflow.com/
47978980/1045444

जवाबों:


2869

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

एक एरे तत्व को हटा दें

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

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

unset()

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

कोड

<?php

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

?>

उत्पादन

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

\array_splice() तरीका

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

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

कोड

<?php

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

?>

उत्पादन

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

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

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

यदि आप कई ऐरे एलिमेंट्स को हटाना चाहते हैं और कई बार कॉल unset()या नहीं करना चाहते हैं तो आप \array_splice()फ़ंक्शंस का उपयोग कर सकते हैं \array_diff()या \array_diff_key()इस पर निर्भर करते हैं कि आप उन एलिमेंट्स या कीज़ को जानते हैं जिन्हें आप डिलीट करना चाहते हैं।

\array_diff() तरीका

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

कोड

<?php

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

?>

उत्पादन

[
    [1] => b
]

\array_diff_key() तरीका

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

कोड

<?php

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

उत्पादन

[
    [1] => b
]

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


25
@AlexandruRada नहीं, आपने कहा "इसका उपयोग न करें" - और यह सिर्फ बकवास है। आप इस पद्धति का उपयोग तब कर सकते हैं जब आप किसी सरणी का इलाज करते हैं जैसे कि यह एक शब्दकोश है। यदि आप लगातार सांख्यिक सूचकांकों की अपेक्षा कर रहे हैं, तो आपको कुछ और उपयोग करने की आवश्यकता है।
कोनराड रुडोल्फ

2
@Alexander उपयोग array_splice, अन्य उत्तरों में वर्णित के रूप में।
कोनराड रुडोल्फ

1
@AlexandruRada कोई जिस तरह से आप कर सकते हैं है array (3) { [0]=>int(0) ...जब आप unset($x[2])से $x = array(1, 2, 3, 4);परिणाम चाहिए हो var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }(यह शायद टाइपो था)
inemanja

5
unsetकई तर्क हो सकते हैं void unset ( mixed $var [, mixed $... ] ):।
Константин Ван

3
array_filter भी एक व्यवहार्य विधि है। विशेष रूप से अच्छा है अगर आप सरणी को म्यूट नहीं करना चाहते हैं, लेकिन यह भी reindex नहीं है जो json_encode के साथ एक मुद्दा हो सकता है। php.net/manual/en/function.json-encode.php#94157
डॉटनेटकारपेंटर

1358

यह ध्यान दिया जाना चाहिए कि 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()अगर आप अपने पूर्णांक कुंजी को सामान्य करना चाहते हैं के लिए इस्तेमाल किया जा सकता है। एक अन्य विकल्प के array_values()बाद उपयोग कर रहा है 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)
} */

42
यह ध्यान देने योग्य है कि जब आप array_splice () का उपयोग कर रहे हैं, तो आपको OFFSET जानने की जरूरत है, कुंजी नहीं, लेकिन ऑफसेट (!) जिस भी तत्व को आप हटाना चाहते हैं
टॉम

18
@ टोम: एक नियमित सरणी के लिए (जो लगातार पूर्णांक-अनुक्रमित है) ऑफसेट सूचकांक है। यह वह जगह है जहाँ array_spliceअर्थ (दूसरों के बीच) हो सकता है।
स्टीफन गेह्रिग

5
हां, लेकिन कुछ याद रखने के लिए अगर आप ब्याह का उपयोग करने से पहले सरणी के साथ छेड़छाड़ करते हैं
टॉम

4
एक विशाल सरणी से तत्वों के एक टन को हटाने के सिर्फ एक मूल परीक्षण से, array_splice एक बहुत तेज और कम स्मृति गहन लगता है। यह मेरी अपेक्षा से मेल खाता है: array_values ​​() सरणी की एक प्रति बनाता हुआ प्रतीत होता है, जबकि array_splice जगह पर काम करता है।
डग कवेंडक

4
array_values ​​एक उपयोगी दृष्टिकोण है जब आप तत्वों को एक लूप में निकाल रहे हैं और अनुक्रमणिका को सुसंगत बनाना चाहते हैं, लेकिन फिर लूप के बाद उन्हें संपीड़ित करना चाहते हैं।
रोरिक

370
  // 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 ​​() एक संख्यात्मक सरणी को अच्छी तरह से फिर से जोड़ देगा, लेकिन यह सरणी से सभी महत्वपूर्ण तारों को हटा देगा और उन्हें संख्याओं के साथ बदल देगा। यदि आपको कुंजी नाम (स्ट्रिंग्स) को संरक्षित करने की आवश्यकता है, या सरणी को फिर से लिखना है यदि सभी कुंजी संख्यात्मक हैं, तो 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
)

$ get_merged_values ​​= array_merge ($ data ['res'], $ data ['check_res']); जब मैं इस Print_r ($ get_merged_values) को प्रिंट करता हूं; यह निम्नलिखित प्रदर्शित करता है। ऐरे ([0] => ऐरे ([menu_code] => 2 [menu_name] => प्लांट [menu_order_no] => 1) [1] => Array ([menu_code] => 3 [menu_name] => रेखा [menu_order_no] => 2)) लेकिन मुझे $ get_merged_values ​​[0] [menu_code], $ get_merged_values ​​[0] का उपयोग करने के बजाय क्रमशः क्रमशः get_merged_values ​​['menu_code'] और $ get_merged_values ​​['menu_name'] का उपयोग करके menu_code और menu_name के मान प्राप्त करने की आवश्यकता है। ] [MENU_NAME]। कृपया मेरी मदद कैसे करें?
हार्ट हैकर

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

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


65

यदि आपके पास एक संख्यात्मक रूप से अनुक्रमित सरणी है, जहां सभी मान अद्वितीय हैं (या वे गैर-अद्वितीय हैं, लेकिन आप किसी विशिष्ट मान के सभी उदाहरणों को निकालना चाहते हैं), तो आप इस तरह से एक तत्व को निकालने के लिए 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।


64

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

unset($array["elementName"]);

$a = array("A"=>1, "B"=>2, "C"=>"a"); print_r($a); unset($a["B"]); print_r($a); देता है (स्वरूपित): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
DefenestrationDay

ऐसा लगता है कि आप स्ट्रिंग द्वारा अनुक्रमित सरणी तत्वों को अनसेट नहीं कर सकते ("घातक त्रुटि उत्पन्न करता है: स्ट्रिंग स्ट्रिंग को अनसेट नहीं कर सकता")। मुझे नहीं लगता कि यह हमेशा मामला था, लेकिन निश्चित रूप से PHP 5.3.10 के रूप में और शायद इससे पहले
carpii

6
@carpii PHP एक साहचर्य सरणी से तत्वों को परेशान कर सकती है। घातक त्रुटि तब होती है जब आप किसी सरणी के बजाय एक स्ट्रिंग पर unset ($ var ['key']) का उपयोग करने का प्रयास करते हैं उदाहरण के लिए: $ array = array ('test' => 'value', 'other' => ') मूल्य ',); सेट नहीं ($ सरणी [ 'परीक्षण']); // सरणी से "परीक्षण" तत्व को हटाता है जैसा कि अपेक्षित $ सरणी = 'परीक्षण'; सेट नहीं ($ सरणी [ 'परीक्षण']); // "घातक त्रुटि: अपेक्षित स्ट्रिंग ऑफ़सेट्स को नहीं छोड़ सकता"
जिम्बो

यहां आपको मुख्य नाम पता होना चाहिए, यह बेहतर है: stackoverflow.com/a/52826684/1407491
नबी काज़

33

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

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

1
array_shiftपुनः सूचकांक अगर यह के पूर्णांक कुंजी आइटम, तो यह के बुरे, तो आप इस का उपयोग कर सकते हैं: stackoverflow.com/a/52826684/1407491
नबी KAZ

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

    echo $fruit;
?>

आउटपुट:

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

fruit1

14
ध्यान दें कि array_shiftकेवल सरणी में पहला तत्व हटा सकते हैं। इसी तरह array_popसरणी में अंतिम तत्व को हटाने के लिए उपयोग करें।
जसबीर

1
उत्तर केवल सरणी के पहले तत्व पर लागू होता है और सामान्य प्रश्न का उत्तर नहीं देता है।
स्विजर्बर.देव।

@sebweisgerber आप सही हैं लेकिन मुझे नहीं लगता कि यह गलत है और इस ans को डाउनवोट करने की जरूरत है। प्रश्न किसी भी स्थिति का उल्लेख नहीं करने वाले तत्व को हटा देता है।
सौरभ चंद्र पटेल

27

खोज करने से बचने के लिए कोई भी व्यक्ति उसके साथ खेल सकता है array_diff:

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

इस मामले में किसी को कुंजी की खोज / उपयोग नहीं करना है।


21

यदि आपको किसी सरणी में कई मान हटाना है और उस सरणी में प्रविष्टियाँ ऑब्जेक्ट या संरचित डेटा हैं, [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']]

20

सहयोगी सरणियाँ

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

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

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

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

संख्यात्मक सरणियों के लिए, उपयोग करें 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)

19

यदि आपको एक साहचर्य सरणी से कई तत्वों को निकालने की आवश्यकता है, तो आप 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 ) 

यह इतना कम क्यों है?
Fr0zenFyr

19

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


12

यदि सूचकांक निर्दिष्ट किया गया है:

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

यदि सूचकांक निर्दिष्ट नहीं है:

$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क्योंकि अगर हालत के लिए आवश्यक है indexनहीं मिला है, unset()स्वचालित रूप से सरणी के पहले तत्व जो है कि हम क्या नहीं करना चाहता नष्ट करेगा


1
यदि मान नहीं मिला है, तो यह पहला तत्व निकाल देगा। अनसेट के लिए एक परीक्षण में जोड़ें: अगर ($ इंडेक्स! == गलत) अनसेट ($ गिरफ्तार [$ इंडेक्स]);
MyRealNameIsBlaze

@MyRealNameIsBlaze धन्यवाद, तय किया
अहमद मोबारकी

9

समाधान:

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

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

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

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

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

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

unset($products['XL1000']);

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

$products['XL1000'] = 0;

यदि आप एक तत्व को अनसेट करते हैं () , 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 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

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

$animals = array_values($animals);

वैकल्पिक रूप से, 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 () का


8

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

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

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

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

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

Array
(
    [user_id] => 193
)

किसके लिए array_filterप्रयोग किया जाता है?
डेविड

मिथ्या तत्वों को दूर करने के लिए
Tebe

8

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

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

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


8

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

मैं)

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

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

चर में अपना ऐरे बनाएं $arrayऔर फिर जहां मैंने 'एलीमेंट' डाल दिया है, जिसे आप डिलीट करना चाहते हैं, तो आप कुछ इस तरह रखें: "a"। और यदि आप कई आइटम हटाना चाहते हैं तो: "a", "b"।


7

कुंजी पाने के लिए array_search का उपयोग करें और यदि यह पाया जाता है तो इसे परेशान से हटा दें:

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

6

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

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

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

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

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

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

6

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

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
        )

*/

6

सूचकांक के क्रम को रखने के साथ एक सरणी के पहले आइटम को हटाने के लिए दो तरीके और अगर आपको पहले आइटम का मुख्य नाम नहीं पता है।

समाधान # 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);

समाधान # 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]);

इस नमूना डेटा के लिए:

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

आपके पास यह परिणाम होना चाहिए:

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

5

निम्नलिखित कोड का उपयोग करें:

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

4
php5: बस रनिंग array_pop($arr)अंतिम प्रविष्टि को हटा देता है। नहीं `=` की जरूरत है।
क्रिस के

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

4

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

सीधे शब्दों में, unset($array[$key]) काम करेगा।

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

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

    unset($array[2]);
    $array = array_values($array);
  2. array_splice($array, 2, 1);


2

यह मदद कर सकता है ...

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

परिणाम होगा:

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

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

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

print_r($arrayName);
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.