Jak wstawić element do tablic w określonej pozycji?


190

Wyobraźmy sobie, że mamy dwie tablice:

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

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

Teraz chciałbym wstawić array('sample_key' => 'sample_value')po trzecim elemencie każdej tablicy. Jak mogę to zrobić?


Odpowiedzi:


208

array_slice()może być użyty do wyodrębnienia części tablicy, a operator tablicy+ unii ( ) może zrekombinować części.

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

Ten przykład:

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

daje:

Szyk
(
    [zero] => 0
    [jeden] => 1
    [dwa] => 2
    [mój_klucz] => moja_wartość
    [trzy] => 3
)

8
Powinieneś użyć array_splice () jak sugerował M42. Rozwiązuje problem w jednym wierszu kodu.
nickh 16.04.13

27
+nie powinien być używany! Użyj array_mergezamiast tego! UWAGA, jeśli indeksy są liczbami całkowitymi (normalna tablica, a nie skrót), +nie będą działać zgodnie z oczekiwaniami !!!
TMS

4
@Tomas To, czy będzie działać zgodnie z oczekiwaniami, czy nie, zależy od Twoich oczekiwań. array_mergezachowanie w odniesieniu do klawiszy numerycznych jest nieodpowiednie dla tego pytania.
Artefacto

10
Zamiast używać count($array)-3możesz po prostu określić null dla tego samego efektu. Ponadto używanie array_mergezgodnie z zaleceniami TMS nie będzie wymagać użycia unikalnego indeksu. PRZYKŁAD: Dodaj „nową wartość” do istniejącej tablicy:$b = array_merge( array_slice( $a, 0, 1, true ), array( 'new-value' ), array_slice( $a, 1, null, true ) );
Radley Sustaire

1
Wydaje się, że pewne zamieszanie o +wersetach array_merge. Jeśli chcesz wstawić rzeczy do tablicy numerycznej, nie powinieneś jej używać, +ponieważ prawdopodobnie nie spełni twoich oczekiwań. Ale nie powinieneś też używać array_merge; w przypadku tablic numerycznych cały problem rozwiązuje się za pomocą array_splicefunkcji. W przypadku tablic asocjacyjnych lub mieszanych prawdopodobnie nie chcesz ponownie indeksować kluczy numerycznych, więc użycie +jest całkowicie odpowiednie.
meustrus

104

Do pierwszej tablicy użyj array_splice():

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

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

wynik:

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

dla drugiego nie ma zamówienia, więc musisz tylko:

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

I posortuj klucze według tego, co chcesz.


33
Druga tablica ma kolejność ... Wszystkie tablice mają, ponieważ są również podwójnie połączonymi listami.
Artefacto

5
-1, jak wspomniano „nie ma porządku”, jest fałszem. Również tablica_splice niszczy powiązanie klucz / wartość w pierwszym przykładzie (ale być może OP zamierzało to).
Brad Koch

2
@Artefacto „Tablice” w PHP to tak naprawdę uporządkowane tabele skrótów . Tablice PHP działają jak tablice, ale tak naprawdę nigdy nie są tablicami; nie są też listami połączonymi ani listami tablic.
Frederik Krautwald,

1
5 godzin później w końcu przeczytałem odpowiedź Rozumiem, dziękuję! Należy jeszcze zauważyć, że jeśli ktoś wypycha tablicę asocjacyjną, może również określić „tablica” jako czwarty argument w tablicy_splice .. podobnie jak: tablica_splice ($ tablica_1, 3, 0, ARRAY ($ tablica_nazwa_wstaw));
Robert Sinclair,

1
@FrederikKrautwald Od PHP 7 to stwierdzenie nie jest prawdziwe. PHP 7 wykorzystuje dwie tablice do zaimplementowania tabeli skrótów + listy uporządkowanej. Oto artykuł jednego z głównych programistów PHP (Nikic): 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;
}

przykład:

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

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

Może nie wygląda idealnie, ale działa.


11
w zasadzie próbujesz splicować, nie wymyślaj ponownie koła.
Paul Dragoonis,

11
Nie, nie wymyśla koła na nowo. array_splice () nie pozwala na umieszczenie klucza i wartości. Wartość tylko z określoną pozycją jako kluczem.
Kirzilla

tak, ale jak wspomniano wcześniej, tablica_splice nie obsługuje tablic asocjacyjnych. Byłbym bardziej niż szczęśliwy widząc bardziej eleganckie podejście.
clausvdb

Twoja funkcja jest naprawdę dobra, ale nie działa poprawnie z pozycją większą niż długość tablicy (spróbuj wykonać to array_insert ($ array_2, array („wow” => „wow”), 4)). Ale można to łatwo naprawić. Twoja odpowiedź jest świetna i odpowiedziałeś na moje pytanie!
Kirzilla

13

Oto prosta funkcja, której możesz użyć. Po prostu podłącz i graj.

To jest Wstaw według indeksu, a nie według wartości.

możesz przekazać tablicę lub użyć tej, którą już zadeklarowałeś.

EDYCJA: krótsza wersja:

   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
}

Teraz możesz przetestować kod za pomocą

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

Rezultat to:

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

Tylko wspomnienie: zamiast array_merge można obecnie używać + między tablicami
roelleor 11.09.19

@roelleor Ale bądź ostrożny: „Jeśli tablice wejściowe mają takie same klucze łańcuchowe, to późniejsza wartość tego klucza zastąpi poprzednią. Jeśli jednak tablice zawierają klucze numeryczne, późniejsza wartość nie zastąpi pierwotnej wartości, ale zostaną dołączone ”. - array_merge
długi

5

Ta funkcja obsługuje:

  • zarówno klawisze numeryczne, jak i kombinowane
  • wstaw przed lub po założonym kluczu
  • dołącz na końcu tablicy, jeśli klucz nie jest założony

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;

    }

STOSOWANIE:

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

WYNIKI:

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

Niedawno napisałem funkcję, aby zrobić coś podobnego do tego, co brzmi jak próbujesz, jest to podobne podejście do odpowiedzi 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;
}

Zasadniczo wstawia w określonym punkcie, ale pozwala uniknąć nadpisywania poprzez przesunięcie wszystkich elementów w dół.


Spróbuj tego magic_insert (3, tablica („wow” => „wow”), $ array_2); Weź $ array_2 z tekstu pytania.
Kirzilla

Nie spodziewałbym się, że to zadziała, ponieważ $ array_2 jest asocjacyjny, a pojęcie pozycji zasadniczo nie ma znaczenia w takiej sytuacji.
Peter O'Callaghan,

4

Jeśli nie wiesz , że chcesz wstawić go w pozycji 3, ale znasz klucz , po którym chcesz go wstawić, po obejrzeniu tego pytania przygotowałem tę małą funkcję.

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

Oto skrzypce codepad, aby zobaczyć go w akcji: http://codepad.org/5WlKFKfz

Uwaga: array_splice () byłby o wiele bardziej wydajny niż array_merge (array_slice ()), ale wtedy klucze wstawionych tablic zostałyby utracone. Westchnienie.


3

Czystsze podejście (w oparciu o płynność użytkowania i mniej kodu).

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

Stosowanie:

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

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

die(var_dump($colors));

2

Najprostsze rozwiązanie, jeśli chcesz wstawić (element lub tablicę) po określonym kluczu:

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

Więc jeśli masz:

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

I wykonaj:

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

Będziesz miał:

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

2

Użycie array_splice zamiast array_splice daje o jedno mniejsze wywołanie funkcji.

$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

Robię to jak


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

Sformatuj kod pls, skorzystaj z przewodnika po formatach dostępnego w menu edycji <3
RaisingAgent

1

Właśnie stworzyłem klasę ArrayHelper, która bardzo ułatwiłaby indeksy liczbowe.

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

    }
}

Przykład:

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

Począwszy $ tablica:

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

Wynik:

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

1

Jest to lepsza metoda, jak wstawić element do tablicy na pewnej pozycji.

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

Potrzebowałem czegoś, co mogłoby zrobić wkładkę wcześniej, zastąpić, po kluczu; i dodaj na początku lub na końcu tablicy, jeśli klucz docelowy nie zostanie znaleziony. Domyślnie wstawia się po kluczu.

Nowa funkcja

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

Wpisz kod

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

Wynik

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

Bardzo prosta 2-strunowa odpowiedź na twoje pytanie:

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

Najpierw wstawiasz cokolwiek do trzeciego elementu za pomocą array_splice, a następnie przypisujesz wartość do tego elementu:

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

1

To stare pytanie, ale w 2014 roku opublikowałem komentarz i często do niego wracam. Myślałem, że zostawię pełną odpowiedź. To nie jest najkrótsze rozwiązanie, ale jest dość łatwe do zrozumienia.

Wstaw nową wartość do tablicy asocjacyjnej, w pozycji numerowanej, zachowując klucze i zachowując porządek.

$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

Nie tak konkretny jak odpowiedź Artefacto, ale opierając się na jego sugestii użycia array_slice (), napisałem następną funkcję:

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

Cechy:

  • Wstawianie jednej lub kilku wartości
  • Wstawianie par kluczy wartości
  • Wstawianie przed / za kluczem lub przez przesunięcie

Przykłady użycia:

$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

Jeśli chcesz tylko wstawić element do tablicy w określonej pozycji (na podstawie odpowiedzi @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

Oto moja wersja:

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

łatwy sposób .. używając 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);

Wynik..

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

2
Nie dodaje to niczego do wszystkich innych komentarzy i odpowiedzi
j08691

0

To jest inne rozwiązanie w 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

Możesz wstawiać elementy podczas pętli foreach , ponieważ ta pętla działa na kopii oryginalnej tablicy, ale musisz śledzić liczbę wstawionych linii (nazywam to „wzdęciem” w tym kodzie):

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

Oczywiście można uogólnić tę ideę „wzdęcia”, aby obsłużyć dowolne wstawianie i usuwanie podczas pętli foreach.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.