क्या PHP का उपयोग करके किसी सरणी से किसी तत्व को हटाने का एक आसान तरीका है, जैसे कि foreach ($array)
अब वह तत्व शामिल नहीं है?
मैंने सोचा था कि यह करने के लिए इसे सेट null
करना होगा, लेकिन जाहिर है कि यह काम नहीं करता है।
क्या PHP का उपयोग करके किसी सरणी से किसी तत्व को हटाने का एक आसान तरीका है, जैसे कि foreach ($array)
अब वह तत्व शामिल नहीं है?
मैंने सोचा था कि यह करने के लिए इसे सेट null
करना होगा, लेकिन जाहिर है कि यह काम नहीं करता है।
जवाबों:
एक सरणी तत्व को हटाने के लिए अलग-अलग तरीके हैं, जहां कुछ दूसरों की तुलना में कुछ विशिष्ट कार्यों के लिए अधिक उपयोगी हैं।
यदि आप केवल एक सरणी तत्व को हटाना चाहते हैं तो आप 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()
किसी विशिष्ट मान के लिए सभी कुंजी प्राप्त करने के लिए उपयोग कर सकते हैं और फिर सभी तत्वों को हटा सकते हैं।
array_splice
, अन्य उत्तरों में वर्णित के रूप में।
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) }
(यह शायद टाइपो था)
unset
कई तर्क हो सकते हैं void unset ( mixed $var [, mixed $... ] )
:।
यह ध्यान दिया जाना चाहिए कि 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)
} */
array_splice
अर्थ (दूसरों के बीच) हो सकता है।
// 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
)
$key = array_search($needle, $array);
if ($key !== false) {
unset($array[$key]);
}
unset($array[$index]);
यदि आपके पास एक संख्यात्मक रूप से अनुक्रमित सरणी है, जहां सभी मान अद्वितीय हैं (या वे गैर-अद्वितीय हैं, लेकिन आप किसी विशिष्ट मान के सभी उदाहरणों को निकालना चाहते हैं), तो आप इस तरह से एक तत्व को निकालने के लिए 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।
इसके अलावा, एक नामित तत्व के लिए:
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 )
किसी सरणी के एकल तत्व को नष्ट करें
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
array_shift
पुनः सूचकांक अगर यह के पूर्णांक कुंजी आइटम, तो यह के बुरे, तो आप इस का उपयोग कर सकते हैं: stackoverflow.com/a/52826684/1407491
<?php
$stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
आउटपुट:
[
[0] => fruit2
[1] => fruit3
[2] => fruit4
]
fruit1
array_shift
केवल सरणी में पहला तत्व हटा सकते हैं। इसी तरह array_pop
सरणी में अंतिम तत्व को हटाने के लिए उपयोग करें।
खोज करने से बचने के लिए कोई भी व्यक्ति उसके साथ खेल सकता है array_diff
:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
इस मामले में किसी को कुंजी की खोज / उपयोग नहीं करना है।
यदि आपको किसी सरणी में कई मान हटाना है और उस सरणी में प्रविष्टियाँ ऑब्जेक्ट या संरचित डेटा हैं, [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
:
$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)
यदि आपको एक साहचर्य सरणी से कई तत्वों को निकालने की आवश्यकता है, तो आप 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 )
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();
?>
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
यदि सूचकांक निर्दिष्ट किया गया है:
$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()
स्वचालित रूप से सरणी के पहले तत्व जो है कि हम क्या नहीं करना चाहता नष्ट करेगा
समाधान:
unset($array[3]); unset($array['foo']);
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
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 () का ।
मान लें कि आपके पास निम्न सरणी है:
Array
(
[user_id] => 193
[storage] => 5
)
हटाने के लिए storage
, करें:
unset($attributes['storage']);
$attributes = array_filter($attributes);
और आपको मिलता है:
Array
(
[user_id] => 193
)
array_filter
प्रयोग किया जाता है?
मैं सिर्फ इतना कहना चाहूंगा कि मेरे पास एक विशेष वस्तु थी जिसमें परिवर्तनशील विशेषताएं थीं (यह मूल रूप से एक तालिका मैप कर रही थी और मैं तालिका में कॉलम बदल रहा था, इसलिए ऑब्जेक्ट में विशेषताएँ, तालिका को प्रतिबिंबित करने के साथ-साथ अलग-अलग होंगी):
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
बस था, इसलिए मुझे कोड में हर जगह नहीं देखना पड़ता है जब वे बदल जाते हैं, मैं सिर्फ कक्षा की शुरुआत को देखता हूं और नए को प्रतिबिंबित करने के लिए विशेषताओं की सूची और $ फ़ील्ड सरणी सामग्री को बदलता हूं जिम्मेदार बताते हैं।
डिफ़ॉल्ट कार्यों का पालन करें:
मैं)
$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"]);
?>
चर में अपना ऐरे बनाएं $array
और फिर जहां मैंने 'एलीमेंट' डाल दिया है, जिसे आप डिलीट करना चाहते हैं, तो आप कुछ इस तरह रखें: "a"। और यदि आप कई आइटम हटाना चाहते हैं तो: "a", "b"।
कुंजी पाने के लिए array_search का उपयोग करें और यदि यह पाया जाता है तो इसे परेशान से हटा दें:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
जबकि 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' ]
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 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);
// 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"
}
निम्नलिखित कोड का उपयोग करें:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
array_pop($arr)
अंतिम प्रविष्टि को हटा देता है। नहीं `=` की जरूरत है।
<?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 )
गैर-पूर्णांक कुंजी के साथ साहचर्य सरणियों के लिए:
सीधे शब्दों में, unset($array[$key])
काम करेगा।
पूर्णांक कुंजियों वाले सरणियों के लिए और यदि आप अपनी कुंजियाँ बनाए रखना चाहते हैं:
$array = [ 'mango', 'red', 'orange', 'grapes'];
unset($array[2]);
$array = array_values($array);
array_splice($array, 2, 1);
यह मदद कर सकता है ...
<?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 )
unset()
सरणी पर पुनरावृत्तियों के साथ अब हटाए गए मान शामिल नहीं होंगे। OTOH, यह सच है कि स्टीवन जवाब पर्याप्त है और, वास्तव में, वह उत्तर था जिसकी मुझे तलाश थी - लेकिन ओपी :) नहीं