PHP
एक सरणी हेरफेर

किसी ऐरे से तत्वों को निकालना

किसी सरणी के अंदर एक तत्व को निकालने के लिए, उदाहरण के लिए 1 इंडेक्स वाला तत्व।

$fruit = array("bananas", "apples", "peaches");
unset($fruit[1]);

यह सूची से सेब को हटा देगा, लेकिन ध्यान दें कि unset होने से शेष तत्वों के सूचकांक में बदलाव नहीं होता है। तो $fruit अब इंडेक्स 0 और 2 ।

साहचर्य सरणी के लिए आप इस तरह निकाल सकते हैं:

$fruit = array('banana', 'one'=>'apple', 'peaches');

print_r($fruit);
/*
    Array
    (
        [0] => banana
        [one] => apple
        [1] => peaches
    )
*/

unset($fruit['one']); 

अब $ फल है

print_r($fruit);

/*
Array
(
    [0] => banana
    [1] => peaches
)
*/

ध्यान दें कि

unset($fruit);

वैरिएबल को अनसेट करता है और इस प्रकार पूरे ऐरे को हटा देता है, जिसका अर्थ है कि इसका कोई भी तत्व अब उपलब्ध नहीं है।

टर्मिनल तत्वों को निकालना

array_shift () - सरणी की शुरुआत में एक तत्व को शिफ्ट करें।

उदाहरण:

  $fruit = array("bananas", "apples", "peaches");
  array_shift($fruit);
  print_r($fruit);

आउटपुट:

 Array
(
    [0] => apples
    [1] => peaches
)

array_pop () - सरणी के अंत से तत्व को पॉप करें।

उदाहरण:

  $fruit = array("bananas", "apples", "peaches");
  array_pop($fruit);
  print_r($fruit);

आउटपुट:

 Array
(
    [0] => bananas
    [1] => apples
)

एक सरणी छानना

किसी सरणी से मानों को फ़िल्टर करने के लिए और फ़िल्टर मान को पूरा करने वाले सभी मानों को प्राप्त करने के लिए एक नया सरणी प्राप्त करने के लिए, आप array_filter फ़ंक्शन का उपयोग कर सकते हैं।

गैर-रिक्त मानों को फ़िल्टर करना

फ़िल्टरिंग का सबसे सरल मामला सभी "खाली" मानों को हटाना है:

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$non_empties = array_filter($my_array); // $non_empties will contain [1,2,3,4,5,6,7,8]; 

कॉलबैक द्वारा फ़िल्टर करना

इस बार हम अपने स्वयं के फ़िल्टरिंग नियम को परिभाषित करते हैं। मान लें कि हम केवल संख्याएँ प्राप्त करना चाहते हैं:

$my_array = [1,2,3,4,5,6,7,8];

$even_numbers = array_filter($my_array, function($number) {
    return $number % 2 === 0;   
});

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

$numbers = [16,3,5,8,1,4,6];

$even_indexed_numbers = array_filter($numbers, function($index) {
    return $index % 2 === 0;
}, ARRAY_FILTER_USE_KEY);

फ़िल्टर किए गए सरणी में अनुक्रमणिका

ध्यान दें कि array_filter मूल सरणी कुंजियों को सुरक्षित रखता है। फ़िल्टर की गई सरणी पर लूप के for उपयोग करने के for एक सामान्य गलती होगी:

<?php

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array); 

error_reporting(E_ALL); // show all errors and notices

// innocently looking "for" loop
for ($i = 0; $i < count($filtered); $i++) {
   print $filtered[$i];
}

/*
Output:
1
Notice: Undefined offset: 1
2
Notice: Undefined offset: 3
3
Notice: Undefined offset: 5
4
Notice: Undefined offset: 7
*/

ऐसा इसलिए होता है क्योंकि मान जो 1 पदों पर थे (वहाँ 0 था), 3 ( null ), 5 (खाली स्ट्रिंग '' ) और 7 (खाली सरणी [] ) को उनके संबंधित इंडेक्स कुंजी के साथ हटा दिया गया था।

यदि आपको अनुक्रमित सरणी पर एक फ़िल्टर के परिणाम के माध्यम से लूप करने की आवश्यकता है, तो आपको सही अनुक्रमित के साथ एक नया सरणी बनाने के लिए array_filter के परिणाम पर array_values को कॉल करना चाहिए:

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array); 
$iterable = array_values($filtered);

error_reporting(E_ALL); // show all errors and notices

for ($i = 0; $i < count($iterable); $i++) {
   print $iterable[$i];
}

// No warnings!

सरणी के प्रारंभ में तत्व जोड़ना

कभी-कभी आप सरणी के भीतर किसी भी मौजूदा तत्व ( ऑर्डर ) को संशोधित किए बिना एक सरणी की शुरुआत में एक तत्व जोड़ना चाहते हैं। जब भी ऐसा हो, आप array_unshift() उपयोग कर सकते हैं।

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

^{array_unshift() लिए PHP डॉक्यूमेंट से लिया गया।}

यदि आप इसे प्राप्त करना चाहते हैं, तो आपको बस इतना करना होगा:

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

array_unshift($myArray, 4);

यह अब आपके एरे में पहले तत्व के रूप में 4 जोड़ देगा। आप इसे इसके द्वारा सत्यापित कर सकते हैं:

print_r($myArray);

^{यह निम्न क्रम में एक सरणी देता है: 4, 1, 2, 3 ।}

चूंकि array_unshift कुंजी-मान युग्मों को रीसेट करने के लिए सरणी को मजबूर करता है क्योंकि नए तत्व को निम्नलिखित प्रविष्टियों की कुंजियां n+1 यह एक नया सरणी बनाने के लिए और मौजूदा सरणी को नए बनाए गए सरणी में जोड़ने के लिए अधिक स्मार्ट है।

उदाहरण:

$myArray = array('apples', 'bananas', 'pears');
$myElement = array('oranges');
$joinedArray = $myElement;

foreach ($myArray as $i) {
  $joinedArray[] = $i;
}

आउटपुट ($ joinArray):

Array ( [0] => oranges [1] => apples [2] => bananas [3] => pears ) 

Eaxmple / डेमो

श्वेतसूची केवल कुछ सरणी कुंजियाँ

आप अपने सरणियों में केवल कुछ चाबियाँ अनुमति देने के लिए, खासकर जब सरणी अनुरोध पैरामीटर से आता है चाहते हैं, तो आप उपयोग कर सकते array_intersect_key के साथ एक साथ array_flip ।

$parameters = ['foo' => 'bar', 'bar' => 'baz', 'boo' => 'bam'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_intersect_key($parameters, array_flip($allowedKeys));

// $filteredParameters contains ['foo' => 'bar', 'bar' => 'baz]

यदि parameters वैरिएबल में कोई अनुमत कुंजी नहीं है, तो filteredParameters चर एक खाली सरणी से मिलकर बनेगा।

PHP 5.6 के बाद से आप इस कार्य के लिए array_filter उपयोग कर सकते हैं, ARRAY_FILTER_USE_KEY ध्वज को तीसरे पैरामीटर के रूप में पास कर रहे हैं:

$parameters  = ['foo' => 1, 'hello' => 'world'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_filter(
    $parameters,
    function ($key) use ($allowedKeys) {
        return in_array($key, $allowedKeys);
    },
    ARRAY_FILTER_USE_KEY
);

array_filter का उपयोग करने से कुंजी के खिलाफ एक अनियंत्रित परीक्षण करने का अतिरिक्त लचीलापन मिलता है, उदाहरण के लिए $allowedKeys में सादे स्ट्रिंग्स के बजाय रेगेक्स पैटर्न हो सकते हैं। यह भी अधिक स्पष्ट रूप से कोड के इरादे से कहा गया है array_intersect_key() के साथ संयुक्त array_flip() ।

एक छँटाई

Php में सरणियों के लिए कई प्रकार के कार्य हैं:

प्रकार ()

मान द्वारा आरोही क्रम में एक सरणी को क्रमबद्ध करें।

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
sort($fruits);
print_r($fruits);

का परिणाम

Array
(
    [0] => Apfel
    [1] => Banane
    [2] => Orange
    [3] => Zitrone
)

rsort ()

मूल्य द्वारा अवरोही क्रम में एक सरणी को क्रमबद्ध करें।

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
rsort($fruits);
print_r($fruits);

का परिणाम

Array
(
    [0] => Zitrone
    [1] => Orange
    [2] => Banane
    [3] => Apfel
)

एक प्रकार()

मान द्वारा आरोही क्रम में एक सरणी को सॉर्ट करें और अनिर्णय को संरक्षित करें।

$fruits = [1 => 'lemon', 2 => 'orange',  3 => 'banana', 4 => 'apple'];
asort($fruits);
print_r($fruits);

का परिणाम

Array
(
    [4] => apple
    [3] => banana
    [1] => lemon
    [2] => orange
)

arsort ()

मूल्य द्वारा अवरोही क्रम में एक सरणी को क्रमबद्ध करें और अनिर्णय को संरक्षित करें।

$fruits = [1 => 'lemon', 2 => 'orange',  3 => 'banana', 4 => 'apple'];
arsort($fruits);
print_r($fruits);

का परिणाम

Array
(
    [2] => orange
    [1] => lemon
    [3] => banana
    [4] => apple
)

ksort ()

कुंजी द्वारा आरोही क्रम में एक सरणी को क्रमबद्ध करें

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
ksort($fruits);
print_r($fruits);

का परिणाम

Array
(
    [a] => orange
    [b] => banana
    [c] => apple
    [d] => lemon
)

krsort ()

कुंजी द्वारा अवरोही क्रम में एक सरणी को क्रमबद्ध करें।

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
krsort($fruits);
print_r($fruits);

का परिणाम

Array
(
    [d] => lemon
    [c] => apple
    [b] => banana
    [a] => orange
)

natsort ()

एक सरणी को एक ऐसे तरीके से क्रमबद्ध करें जिसे मनुष्य (प्राकृतिक व्यवस्था) करेगा।

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natsort($files);
print_r($files);

का परिणाम

Array
(
    [4] => File2.stack
    [0] => File8.stack
    [2] => file7.stack
    [3] => file13.stack
    [1] => file77.stack
)

natcasesort ()

एक सरणी को एक ऐसे तरीके से क्रमबद्ध करें जिसे इंसान (प्राकृतिक व्यवस्था) करेगा, लेकिन मामला गहन होगा

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natcasesort($files);
print_r($files);

का परिणाम

Array
(
    [4] => File2.stack
    [2] => file7.stack
    [0] => File8.stack
    [3] => file13.stack
    [1] => file77.stack
)

शफ़ल ()

एक सरणी फेरबदल (बेतरतीब ढंग से हल)।

$array = ['aa', 'bb', 'cc'];
shuffle($array);
print_r($array);

जैसा कि विवरण में लिखा गया है यह यादृच्छिक है इसलिए यहां केवल एक उदाहरण है कि यह क्या परिणाम दे सकता है

Array
(
    [0] => cc
    [1] => bb
    [2] => aa
)

usort ()

उपयोगकर्ता परिभाषित तुलना फ़ंक्शन के साथ एक सरणी को क्रमबद्ध करें।

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = [3, 2, 5, 6, 1];
usort($array, 'compare');
print_r($array);

का परिणाम

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)

uasort ()

उपयोगकर्ता परिभाषित तुलना फ़ंक्शन के साथ एक सरणी को सॉर्ट करें और कुंजियों को संरक्षित करें।

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['a' => 1, 'b' => -3, 'c' => 5, 'd' => 3, 'e' => -5];
uasort($array, 'compare');
print_r($array);

का परिणाम

Array
(
    [e] => -5
    [b] => -3
    [a] => 1
    [d] => 3
    [c] => 5
)

uksort ()

उपयोगकर्ता परिभाषित तुलना फ़ंक्शन के साथ कुंजियों द्वारा एक सरणी को क्रमबद्ध करें।

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['ee' => 1, 'g' => -3, '4' => 5, 'k' => 3, 'oo' => -5];

uksort($array, 'compare');
print_r($array);

का परिणाम

Array
(
    [ee] => 1
    [g] => -3
    [k] => 3
    [oo] => -5
    [4] => 5
)

कुंजियों के साथ विनिमय मूल्य

array_flip फ़ंक्शन अपने तत्वों के साथ सभी कुंजियों का आदान-प्रदान करेगा।

$colors = array(
    'one' => 'red',
    'two' => 'blue',
    'three' => 'yellow',
);

array_flip($colors); //will output

array(
    'red' => 'one',
    'blue' => 'two',
    'yellow' => 'three'
)

एक सरणी में दो सरणियों को मिलाएं

$a1 = array("red","green");
$a2 = array("blue","yellow");
print_r(array_merge($a1,$a2));

/*
    Array ( [0] => red [1] => green [2] => blue [3] => yellow )
*/

सहयोगी सरणी:

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2));
/*
    Array ( [a] => red [b] => yellow [c] => blue )
*/

1. एक या एक से अधिक सरणियों के तत्वों को एक साथ जोड़ता है ताकि एक के मूल्यों को पिछले एक के अंत में जोड़ा जा सके। यह परिणामी सरणी देता है।
2. यदि इनपुट सरणियों में समान स्ट्रिंग कुंजियाँ हैं, तो उस कुंजी के लिए बाद का मान पिछले एक को अधिलेखित कर देगा। यदि, हालाँकि, सरणियों में संख्यात्मक कुंजियाँ होती हैं, तो बाद में मान मूल मान को अधिलेखित नहीं करेगा, लेकिन संलग्न किया जाएगा।
3. अंकीय कुंजियों के साथ इनपुट सरणी में मान परिणाम सरणी में शून्य से शुरू होने वाली वृद्धि कीज़ के साथ बदल दिए जाएंगे।