कैसे आप PHP में एक सरणी reindex करते हैं?

Question

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

वर्तमान सरणी ( संपादित करें: सरणी वास्तव में इस तरह दिखती है):

Array (

[2] => Object
    (
        [title] => Section
        [linked] => 1
    )

[1] => Object
    (
        [title] => Sub-Section
        [linked] => 1
    )

[0] => Object
    (
        [title] => Sub-Sub-Section
        [linked] => 
    )

)

यह कैसा होना चाहिए:

Array (

[1] => Object
    (
        [title] => Section
        [linked] => 1
    )

[2] => Object
    (
        [title] => Sub-Section
        [linked] => 1
    )

[3] => Object
    (
        [title] => Sub-Sub-Section
        [linked] => 
    )

)

Comments

कहां कुछ उलटा हुआ है?

— गुमबो

मेरा पहला उदाहरण देखें

— meleyal

और आपको पहले तत्व के इंडेक्स 1 की आवश्यकता क्यों है? सिर्फ एक प्रारूप मामला या आंतरिक प्रसंस्करण के लिए?

— गुमबो

यह url खंड प्राप्त करने के लिए एक फ़ंक्शन के लिए एक परम के रूप में उपयोग किया जाएगा, get_url_segment (1) की तरह कुछ इस पृष्ठ पर "जैसे सवाल"

— लौटेगा

Answer 1

यदि आप शून्य से फिर से इंडेक्स शुरू करना चाहते हैं, तो बस निम्नलिखित करें:

$iZero = array_values($arr);

यदि आपको एक पर शुरू करने की आवश्यकता है, तो निम्नलिखित का उपयोग करें:

$iOne = array_combine(range(1, count($arr)), array_values($arr));

यहां उपयोग किए गए कार्यों के लिए मैन्युअल पृष्ठ हैं:

• array_values()
• array_combine()
• range()

Comments

आपको रेंज (0, गणना ($ गिरफ्तारी) - 1) का उपयोग करना चाहिए ताकि आपको एक शून्य-अनुक्रमित सरणी मिल सके।

— मैक्स हार्टशोर्न

यह बढ़िया है, वैकल्पिक रूप से आप एक शून्य-अनुक्रमित तत्व को जोड़ने के लिए array_unshift ($ गिरफ्तारी, '') का उपयोग करने की कोशिश कर सकते हैं, फिर इसे हटाने के लिए परेशान ($ गिरफ्तार [0]), इस प्रकार सभी अनुक्रमित को एक-एक करके आगे बढ़ाते हैं। यह शायद array_combine () से तेज है। या नहीं :)

— स्टीव Horvath

ध्यान दें कि array_valuesसरणी की एक प्रति लौटाता है। इसलिए अगर आपके पास सरणी के संदर्भ हैं तो array_spliceबेहतर होगा। @Imagiro समाधान देखें।

— Nux

केवल array_values()इसे काम करें, यदि आप हर समय सूचकांक 0 से शुरू करते हैं।

— kishor10d

Answer 2

यहाँ सबसे अच्छा तरीका है :

# Array
$array = array('tomato', '', 'apple', 'melon', 'cherry', '', '', 'banana');

वह लौटता है

Array
(
    [0] => tomato
    [1] => 
    [2] => apple
    [3] => melon
    [4] => cherry
    [5] => 
    [6] => 
    [7] => banana
)

ऐसा करके

$array = array_values(array_filter($array));

आप इसे प्राप्त करें

Array
(
    [0] => tomato
    [1] => apple
    [2] => melon
    [3] => cherry
    [4] => banana
)

व्याख्या

array_values() : इनपुट ऐरे के मानों को और संख्यात्मक रूप से अनुक्रमित करता है।

array_filter(): उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन के साथ एक सरणी के तत्वों को फ़िल्टर करता है (UDF यदि कोई भी प्रदान नहीं किया गया है , तो मूल्यवान तालिका FALSE की सभी प्रविष्टियों को हटा दिया जाएगा ।)

Comments

यदि आप ऑर्डर के बारे में परवाह नहीं करते हैं, तो आप बस सॉर्ट ($ सरणी) भी कर सकते हैं;

— पीटर एम। एलियास

array_filter()नमूना डेटा के लिए पूरी तरह अप्रासंगिक लगता है।

— मिकमैकुसा

Answer 3

मुझे अभी पता चला है कि आप भी कर सकते हैं

array_splice($ar, 0, 0);

यह री-इंडेक्सिंग इनहेल करता है, इसलिए आप मूल सरणी की एक प्रति के साथ समाप्त नहीं होते हैं।

Answer 4

रेनडेक्सिंग क्यों? सूचकांक में केवल 1 जोड़ें:

foreach ($array as $key => $val) {
    echo $key + 1, '<br>';
}

---

संपादित करें    प्रश्न को स्पष्ट किए जाने के बाद: आप array_values0. पर शुरू होने वाले सूचकांक को रीसेट करने के लिए उपयोग कर सकते हैं। फिर आप ऊपर दिए गए एल्गोरिथ्म का उपयोग कर सकते हैं यदि आप मुद्रित तत्वों को 1 पर शुरू करना चाहते हैं।

Comments

इस सवाल का जवाब दिया गया

— अंडरटेकिंग

Answer 5

खैर, मैं यह सोचना चाहता हूं कि आपका अंतिम लक्ष्य जो भी हो, आपको वास्तव में 0-आधारित के विपरीत 1-आधारित होने के लिए सरणी को संशोधित करने की आवश्यकता नहीं होगी, लेकिन इसके बजाय इसे गुमू की तरह पुनरावृत्ति समय पर संभाल सकता है।

हालांकि , आपके प्रश्न का उत्तर देने के लिए, इस फ़ंक्शन को किसी भी सरणी को 1-आधारित संस्करण में बदलना चाहिए

function convertToOneBased( $arr )
{
    return array_combine( range( 1, count( $arr ) ), array_values( $arr ) );
}

संपादित करें

यहाँ एक और अधिक पुन: प्रयोज्य / लचीला कार्य है, क्या आपको इसकी इच्छा करनी चाहिए

$arr = array( 'a', 'b', 'c' );

echo '<pre>';
print_r( reIndexArray( $arr ) );
print_r( reIndexArray( $arr, 1 ) );
print_r( reIndexArray( $arr, 2 ) );
print_r( reIndexArray( $arr, 10 ) );
print_r( reIndexArray( $arr, -10 ) );
echo '</pre>';

function reIndexArray( $arr, $startAt=0 )
{
    return ( 0 == $startAt )
        ? array_values( $arr )
        : array_combine( range( $startAt, count( $arr ) + ( $startAt - 1 ) ), array_values( $arr ) );
}

Answer 6

यह वही करेगा जो आप चाहते हैं:

<?php

$array = array(2 => 'a', 1 => 'b', 0 => 'c');

array_unshift($array, false); // Add to the start of the array
$array = array_values($array); // Re-number

// Remove the first index so we start at 1
$array = array_slice($array, 1, count($array), true);

print_r($array); // Array ( [1] => a [2] => b [3] => c ) 

?>

Answer 7

आप विचार करना चाह सकते हैं कि आप 1-आधारित सरणी का उपयोग क्यों करना चाहते हैं। शून्य-आधारित सरणियाँ (गैर-साहचर्य सरणियों का उपयोग करते समय) बहुत मानक हैं, और यदि आप UI पर आउटपुट करना चाहते हैं, तो अधिकांश यूआई के आउटपुट पर पूर्णांक को बढ़ाकर समाधान को संभाल लेंगे।

संगति के बारे में सोचें - आपके आवेदन में और कोड में आप दोनों काम करते हैं - जब सरणियों के लिए 1-आधारित इंडेक्सर्स के बारे में सोचते हैं।

Comments

यह सीधे व्यापार परत और प्रस्तुति परत के बीच अलगाव से संबंधित है। यदि आप प्रस्तुति को समायोजित करने के लिए अपने तर्क में कोड को संशोधित कर रहे हैं, तो आप बुरे काम कर रहे हैं। उदाहरण के लिए, यदि आपने एक नियंत्रक के लिए ऐसा किया है, तो अचानक आपका नियंत्रक एक विशिष्ट दृश्य रेंडरर से बंधा होता है, जो भी दृश्य रेंडर का उपयोग करने के लिए डेटा तैयार करता है (php, json, xml, rss, आदि)

— Tres

Answer 8

एक और अधिक सुंदर समाधान:

$list = array_combine(range(1, count($list)), array_values($list));

Comments

आप इसे सुरुचिपूर्ण कहते हैं?

— जूलियन

Answer 9

आप एक सरणी को फिर से जोड़ सकते हैं इसलिए नया सरणी 1 के सूचकांक के साथ शुरू होता है;

$arr = array(
  '2' => 'red',
  '1' => 'green',
  '0' => 'blue',
);

$arr1 = array_values($arr);   // Reindex the array starting from 0.
array_unshift($arr1, '');     // Prepend a dummy element to the start of the array.
unset($arr1[0]);              // Kill the dummy element.

print_r($arr);
print_r($arr1);

ऊपर से आउटपुट है;

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

Comments

आपको array_valuesयहाँ उपयोग करने की आवश्यकता नहीं है । मेरा जवाब देखिए।

— बारिश

Answer 10

@Monowerker के समान, मुझे किसी ऑब्जेक्ट की कुंजी का उपयोग करके एक सरणी को फिर से जोड़ने की आवश्यकता है ...

$new = array();
$old = array(
  (object)array('id' => 123),
  (object)array('id' => 456),
  (object)array('id' => 789),
);
print_r($old);

array_walk($old, function($item, $key, &$reindexed_array) {
  $reindexed_array[$item->id] = $item;
}, &$new);

print_r($new);

इसके परिणामस्वरूप:

Array
(
    [0] => stdClass Object
        (
            [id] => 123
        )
    [1] => stdClass Object
        (
            [id] => 456
        )
    [2] => stdClass Object
        (
            [id] => 789
        )
)
Array
(
    [123] => stdClass Object
        (
            [id] => 123
        )
    [456] => stdClass Object
        (
            [id] => 456
        )
    [789] => stdClass Object
        (
            [id] => 789
        )
)

Answer 11

$tmp = array();
foreach (array_values($array) as $key => $value) {
    $tmp[$key+1] = $value;
}
$array = $tmp;

Answer 12

यदि आप उस सरणी को पुनः व्यवस्थित करने का प्रयास नहीं कर रहे हैं, जो आप कर सकते हैं:

$ सरणी = array_reverse ($ array);
$ सरणी = array_reverse ($ सरणी);

Array_reverse बहुत तेज है और यह उलट होने के साथ ही फिर से चालू हो जाता है। बहुत पहले किसी और ने मुझे यह दिखाया था। इसलिए मैं इसके साथ आने का श्रेय नहीं ले सकता। लेकिन यह बहुत सरल और तेज है।

Answer 13

निक के योगदान के समान, मैं एक सरणी को reindexing करने के लिए एक ही समाधान के लिए आया था, लेकिन PHP संस्करण 5.4 से फ़ंक्शन को थोड़ा बढ़ाया, यह संदर्भ द्वारा चर को पार करने के कारण काम नहीं करता है। उदाहरण reindexing फ़ंक्शन तब useकीवर्ड क्लोजर का उपयोग करके इस तरह होता है :

function indexArrayByElement($array, $element)
{
    $arrayReindexed = [];
    array_walk(
        $array,
        function ($item, $key) use (&$arrayReindexed, $element) {
            $arrayReindexed[$item[$element]] = $item;
        }
    );
    return $arrayReindexed;
}

Answer 14

यहाँ मेरा अपना कार्यान्वयन है। इनपुट सरणी में कीज़ को $ start_index से शुरू होने वाली इंक्रीमेंट कीज़ के साथ फिर से जोड़ा जाएगा।

function array_reindex($array, $start_index)
{
    $array = array_values($array);
    $zeros_array = array_fill(0, $start_index, null);
    return array_slice(array_merge($zeros_array, $array), $start_index, null, true);
}

Answer 15

बस यह करें:

<?php

array_push($array, '');
$array = array_reverse($array);
array_shift($array);

Answer 16

आप खाली सरणी तत्वों को हटाने और PHP में एक सरणी से reindex करने के लिए array_values ​​() और array_filter () फ़ंक्शन का उपयोग करने के बाद आसानी से कर सकते हैं।

array_filter () फ़ंक्शन PHP array_filter () फ़ंक्शन PHP में एक सरणी से खाली सरणी तत्वों या मूल्यों को हटा देता है। यह रिक्त, अशक्त, असत्य, 0 (शून्य) मानों को भी हटा देगा।

array_values ​​() फ़ंक्शन PHP array_values ​​() फ़ंक्शन एक सरणी के सभी मूल्यों से युक्त एक सरणी देता है। लौटे सरणी में संख्यात्मक कुंजी होंगी, 0 से शुरू होकर 1 तक बढ़ेंगी।

खाली एरे तत्वों और रेनडेक्स को हटा दें

पहले देखते हैं $ स्टैक सरणी आउटपुट:

<?php
  $stack = array("PHP", "HTML", "CSS", "", "JavaScript", null, 0);
  print_r($stack);
?>

आउटपुट:

Array
(
    [0] => PHP
    [1] => HTML
    [2] => CSS
    [3] => 
    [4] => JavaScript
    [5] => 
    [6] => 0
)

उपरोक्त आउटपुट में हम रिक्त, अशक्त, 0 (शून्य) मानों को निकालना चाहते हैं और फिर एरेक्स ऐरे तत्वों को हटाते हैं। अब हम array_values ​​() और array_filter () फ़ंक्शन का उपयोग नीचे दिए उदाहरण में एक साथ करेंगे:

<?php
  $stack = array("PHP", "HTML", "CSS", "", "JavaScript", null, 0);
  print_r(array_values(array_filter($stack)));
?>

आउटपुट:

Array
(
    [0] => PHP
    [1] => HTML
    [2] => CSS
    [3] => JavaScript
)

Comments

array_filter()ओपी के सैंपल डेटा के लिए पूरी तरह अप्रासंगिक लगता है।

— मिकमैकुसा

Answer 17

डुप्लिकेट निष्कासन और पुनर्भरण एक सरणी:

<?php  
   $oldArray = array('0'=>'php','1'=>'java','2'=>'','3'=>'asp','4'=>'','5'=>'mysql');
   //duplicate removal
   $fillteredArray = array_filter($oldArray);
   //reindexing actually happens  here
   $newArray = array_merge($filteredArray);
   print_r($newArray);
?>

Comments

array_filter()ओपी के सैंपल डेटा के लिए पूरी तरह अप्रासंगिक लगता है।

— मिकमैकुसा

Answer 18

सबसे तेज तरीका मैं सोच सकता हूं

array_unshift($arr, null);
unset($arr[0]);
print_r($arr);

और अगर आप केवल सरणी को फिर से लिखना चाहते हैं (शून्य पर शुरू करें) और आपके पास PHP +7.3 है तो आप इसे इस तरह से कर सकते हैं

array_unshift($arr);

मेरा मानना array_unshiftहै कि पहले से बेहतर है array_valuesक्योंकि पूर्व सरणी की एक प्रति नहीं बनाता है।

Answer 19

ऐसा लगता है कि सभी array_combine()उत्तर एक ही "गलती" (अनावश्यक कॉल array_values()) की नकल कर रहे हैं ।

array_combine() दोनों मापदंडों की कुंजियों को अनदेखा करता है जो इसे प्राप्त करता है।

कोड: ( डेमो )

$array = [
    2 => (object)['title' => 'Section', 'linked' => 1],
    1 => (object)['title' => 'Sub-Section', 'linked' => 1],
    0 => (object)['title' => 'Sub-Sub-Section', 'linked' => null]
];

var_export(array_combine(range(1, count($array)), $array));

आउटपुट:

array (
  1 => 
  (object) array(
     'title' => 'Section',
     'linked' => 1,
  ),
  2 => 
  (object) array(
     'title' => 'Sub-Section',
     'linked' => 1,
  ),
  3 => 
  (object) array(
     'title' => 'Sub-Sub-Section',
     'linked' => NULL,
  ),
)

Answer 20

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

<?php

function reindex(&$item, $key, &$reindexedarr) {
    $reindexedarr[$key+1] = $item;
}

$arr = Array (2 => 'c', 1 => 'b', 0 => 'a');

sort($arr);
$newarr = Array();
array_walk($arr, reindex, &$newarr);
$arr = $newarr;
print_r($arr); // Array ( [1] => a [2] => b [3] => c )

?>

Answer 21

यदि यह एक नया सरणी बनाना ठीक है, तो यह है:

$result = array();
foreach ( $array as $key => $val )
    $result[ $key+1 ] = $val;

यदि आपको जगह-जगह उलट-पलट की जरूरत है, तो आपको पीछे की तरफ दौड़ने की जरूरत है ताकि आप उन इंडेक्सों पर स्टंप न करें जो आपको चाहिए:

for ( $k = count($array) ; $k-- > 0 ; )
    $result[ $k+1 ] = $result[ $k ];
unset( $array[0] );   // remove the "zero" element

Comments

इस समस्या के किसी भी उत्तर को लूप की आवश्यकता नहीं होनी चाहिए। उत्तर का मुख्य भाग array_values()0-आधारित सरणी प्राप्त करने के लिए उपयोग कर रहा है और फिर उस परिणाम के लिए कुछ समायोजन कर रहा है यदि 1-आधारित सरणी वास्तव में आवश्यक है।

— 099 बजे अनुदान