विशिष्ट स्थिति में सरणियों में तत्व कैसे डालें?


190

आइए कल्पना करें कि हमारे पास दो सरणियाँ हैं:

$array_1 = array(
  '0' => 'zero',
  '1' => 'one',
  '2' => 'two',
  '3' => 'three',
);

$array_2 = array(
  'zero'  => '0',
  'one'   => '1',
  'two'   => '2',
  'three' => '3',
);

अब, मैं array('sample_key' => 'sample_value')प्रत्येक सरणी के तीसरे तत्व के बाद सम्मिलित करना चाहूंगा । मैं यह कैसे कर सकता हूं?


जवाबों:


207

array_slice()सरणी के कुछ हिस्सों को निकालने के लिए इस्तेमाल किया जा सकता है, और संघ सरणी ऑपरेटर ( +) भागों को फिर से जोड़ सकता है।

$res = array_slice($array, 0, 3, true) +
    array("my_key" => "my_value") +
    array_slice($array, 3, count($array)-3, true);

यह उदाहरण:

$array = array(
  'zero'  => '0',
  'one'   => '1',
  'two'   => '2',
  'three' => '3',
);
$res = array_slice($array, 0, 3, true) +
    array("my_key" => "my_value") +
    array_slice($array, 3, count($array) - 1, true) ;
print_r($res);

देता है:

सरणी
(
    [शून्य] => ०
    [एक] => १
    [दो] => २
    [my_key] => my_value
    [तीन] => ३
)

8
जैसा कि M42 ने सुझाव दिया है आप array_splice () का उपयोग करें। यह कोड की सिर्फ एक लाइन में समस्या को हल करता है।
निक

27
+इस्तेमाल नहीं किया जाना चाहिए! array_mergeइसके बजाय का उपयोग करें ! मान लीजिए कि इंडेक्स पूर्णांक हैं (सामान्य सरणी, हैश नहीं), +अपेक्षा के अनुरूप काम नहीं करेगा !!!
टीएमएस

4
@ टोमस उम्मीद के मुताबिक काम करता है या नहीं यह आपकी उम्मीदों पर निर्भर करता है। array_mergeसंख्यात्मक प्रश्नों के संबंध में व्यवहार इस प्रश्न के लिए उपयुक्त नहीं है।
Artefacto

10
उपयोग करने के बजाय count($array)-3आप बस उसी प्रभाव को शून्य निर्दिष्ट कर सकते हैं। इसके अलावा, array_mergeटीएमएस के रूप में उपयोग करने के लिए आपको एक अद्वितीय सूचकांक का उपयोग करने की आवश्यकता नहीं होगी। उदाहरण: मौजूदा सरणी में "नया-मान" जोड़ें:$b = array_merge( array_slice( $a, 0, 1, true ), array( 'new-value' ), array_slice( $a, 1, null, true ) );
Radley Sustaire

1
+बनाम के बारे में कुछ भ्रम होने लगता है array_merge। यदि आप चीजों को एक संख्यात्मक सरणी में सम्मिलित करना चाहते हैं, तो आपको इसका उपयोग नहीं करना चाहिए +क्योंकि यह संभवतः आपकी अपेक्षाओं से मेल नहीं खाएगा। लेकिन आपको array_mergeया तो उपयोग नहीं करना चाहिए ; संख्यात्मक सरणियों के लिए, यह पूरी समस्या array_spliceफ़ंक्शन के साथ हल की गई है। साहचर्य या मिश्रित सरणियों के लिए, आप संभवतः संख्यात्मक कुंजियों को दोबारा अनुक्रमित नहीं करना चाहते हैं, इसलिए इसका उपयोग +पूरी तरह से उचित है।
meustrus

103

अपने पहले एरे के लिए, उपयोग करें array_splice():

$array_1 = array(
  '0' => 'zero',
  '1' => 'one',
  '2' => 'two',
  '3' => 'three',
);

array_splice($array_1, 3, 0, 'more');
print_r($array_1);

उत्पादन:

Array(
    [0] => zero
    [1] => one
    [2] => two
    [3] => more
    [4] => three
)

दूसरे के लिए कोई आदेश नहीं है इसलिए आपको बस करना है:

$array_2['more'] = '2.5';
print_r($array_2);

और जो भी आप चाहते हैं, उसके आधार पर छाँटें।


33
दूसरे सरणी में एक आदेश है ... सभी सरणियों के पास है, क्योंकि वे डबल लिंक्ड सूची भी हैं।
आर्टेक्टैक्टो

5
-1, जैसा कि उल्लेख किया गया है "कोई आदेश नहीं है" गलत है। इसके अलावा, array_splice पहले उदाहरण में कुंजी / मूल्य एसोसिएशन को नष्ट कर देता है (लेकिन शायद ओपी का इरादा है कि)।
ब्रैड कोच

2
PHP में @Artefacto "Arrays", वास्तव में, हैश टेबल का आदेश दिया है । PHP सरणियाँ सरणियों की तरह कार्य करती हैं, लेकिन वे वास्तव में कभी सरणियाँ नहीं हैं; न ही वे लिंक लिस्ट हैं, न ही एरे लिस्ट।
फ्रेडरिक क्राउटवल्ड

1
5 घंटे बाद मैं अंत में एक जवाब पढ़ता हूं जो मुझे समझ में आया, धन्यवाद! एक बात और ध्यान दें कि यदि किसी को एक साहचर्य सारणी धक्का दे रही है, तो वे array_splice में भी 4 वें तर्क के रूप में "सरणी" को निर्दिष्ट कर सकते हैं..इस तरह: array_splice ($ array_1, 3, 0, ARRAY ($ array_s_to_insert));
रॉबर्ट सिनक्लेयर

1
@FrederikKrautwald PHP 7 के बाद से, यह कथन सत्य नहीं है। PHP 7 अपनी हैश तालिका + आदेशित सूची को लागू करने के लिए दो सरणियों का उपयोग करता है। यहाँ कोर PHP देवों (निकिक) में से एक से एक लेख है: nikic.github.io/2014/12/22/…
CubicleSoft

19

कोड:

function insertValueAtPosition($arr, $insertedArray, $position) {
    $i = 0;
    $new_array=[];
    foreach ($arr as $key => $value) {
        if ($i == $position) {
            foreach ($insertedArray as $ikey => $ivalue) {
                $new_array[$ikey] = $ivalue;
            }
        }
        $new_array[$key] = $value;
        $i++;
    }
    return $new_array;
}

उदाहरण:

$array        = ["A"=8, "K"=>3];
$insert_array = ["D"= 9];

insertValueAtPosition($array, $insert_array, $position=2);
// result ====> ["A"=>8,  "D"=>9,  "K"=>3];

वास्तव में सही नहीं लग सकता है, लेकिन यह काम करता है।


11
आप मूल रूप से splicing करने की कोशिश कर रहे हैं, पहिया को सुदृढ़ मत करो।
पॉल ड्रैगुनिस

11
नहींं, वह पहिए को नहीं लगा रहा है। array_splice () कुंजी और मान रखने की अनुमति नहीं देता है। केवल कुंजी के रूप में विशिष्ट स्थिति के साथ मूल्य।
किर्ज़िला

हाँ, लेकिन जैसा कि पहले कहा गया है, array_splice सहयोगी सरणियों का समर्थन नहीं करता है। मैं और अधिक सुंदर दृष्टिकोण देखने के लिए खुश हूं।
क्लॉसव्डब

आपका कार्य वास्तव में अच्छा है, लेकिन यह सरणी की लंबाई से बड़ी स्थिति के साथ उचित रूप से काम नहीं करता है (इस array_insert ($ array_2, array ("wow" => "wow"), 4) को निष्पादित करने का प्रयास करें)। लेकिन इसे आसानी से तय किया जा सकता है। आपका उत्तर बहुत अच्छा है और आपने मेरे प्रश्न का उत्तर दिया है!
किर्ज़िला

13

यहां एक सरल कार्य है जिसे आप उपयोग कर सकते हैं। बस प्लग एन प्ले।

यह इन्सर्ट बाय इंडेक्स है, नॉट बाय वैल्यू।

आप ऐरे को पास करना चुन सकते हैं, या एक का उपयोग कर सकते हैं जिसे आपने पहले ही घोषित कर दिया है।

संपादित करें: छोटा संस्करण:

   function insert($array, $index, $val)
   {
       $size = count($array); //because I am going to use this more than one time
       if (!is_int($index) || $index < 0 || $index > $size)
       {
           return -1;
       }
       else
       {
           $temp   = array_slice($array, 0, $index);
           $temp[] = $val;
           return array_merge($temp, array_slice($array, $index, $size));
       }
   }

  function insert($array, $index, $val) { //function decleration
    $temp = array(); // this temp array will hold the value 
    $size = count($array); //because I am going to use this more than one time
    // Validation -- validate if index value is proper (you can omit this part)       
        if (!is_int($index) || $index < 0 || $index > $size) {
            echo "Error: Wrong index at Insert. Index: " . $index . " Current Size: " . $size;
            echo "<br/>";
            return false;
        }    
    //here is the actual insertion code
    //slice part of the array from 0 to insertion index
    $temp = array_slice($array, 0, $index);//e.g index=5, then slice will result elements [0-4]
    //add the value at the end of the temp array// at the insertion index e.g 5
    array_push($temp, $val);
    //reconnect the remaining part of the array to the current temp
    $temp = array_merge($temp, array_slice($array, $index, $size)); 
    $array = $temp;//swap// no need for this if you pass the array cuz you can simply return $temp, but, if u r using a class array for example, this is useful. 

     return $array; // you can return $temp instead if you don't use class array
}

अब आप कोड का उपयोग करके परीक्षण कर सकते हैं

//1
$result = insert(array(1,2,3,4,5),0, 0);
echo "<pre>";
echo "<br/>";
print_r($result);
echo "</pre>";
//2
$result = insert(array(1,2,3,4,5),2, "a");
echo "<pre>";
print_r($result);
echo "</pre>";
//3
$result = insert(array(1,2,3,4,5) ,4, "b");
echo "<pre>";
print_r($result);
echo "</pre>";
//4
$result = insert(array(1,2,3,4,5),5, 6);
echo "<pre>";
echo "<br/>";
print_r($result);
echo "</pre>";

और परिणाम है:

//1
Array
(
    [0] => 0
    [1] => 1
    [2] => 2
    [3] => 3
    [4] => 4
    [5] => 5
)
//2
Array
(
    [0] => 1
    [1] => 2
    [2] => a
    [3] => 3
    [4] => 4
    [5] => 5
)
//3
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => b
    [5] => 5
)

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

12
$list = array(
'Tunisia' => 'Tunis',
'Germany' => 'Berlin',
'Italy' => 'Rom',
'Egypt' => 'Cairo'
);
$afterIndex = 2;
$newVal= array('Palestine' => 'Jerusalem');

$newList = array_merge(array_slice($list,0,$afterIndex+1), $newVal,array_slice($list,$afterIndex+1));

सिर्फ एक उल्लेख: array_merge के बजाय, आजकल कोई भी सरणियों के बीच + का उपयोग कर सकता है
roelleor

@roelleor लेकिन सावधान रहें: "यदि इनपुट सरणियों में समान स्ट्रिंग कुंजियाँ हैं, तो उस कुंजी के लिए बाद का मान पिछले वाले को अधिलेखित कर देगा। यदि, हालांकि, सरणियों में संख्यात्मक कुंजियाँ हैं, तो बाद का मान मूल मान को अधिलेखित नहीं करेगा। लेकिन जोड़ दिया जाएगा। " - array_merge
लंबे

5

यह फ़ंक्शन समर्थन करता है:

  • दोनों संख्यात्मक और assoc चाबियाँ
  • स्थापित कुंजी के पहले या बाद में डालें
  • यदि कुंजी स्थापित नहीं है, तो सरणी के अंत में संलग्न करें

function insert_into_array( $array, $search_key, $insert_key, $insert_value, $insert_after_founded_key = true, $append_if_not_found = false ) {

        $new_array = array();

        foreach( $array as $key => $value ){

            // INSERT BEFORE THE CURRENT KEY? 
            // ONLY IF CURRENT KEY IS THE KEY WE ARE SEARCHING FOR, AND WE WANT TO INSERT BEFORE THAT FOUNDED KEY
            if( $key === $search_key && ! $insert_after_founded_key )
                $new_array[ $insert_key ] = $insert_value;

            // COPY THE CURRENT KEY/VALUE FROM OLD ARRAY TO A NEW ARRAY
            $new_array[ $key ] = $value;

            // INSERT AFTER THE CURRENT KEY? 
            // ONLY IF CURRENT KEY IS THE KEY WE ARE SEARCHING FOR, AND WE WANT TO INSERT AFTER THAT FOUNDED KEY
            if( $key === $search_key && $insert_after_founded_key )
                $new_array[ $insert_key ] = $insert_value;

        }

        // APPEND IF KEY ISNT FOUNDED
        if( $append_if_not_found && count( $array ) == count( $new_array ) )
            $new_array[ $insert_key ] = $insert_value;

        return $new_array;

    }

उपयोग:

    $array1 = array(
        0 => 'zero',
        1 => 'one',
        2 => 'two',
        3 => 'three',
        4 => 'four'
    );

    $array2 = array(
        'zero'  => '# 0',
        'one'   => '# 1',
        'two'   => '# 2',
        'three' => '# 3',
        'four'  => '# 4'
    );

    $array3 = array(
        0 => 'zero',
        1 => 'one',
       64 => '64',
        3 => 'three',
        4 => 'four'
    );


    // INSERT AFTER WITH NUMERIC KEYS
    print_r( insert_into_array( $array1, 3, 'three+', 'three+ value') );

    // INSERT AFTER WITH ASSOC KEYS
    print_r( insert_into_array( $array2, 'three', 'three+', 'three+ value') );

    // INSERT BEFORE
    print_r( insert_into_array( $array3, 64, 'before-64', 'before-64 value', false) );

    // APPEND IF SEARCH KEY ISNT FOUNDED
    print_r( insert_into_array( $array3, 'undefined assoc key', 'new key', 'new value', true, true) );

परिणाम:

Array
(
    [0] => zero
    [1] => one
    [2] => two
    [3] => three
    [three+] => three+ value
    [4] => four
)
Array
(
    [zero] => # 0
    [one] => # 1
    [two] => # 2
    [three] => # 3
    [three+] => three+ value
    [four] => # 4
)
Array
(
    [0] => zero
    [1] => one
    [before-64] => before-64 value
    [64] => 64
    [3] => three
    [4] => four
)
Array
(
    [0] => zero
    [1] => one
    [64] => 64
    [3] => three
    [4] => four
    [new key] => new value
)

4

मैंने हाल ही में कुछ ऐसा ही करने के लिए एक फ़ंक्शन लिखा है जो आपको लगता है कि आप प्रयास कर रहे हैं, यह clasvdb के उत्तर के समान है।

function magic_insert($index,$value,$input_array ) {
  if (isset($input_array[$index])) {
    $output_array = array($index=>$value);
    foreach($input_array as $k=>$v) {
      if ($k<$index) {
        $output_array[$k] = $v;
      } else {
        if (isset($output_array[$k]) ) {
          $output_array[$k+1] = $v;
        } else {
          $output_array[$k] = $v;
        }
      } 
    }

  } else {
    $output_array = $input_array;
    $output_array[$index] = $value;
  }
  ksort($output_array);
  return $output_array;
}

मूल रूप से यह एक विशिष्ट बिंदु पर सम्मिलित होता है, लेकिन सभी वस्तुओं को नीचे स्थानांतरित करके ओवरराइटिंग से बचा जाता है।


इस मैजिक_इन्टर को आज़माएं (3, सरणी ("वाह" => "वाह"), $ array_2); प्रश्न टेक्स्ट से $ array_2 लें।
किर्ज़िला

मुझे उम्मीद नहीं होगी कि $ array_2 के बाद से काम करना साहचर्य है और ऐसी स्थिति में आमतौर पर स्थिति की अवधारणा प्रासंगिक नहीं है।
पीटर ओ'कालाघन

4

यदि आप यह नहीं जानते कि आप इसे # 3 स्थिति में सम्मिलित करना चाहते हैं, लेकिन आप उस कुंजी को जानते हैं जिसे आप इसे सम्मिलित करना चाहते हैं, तो मैंने इस प्रश्न को देखने के बाद इस छोटे से कार्य को पकाया।

/**
     * Inserts any number of scalars or arrays at the point
     * in the haystack immediately after the search key ($needle) was found,
     * or at the end if the needle is not found or not supplied.
     * Modifies $haystack in place.
     * @param array &$haystack the associative array to search. This will be modified by the function
     * @param string $needle the key to search for
     * @param mixed $stuff one or more arrays or scalars to be inserted into $haystack
     * @return int the index at which $needle was found
     */                         
    function array_insert_after(&$haystack, $needle = '', $stuff){
        if (! is_array($haystack) ) return $haystack;

        $new_array = array();
        for ($i = 2; $i < func_num_args(); ++$i){
            $arg = func_get_arg($i);
            if (is_array($arg)) $new_array = array_merge($new_array, $arg);
            else $new_array[] = $arg;
        }

        $i = 0;
        foreach($haystack as $key => $value){
            ++$i;
            if ($key == $needle) break;
        }

        $haystack = array_merge(array_slice($haystack, 0, $i, true), $new_array, array_slice($haystack, $i, null, true));

        return $i;
    }

इसे कार्रवाई में देखने के लिए यहां एक कोडपैड फिडेल है: http://codepad.org/5WlKFKfz

नोट: array_splice () array_merge (array_slice ()) की तुलना में बहुत अधिक कुशल रहा होगा, लेकिन तब आपके सम्मिलित सरणियों की कुंजी खो गई होगी। आह।


3

क्लीनर दृष्टिकोण (उपयोग की तरलता और कम कोड के आधार पर)।

/**
 * Insert data at position given the target key.
 *
 * @param array $array
 * @param mixed $target_key
 * @param mixed $insert_key
 * @param mixed $insert_val
 * @param bool $insert_after
 * @param bool $append_on_fail
 * @param array $out
 * @return array
 */
function array_insert(
    array $array, 
    $target_key, 
    $insert_key, 
    $insert_val = null,
    $insert_after = true,
    $append_on_fail = false,
    $out = [])
{
    foreach ($array as $key => $value) {
        if ($insert_after) $out[$key] = $value;
        if ($key == $target_key) $out[$insert_key] = $insert_val;
        if (!$insert_after) $out[$key] = $value;
    }

    if (!isset($array[$target_key]) && $append_on_fail) {
        $out[$insert_key] = $insert_val;
    }

    return $out;
}

उपयोग:

$colors = [
    'blue' => 'Blue',
    'green' => 'Green',
    'orange' => 'Orange',
];

$colors = array_insert($colors, 'blue', 'pink', 'Pink');

die(var_dump($colors));

2

सरल समाधान, यदि आप एक निश्चित कुंजी के बाद (एक तत्व या सरणी) सम्मिलित करना चाहते हैं:

function array_splice_after_key($array, $key, $array_to_insert)
{
    $key_pos = array_search($key, array_keys($array));
    if($key_pos !== false){
        $key_pos++;
        $second_array = array_splice($array, $key_pos);
        $array = array_merge($array, $array_to_insert, $second_array);
    }
    return $array;
}

इसलिए, यदि आपके पास:

$array = [
    'one' => 1,
    'three' => 3
];
$array_to_insert = ['two' => 2];

और निष्पादित करें:

$result_array = array_splice_after_key($array, 'one', $array_to_insert);

तुम्हारे पास होगा:

Array ( 
    ['one'] => 1 
    ['two'] => 2 
    ['three'] => 3 
)

2

Array_slice के बजाय array_splice का उपयोग करना एक कम फ़ंक्शन कॉल देता है।

$toto =  array(
  'zero'  => '0',
  'one'   => '1',
  'two'   => '2',
  'three' => '3'
);
$ret = array_splice($toto, 3 );
$toto = $toto +  array("my_key" => "my_value") + $ret;
print_r($toto);

2

मैं वैसा करता हूं


    $slightly_damaged = array_merge(
        array_slice($slightly_damaged, 0, 4, true) + ["4" => "0.0"], 
        array_slice($slightly_damaged, 4, count($slightly_damaged) - 4, true)
    );

प्रारूप कोड pls, संपादन मेनू <3
RaisingAgent

1

मैंने सिर्फ एक ArrayHelper क्लास बनाया है जो संख्यात्मक सूचकांक के लिए इसे बहुत आसान बना देगा।

class ArrayHelper
{
    /*
        Inserts a value at the given position or throws an exception if
        the position is out of range.
        This function will push the current values up in index. ex. if 
        you insert at index 1 then the previous value at index 1 will 
        be pushed to index 2 and so on.
        $pos: The position where the inserted value should be placed. 
        Starts at 0.
    */
    public static function insertValueAtPos(array &$array, $pos, $value) {
        $maxIndex = count($array)-1;

        if ($pos === 0) {
            array_unshift($array, $value);
        } elseif (($pos > 0) && ($pos <= $maxIndex)) {
            $firstHalf = array_slice($array, 0, $pos);
            $secondHalf = array_slice($array, $pos);
            $array = array_merge($firstHalf, array($value), $secondHalf);
        } else {
            throw new IndexOutOfBoundsException();
        }

    }
}

उदाहरण:

$array = array('a', 'b', 'c', 'd', 'e');
$insertValue = 'insert';
\ArrayHelper::insertValueAtPos($array, 3, $insertValue);

$ सरणी की शुरुआत:

Array ( 
    [0] => a 
    [1] => b 
    [2] => c 
    [3] => d 
    [4] => e 
)

परिणाम:

Array ( 
    [0] => a 
    [1] => b 
    [2] => c 
    [3] => insert 
    [4] => d 
    [5] => e 
)

1

यह बेहतर तरीका है कि किसी स्थिति पर सरणी में आइटम कैसे डालें।

function arrayInsert($array, $item, $position)
{
    $begin = array_slice($array, 0, $position);
    array_push($begin, $item);
    $end = array_slice($array, $position);
    $resultArray = array_merge($begin, $end);
    return $resultArray;
}

1

मुझे कुछ ऐसा चाहिए था जो कुंजी के पहले, प्रतिस्थापित, कर सके; और यदि लक्ष्य कुंजी नहीं मिली है तो सरणी के आरंभ या अंत में जोड़ें। डिफ़ॉल्ट कुंजी के बाद सम्मिलित करना है।

नया फंक्शन

/**
 * Insert element into an array at a specific key.
 *
 * @param array $input_array
 *   The original array.
 * @param array $insert
 *   The element that is getting inserted; array(key => value).
 * @param string $target_key
 *   The key name.
 * @param int $location
 *   1 is after, 0 is replace, -1 is before.
 *
 * @return array
 *   The new array with the element merged in.
 */
function insert_into_array_at_key(array $input_array, array $insert, $target_key, $location = 1) {
  $output = array();
  $new_value = reset($insert);
  $new_key = key($insert);
  foreach ($input_array as $key => $value) {
    if ($key === $target_key) {
      // Insert before.
      if ($location == -1) {
        $output[$new_key] = $new_value;
        $output[$key] = $value;
      }
      // Replace.
      if ($location == 0) {
        $output[$new_key] = $new_value;
      }
      // After.
      if ($location == 1) {
        $output[$key] = $value;
        $output[$new_key] = $new_value;
      }
    }
    else {
      // Pick next key if there is an number collision.
      if (is_numeric($key)) {
        while (isset($output[$key])) {
          $key++;
        }
      }
      $output[$key] = $value;
    }
  }
  // Add to array if not found.
  if (!isset($output[$new_key])) {
    // Before everything.
    if ($location == -1) {
      $output = $insert + $output;
    }
    // After everything.
    if ($location == 1) {
      $output[$new_key] = $new_value;
    }

  }
  return $output;
}

इनपुट कोड

$array_1 = array(
  '0' => 'zero',
  '1' => 'one',
  '2' => 'two',
  '3' => 'three',
);
$array_2 = array(
  'zero'  => '0',
  'one'   => '1',
  'two'   => '2',
  'three' => '3',
);

$array_1 = insert_into_array_at_key($array_1, array('sample_key' => 'sample_value'), 2, 1);
print_r($array_1);
$array_2 = insert_into_array_at_key($array_2, array('sample_key' => 'sample_value'), 'two', 1);
print_r($array_2);

उत्पादन

Array
(
    [0] => zero
    [1] => one
    [2] => two
    [sample_key] => sample_value
    [3] => three
)
Array
(
    [zero] => 0
    [one] => 1
    [two] => 2
    [sample_key] => sample_value
    [three] => 3
)

1

आपके प्रश्न का बहुत ही सरल 2 स्ट्रिंग उत्तर:

$array_1 = array(
  '0' => 'zero',
  '1' => 'one',
  '2' => 'two',
  '3' => 'three',
);

पहले आप array_splice के साथ अपने तीसरे तत्व में कुछ भी डालें और फिर इस तत्व को एक मान दें:

array_splice($array_1, 3, 0 , true);
$array_1[3] = array('sample_key' => 'sample_value');

1

यह एक पुराना सवाल है, लेकिन मैंने 2014 में एक टिप्पणी पोस्ट की थी और अक्सर इस पर वापस आता हूं। मुझे लगा कि मैं पूरा जवाब छोड़ दूंगा। यह सबसे छोटा समाधान नहीं है, लेकिन इसे समझना काफी आसान है।

एक क्रमबद्ध स्थिति में, एक महत्वपूर्ण स्थान पर, कुंजी को संरक्षित करने, और संरक्षण क्रम में एक नया मान डालें।

$columns = array(
    'id' => 'ID',
    'name' => 'Name',
    'email' => 'Email',
    'count' => 'Number of posts'
);

$columns = array_merge(
    array_slice( $columns, 0, 3, true ),     // The first 3 items from the old array
    array( 'subscribed' => 'Subscribed' ),   // New value to add after the 3rd item
    array_slice( $columns, 3, null, true )   // Other items after the 3rd
);

print_r( $columns );

/*
Array ( 
    [id] => ID 
    [name] => Name 
    [email] => Email 
    [subscribed] => Subscribed 
    [count] => Number of posts 
)
*/

0

Artefacto के उत्तर के रूप में ठोस नहीं है, लेकिन array_slice () का उपयोग करने के अपने सुझाव के आधार पर, मैंने अगला फ़ंक्शन लिखा:

function arrayInsert($target, $byKey, $byOffset, $valuesToInsert, $afterKey) {
    if (isset($byKey)) {
        if (is_numeric($byKey)) $byKey = (int)floor($byKey);
        $offset = 0;

        foreach ($target as $key => $value) {
            if ($key === $byKey) break;
            $offset++;
        }

        if ($afterKey) $offset++;
    } else {
        $offset = $byOffset;
    }

    $targetLength = count($target);
    $targetA = array_slice($target, 0, $offset, true);
    $targetB = array_slice($target, $offset, $targetLength, true);
    return array_merge($targetA, $valuesToInsert, $targetB);
}

विशेषताएं:

  • एक या म्यूचुअल अनुयायियों को सम्मिलित करना
  • प्रमुख मूल्य युग्म सम्मिलित करना
  • कुंजी के पहले / बाद में या ऑफसेट द्वारा सम्मिलित करना

उपयोग के उदाहरण:

$target = [
    'banana' => 12,
    'potatoe' => 6,
    'watermelon' => 8,
    'apple' => 7,
    2 => 21,
    'pear' => 6
];

// Values must be nested in an array
$insertValues = [
    'orange' => 0,
    'lemon' => 3,
    3
];

// By key
// Third parameter is not applicable
//     Insert after 2 (before 'pear')
var_dump(arrayInsert($target, 2, null, $valuesToInsert, true));
//     Insert before 'watermelon'
var_dump(arrayInsert($target, 'watermelon', null, $valuesToInsert, false)); 

// By offset
// Second and last parameter are not applicable
//     Insert in position 2 (zero based i.e. before 'watermelon')
var_dump(arrayInsert($target, null, 2, $valuesToInsert, null)); 

0

यदि आप किसी वस्तु को किसी निश्चित स्थिति में एक सरणी में डालना चाहते हैं (@clausvdb उत्तर के आधार पर):

function array_insert($arr, $insert, $position) {
    $i = 0;
    $ret = array();
    foreach ($arr as $key => $value) {
            if ($i == $position) {
                $ret[] = $insert;
            }
            $ret[] = $value;
            $i++;
    }
    return $ret;
}

0

यहाँ मेरा संस्करण है:

/**
 * 
 * Insert an element after an index in an array
 * @param array $array  
 * @param string|int $key 
 * @param mixed $value
 * @param string|int $offset
 * @return mixed
 */
function array_splice_associative($array, $key, $value, $offset) {
    if (!is_array($array)) {
        return $array;
    }
    if (array_key_exists($key, $array)) {
        unset($array[$key]);
    }
    $return = array();
    $inserted = false;
    foreach ($array as $k => $v) {
        $return[$k] = $v;
        if ($k == $offset && !$inserted) {
            $return[$key] = $value;
            $inserted = true;
        }
    }
    if (!$inserted) {
        $return[$key] = $value;
    }


    return $return;
}

0

आसान तरीका .. उपयोग करना array_splice()

$array_1 = array(
  '0' => 'zero',
  '1' => 'one',
  '2' => 'two',
  '3' => 'three',
);

$addArray = array('sample_key' => 'sample_value');

array_splice($rs, 3, 0, $addArray);

परिणाम..

Array
(
    [0] => zero
    [1] => one
    [2] => two
    [3] => sample_value
    [4] => three
)

2
यह अन्य सभी टिप्पणियों और उत्तरों के लिए कुछ भी नहीं जोड़ता है
j08691

0

यह एक और उपाय है PHP 7.1


     /**
     * @param array $input    Input array to add items to
     * @param array $items    Items to insert (as an array)
     * @param int   $position Position to inject items from (starts from 0)
     *
     * @return array
     */
    function arrayInject( array $input, array $items, int $position ): array 
    {
        if (0 >= $position) {
            return array_merge($items, $input);
        }
        if ($position >= count($input)) {
            return array_merge($input, $items);
        }

        return array_merge(
            array_slice($input, 0, $position, true),
            $items,
            array_slice($input, $position, null, true)
        );
    }

-1

आप फ़ॉरेस्ट लूप के दौरान तत्वों को सम्मिलित कर सकते हैं , क्योंकि यह लूप मूल सरणी की एक प्रति पर काम करता है , लेकिन आपको सम्मिलित लाइनों की संख्या पर नज़र रखनी होगी (मैं इस कोड में "ब्लोट" कहता हूं):

$bloat=0;
foreach ($Lines as $n=>$Line)
    {
    if (MustInsertLineHere($Line))
        {
        array_splice($Lines,$n+$bloat,0,"string to insert");
        ++$bloat;
        }
    }

स्पष्ट रूप से, आप फ़ॉरेस्ट लूप के दौरान मनमाने सम्मिलन और विलोपन को संभालने के लिए इस "ब्लोट" विचार को सामान्य कर सकते हैं।

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