Belirli bir konumda dizilere eleman nasıl eklenir?


190

İki dizimiz olduğunu hayal edelim:

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

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

Şimdi, array('sample_key' => 'sample_value')her dizinin üçüncü öğesinden sonra eklemek istiyorum . Nasıl yapabilirim?


Yanıtlar:


208

array_slice()dizinin bölümlerini ayıklamak için kullanılabilir ve birleşim dizisi işleci ( +) parçaları yeniden birleştirebilir.

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

Bu örnek:

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

verir:

Dizi
(
    [sıfır] => 0
    [bir] => 1
    [iki] => 2
    [my_key] => değerim
    [üç] => 3
)

8
M42'nin önerdiği gibi array_splice () öğesini kullanmalısınız. Sorunu sadece bir kod satırında çözer.
nickh

27
+kullanılmamalıdır! array_mergeBunun yerine kullanın ! BE: indeksler tamsayı ise (normal dizi, karma değil), +beklendiği gibi çalışmaz !!!
TMS

4
@Tomas Beklendiği gibi çalışıp çalışmadığı beklentilerinize bağlıdır. array_mergesayısal tuşlarla ilgili davranışı bu soru için uygun değildir.
Artefacto

10
Kullanmak yerine count($array)-3aynı efekti null olarak belirtebilirsiniz. Ayrıca, array_mergeönerilen TMS olarak kullanmak benzersiz bir dizin kullanmanızı gerektirmez. ÖRNEK: Mevcut bir diziye "yeni değer" ekleyin:$b = array_merge( array_slice( $a, 0, 1, true ), array( 'new-value' ), array_slice( $a, 1, null, true ) );
Radley Sustaire

1
Hakkında bazı karışıklıklar var gibi görünüyor +vs. array_merge. Sayısal bir diziye bir şeyler eklemek istiyorsanız, kullanmamalısınız +çünkü muhtemelen beklentilerinize uymayacaktır. Ama array_mergeikisini de kullanmamalısınız ; sayısal diziler için, tüm bu problem array_splicefonksiyonla çözülür . İlişkilendirilebilir veya karışık diziler için, muhtemelen sayısal anahtarların yeniden dizine eklenmesini istemezsiniz +, bu nedenle kullanımı tamamen uygundur.
meustrus

104

İlk diziniz için şunu kullanın array_splice():

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

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

çıktı:

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

ikincisi için sipariş yoktur, bu yüzden yapmanız gerekenler:

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

Ve anahtarları ne istersen sırala.


33
İkinci dizinin bir sırası var ... Çift dizili listeler olduğu için tüm diziler var.
Artefacto

5
-1, belirtildiği gibi "sipariş yoktur" yanlıştır. Ayrıca, array_splice ilk örnekte anahtar / değer ilişkisini yok eder (ancak OP bunu belki de amaçlamıştır).
Brad Koch

2
@Artefacto PHP'deki "Diziler" aslında sıralı karma tablolardır . PHP dizileri diziler gibi davranır, ancak hiçbir zaman gerçekte diziler değildir; ne de bağlantılı listeler ya da dizi listeleri değildir.
Frederik Krautwald

1
5 saat sonra sonunda anladığım bir cevap okudum, teşekkürler! Birisi ilişkilendirilebilir bir diziyi itiyorsa, dizi_splice..'da 4. bağımsız değişken olarak "dizi" de belirtebileceğine dikkat edilmesi gereken bir şey daha vardır: array_splice ($ dizi_1, 3, 0, ARRAY ($ array_name_to_insert));
Robert Sinclair

1
@FrederikKrautwald PHP 7'den beri bu ifade doğru değildir. PHP 7, karma tablosu + sıralı listesini uygulamak için iki dizi kullanır. İşte temel PHP geliştiricilerinden (Nikic) bir makale: nikic.github.io/2014/12/22/…
CubicleSoft

19

kod:

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

misal:

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

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

Gerçekten mükemmel görünmeyebilir, ama işe yarıyor.


11
temelde yapıştırma yapmaya çalışıyorsunuz, tekerleği yeniden icat etmeyin.
Paul Dragoonis

11
Hayır, tekerleği yeniden icat etmiyor. array_splice (), anahtar ve değer koymaya izin vermez. Yalnızca anahtar olarak belirli bir konuma sahip değer.
Kirzilla

evet, ancak daha önce belirtildiği gibi, array_splice ilişkilendirilebilir dizileri desteklemez. Daha zarif bir yaklaşım gördüğüm için çok mutlu olurum.
clausvdb

İşleviniz gerçekten iyi, ancak dizi uzunluğundan daha büyük konumla düzgün çalışmıyor (bu array_insert'i ($ array_2, dizi ("wow" => "wow"), 4) çalıştırmayı deneyin). Ancak kolayca sabitlenebilir. Cevabınız harika ve sorumu cevapladınız!
Kirzilla

13

İşte kullanabileceğiniz basit bir işlev. Sadece tak ve çalıştır.

Bu, Değere Göre Değil, Dizine Göre Ekle'dir.

diziyi geçmeyi veya zaten bildirdiğiniz bir diziyi kullanmayı seçebilirsiniz.

EDIT: Kısa Versiyon:

   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
}

Şimdi kullanarak kodu test edebilirsiniz

//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>";

Ve sonuç:

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

Sadece bir söz:
dizi_merge

@roelleor Ama dikkatli olun: "Giriş dizileri aynı dize anahtarlarına sahipse, o anahtar için sonraki değer öncekinin üzerine yazılır. Ancak, diziler sayısal anahtarlar içeriyorsa, sonraki değer orijinal değerin üzerine yazılmaz, ancak eklenecektir. " - array_merge
uzun

5

Bu işlev şunları destekler:

  • hem sayısal hem de assoc tuşları
  • kurulan anahtardan önce veya sonra takın
  • anahtar oluşturulmamışsa dizinin sonuna ekle

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;

    }

KULLANIM:

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

SONUÇLAR:

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

Son zamanlarda, denediğiniz gibi kulağa benzer bir şey yapmak için bir işlev yazdım, clasvdb'nin cevabına benzer bir yaklaşım.

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

Temel olarak belirli bir noktaya eklenir, ancak tüm öğeleri aşağı kaydırarak üzerine yazmayı önler.


Bu magic_insert'i (3, dizi ("wow" => "wow"), $ dizi_2) deneyin; Soru metninden $ array_2 alın.
Kirzilla

Ben $ dizi_2 ilişkisel ve pozisyon kavramı genellikle böyle bir durumda ilgili olmadığı için çalışmak için beklemem.
Peter O'Callaghan

4

Eğer yoksa biliyorum sen pozisyon # 3'te eklemek istediğiniz, ama bilirsin anahtarı sen sonra eklemek istediğiniz, ben bu soruyu gördükten sonra bu küçük işlevi kadar pişirilir.

/**
     * 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;
    }

İşte onu görmek için bir kod takımı keman: http://codepad.org/5WlKFKfz

Not: array_splice (), array_merge (array_slice ()) 'dan çok daha verimli olurdu, ancak daha sonra eklenen dizilerinizin anahtarları kaybolurdu. İç çekmek.


3

Daha temiz bir yaklaşım (kullanım akışkanlığına ve daha az koda dayalı).

/**
 * 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;
}

Kullanımı:

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

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

die(var_dump($colors));

2

Belirli bir anahtarın arkasına (bir öğe veya dizi) eklemek istiyorsanız en basit çözüm:

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

Yani, eğer varsa:

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

Ve yürütün:

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

Sahip olacaksın:

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

2

Array_slice yerine array_splice kullanılması, bir tane daha az işlev çağrısı verir.

$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

Bunu şu şekilde yaparım


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

Biçim kodu pls, düzenleme menüsünde sağlanan biçim kılavuzunu kullanın <3
RaisingAgent

1

Az önce bunu sayısal dizinler için çok kolaylaştıracak bir ArrayHelper sınıfı oluşturdum.

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

    }
}

Misal:

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

Başlangıç ​​$ dizisi:

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

Sonuç:

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

1

Bu, bir konumdaki öğeyi diziye nasıl ekleyeceğinizin daha iyi bir yöntemidir.

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

Anahtardan önce, yerine, bir ekleme yapabileceği bir şeye ihtiyacım vardı; hedef anahtar bulunamazsa dizinin başına veya sonuna ekleyin. Varsayılan tuştan sonra eklenmelidir.

Yeni İşlev

/**
 * 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;
}

Giriş kodu

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

Çıktı

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

Sorunuza çok basit 2 dize cevabı:

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

İlk önce array_splice ile üçüncü öğenize bir şey ekler ve ardından bu öğeye bir değer atarsınız:

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

1

Bu eski bir soru, ancak 2014'te bir yorum gönderdim ve sık sık buna geri dönüyorum. Tam bir cevap bırakacağımı düşündüm. Bu en kısa çözüm değil, ama anlaşılması oldukça kolay.

İlişkilendirilmiş bir diziye numaralı bir konumda, anahtarları koruyarak ve düzeni koruyarak yeni bir değer ekleyin.

$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'nun cevabı kadar somut değil, ama array_slice () kullanma önerisine dayanarak, bir sonraki işlevi yazdım:

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

Özellikleri:

  • Bir veya birden fazla değer ekleme
  • Anahtar / değer çiftlerini ekleme
  • Anahtardan önce / sonra veya ofset ile ekleme

Kullanım örnekleri:

$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

Bir diziye belirli bir konumdaki bir öğeyi eklemek istiyorsanız (@clausvdb yanıtına göre):

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

İşte benim sürüm:

/**
 * 
 * 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

kolay yolu .. kullanarak 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);

Sonuç..

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

2
Bu, diğer tüm yorum ve cevaplara bir şey eklemez
j08691

0

Bu başka bir çözüm 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

Bu döngü orijinal dizinin bir kopyası üzerinde çalıştığından, foreach döngüsü sırasında öğeler ekleyebilirsiniz , ancak eklenen satırların sayısını izlemeniz gerekir (bu kodda bu "bloat" diyorum):

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

Açıkçası, bu "şişkinlik" fikrini foreach döngüsü sırasında rastgele eklemeler ve silmeler ile başa çıkabilirsiniz.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.