Wie füge ich ein Element an einer bestimmten Position in Arrays ein?

188

Stellen wir uns vor, wir haben zwei Arrays:

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

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

Jetzt möchte ich array('sample_key' => 'sample_value')nach dem dritten Element jedes Arrays einfügen . Wie kann ich es tun?

Kirzilla
quelle

Antworten:

206

array_slice()kann verwendet werden, um Teile des Arrays zu extrahieren, und der Union- Array-Operator ( +) kann die Teile neu kombinieren.

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

Dieses Beispiel:

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

gibt:

Array
(
    [Null] => 0
    [eins] => 1
    [zwei] => 2
    [my_key] => my_value
    [drei] => 3
)
Artefakt
quelle
8
Sie sollten array_splice () verwenden, wie von M42 vorgeschlagen. Es löst das Problem in nur einer Codezeile.
Nickh
27
+sollte nicht verwendet werden! Verwenden Sie array_mergestattdessen! Weil die Indizes ganzzahlig sind (normales Array, kein Hash), +funktionieren sie nicht wie erwartet !!!
TMS
4
@Tomas Ob es wie erwartet funktioniert oder nicht, hängt von Ihren Erwartungen ab. array_mergeDas Verhalten von Zifferntasten ist für diese Frage nicht geeignet.
Artefacto
10
Anstatt zu verwenden count($array)-3, können Sie einfach null angeben, um den gleichen Effekt zu erzielen. Auch die Verwendung array_mergeals TMS vorgeschlagen benötigen Sie keine eindeutigen Index zu verwenden. BEISPIEL: Hinzufügen eines "neuen Werts" zu einem vorhandenen Array:$b = array_merge( array_slice( $a, 0, 1, true ), array( 'new-value' ), array_slice( $a, 1, null, true ) );
Radley Sustaire
1
Es scheint eine gewisse Verwirrung über sein +vs. array_merge. Wenn Sie Dinge in ein numerisches Array einfügen möchten, sollten Sie es nicht verwenden, +da es wahrscheinlich nicht Ihren Erwartungen entspricht. Aber Sie sollten auch nicht verwenden array_merge; Bei numerischen Arrays wird dieses ganze Problem mit der array_spliceFunktion gelöst . Für assoziative oder gemischte Arrays möchten Sie wahrscheinlich nicht, dass numerische Schlüssel neu indiziert werden, daher ist die Verwendung +völlig angemessen.
Meustrus
103

Verwenden Sie für Ihr erstes Array array_splice():

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

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

Ausgabe:

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

Für den zweiten gibt es keine Bestellung, Sie müssen also nur Folgendes tun:

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

Und sortieren Sie die Schlüssel nach Belieben.

Toto
quelle
33
Das zweite Array hat eine Reihenfolge ... Alle Arrays haben, da sie auch doppelt verknüpfte Listen sind.
Artefacto
5
-1, wie erwähnt "es gibt keine Reihenfolge" ist falsch. Außerdem zerstört array_splice die Schlüssel / Wert-Zuordnung im ersten Beispiel (aber möglicherweise hat das OP dies beabsichtigt).
Brad Koch
2
@Artefacto "Arrays" in PHP sind in der Tat geordnete Hash-Tabellen . PHP-Arrays verhalten sich wie Arrays, sind jedoch nie wirklich Arrays. Sie sind auch keine verknüpften Listen oder Array-Listen.
Frederik Krautwald
1
5 Stunden später las ich endlich eine Antwort, die ich verstehe, danke! Beachten Sie außerdem, dass jemand, der ein assoziatives Array pusht, auch "array" als viertes Argument in array_splice angeben kann.
Robert Sinclair
1
@FrederikKrautwald Seit PHP 7 ist diese Aussage nicht wahr. PHP 7 verwendet zwei Arrays, um seine Hash-Tabelle + geordnete Liste zu implementieren. Hier ist ein Artikel von einem der wichtigsten PHP-Entwickler (Nikic): nikic.github.io/2014/12/22/…
CubicleSoft
19

Code:

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

Beispiel:

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

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

Mag nicht wirklich perfekt aussehen, aber es funktioniert.

clausvdb
quelle
11
Sie versuchen im Grunde, zu spleißen, erfinden Sie das Rad nicht neu.
Paul Dragoonis
11
Nein, er erfindet das Rad nicht neu. array_splice () erlaubt es nicht, Schlüssel und Wert zu setzen. Nur Wert mit bestimmter Position als Schlüssel.
Kirzilla
Ja, aber wie bereits erwähnt, unterstützt array_splice keine assoziativen Arrays. Ich würde mich sehr über einen eleganteren Ansatz freuen.
Clausvdb
Ihre Funktion ist wirklich gut, aber sie funktioniert nicht ordnungsgemäß mit einer Position, die größer als die Array-Länge ist (versuchen Sie, dieses array_insert auszuführen ($ array_2, array ("wow" => "wow"), 4)). Aber es kann leicht behoben werden. Ihre Antwort ist großartig und Sie haben meine Frage beantwortet!
Kirzilla
13

Hier ist eine einfache Funktion, die Sie verwenden können. Einfach Plug n Play.

Dies ist Einfügen nach Index, nicht nach Wert.

Sie können das Array übergeben oder eines verwenden, das Sie bereits deklariert haben.

EDIT: Kürzere Version:

   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
}

Jetzt können Sie den Code mit testen

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

Und das Ergebnis ist:

//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
)
Mohammed Joraid
quelle
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));
foued611
quelle
Nur eine Erwähnung: Anstelle von array_merge kann man heutzutage auch + zwischen Arrays verwenden
Roelleor
@roelleor Aber seien Sie vorsichtig: "Wenn die Eingabearrays dieselben Zeichenfolgenschlüssel haben, überschreibt der spätere Wert für diesen Schlüssel den vorherigen. Wenn die Arrays jedoch numerische Schlüssel enthalten, überschreibt der spätere Wert den ursprünglichen Wert nicht. wird aber angehängt. " - array_merge
langer
5

Diese Funktion unterstützt:

  • sowohl numerische als auch Assoc-Tasten
  • vor oder nach dem begründeten Schlüssel einfügen
  • an das Ende des Arrays anhängen, wenn der Schlüssel nicht gefunden wurde

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;

    }

VERWENDUNG:

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

ERGEBNISSE:

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
)
Déján Kőŕdić
quelle
4

Ich habe kürzlich eine Funktion geschrieben, um etwas Ähnliches zu tun, wie es sich anhört, als ob Sie es versuchen. Es ist ein ähnlicher Ansatz für die Antwort von 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;
}

Grundsätzlich wird es an einer bestimmten Stelle eingefügt, aber das Überschreiben wird vermieden, indem alle Elemente nach unten verschoben werden.

Peter O'Callaghan
quelle
Versuchen Sie dies magic_insert (3, Array ("wow" => "wow"), $ array_2); Nehmen Sie $ array_2 aus dem Fragentext.
Kirzilla
Ich würde nicht erwarten, dass das funktioniert, da $ array_2 assoziativ ist und das Konzept der Position in einer solchen Situation im Allgemeinen nicht relevant ist.
Peter O'Callaghan
4

Wenn Sie nicht wissen, dass Sie es an Position 3 einfügen möchten, aber den Schlüssel kennen , nach dem Sie es einfügen möchten, habe ich diese kleine Funktion erfunden, nachdem ich diese Frage gesehen habe.

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

Hier ist eine Codepad-Geige, um sie in Aktion zu sehen: http://codepad.org/5WlKFKfz

Hinweis: array_splice () wäre viel effizienter gewesen als array_merge (array_slice ()), aber dann wären die Schlüssel Ihrer eingefügten Arrays verloren gegangen. Seufzer.

Tom Auger
quelle
3

Saubererer Ansatz (basierend auf flüssiger Nutzung und weniger Code).

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

Verwendung:

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

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

die(var_dump($colors));
Luka
quelle
2

Einfachste Lösung, wenn Sie (ein Element oder Array) nach einem bestimmten Schlüssel einfügen möchten:

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

Also, wenn Sie haben:

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

Und ausführen:

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

Du wirst haben:

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

Die Verwendung von array_splice anstelle von array_slice führt zu einem Funktionsaufruf weniger.

$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);
Florent
quelle
2

Ich mache das als


    $slightly_damaged = array_merge(
        array_slice($slightly_damaged, 0, 4, true) + ["4" => "0.0"], 
        array_slice($slightly_damaged, 4, count($slightly_damaged) - 4, true)
    );
HacheCuatro
quelle
Formatieren Sie den Code pls. Verwenden Sie die Formatierungsanleitung im Bearbeitungsmenü <3
RaisingAgent
1

Ich habe gerade eine ArrayHelper-Klasse erstellt, die dies für numerische Indizes sehr einfach macht.

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

    }
}

Beispiel:

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

Beginn $ array:

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

Ergebnis:

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

Dies ist eine bessere Methode, um ein Element an einer bestimmten Position in ein Array einzufügen.

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;
}
Lukáš Kříž
quelle
1

Ich brauchte etwas, das vor, nach und nach dem Schlüssel eingefügt werden konnte. und am Anfang oder Ende des Arrays hinzufügen, wenn der Zielschlüssel nicht gefunden wird. Standardmäßig wird nach dem Schlüssel eingefügt.

Neue Funktion

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

Code eingeben

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

Ausgabe

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
)
mikeytown2
quelle
1

Sehr einfache 2-saitige Antwort auf Ihre Frage:

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

Zuerst fügen Sie mit array_splice etwas in Ihr drittes Element ein und weisen diesem Element dann einen Wert zu:

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

Dies ist eine alte Frage, aber ich habe 2014 einen Kommentar gepostet und komme häufig darauf zurück. Ich dachte, ich würde eine vollständige Antwort hinterlassen. Dies ist nicht die kürzeste Lösung, aber leicht zu verstehen.

Fügen Sie an einer nummerierten Position einen neuen Wert in ein assoziatives Array ein, wobei die Schlüssel und die Reihenfolge erhalten bleiben.

$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 
)
*/
Radley Sustaire
quelle
0

Nicht so konkret wie die Antwort von Artefacto, aber basierend auf seinem Vorschlag, array_slice () zu verwenden, schrieb ich die nächste Funktion:

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

Eigenschaften:

  • Einfügen eines oder mehrerer Werte
  • Einfügen von Schlüsselwertpaaren
  • Einfügen vor / nach dem Schlüssel oder durch Versatz

Anwendungsbeispiele:

$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)); 
mikl
quelle
0

Für den Fall, dass Sie nur ein Element an einer bestimmten Position in ein Array einfügen möchten (basierend auf der Antwort von @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;
}
Samuel Delesque
quelle
0

Hier ist meine Version:

/**
 * 
 * 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;
}
Beta-Entwickler
quelle
0

einfacher Weg .. mit 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);

Ergebnis..

Array
(
    [0] => zero
    [1] => one
    [2] => two
    [3] => sample_value
    [4] => three
)
Omair
quelle
2
Dies fügt nichts zu allen anderen Kommentaren und Antworten hinzu
j08691
0

Dies ist eine weitere Lösung in 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)
        );
    }
sergeliatko
quelle
-1

Sie können Elemente während einer foreach-Schleife einfügen , da diese Schleife auf einer Kopie des ursprünglichen Arrays funktioniert , Sie jedoch die Anzahl der eingefügten Zeilen verfolgen müssen (ich nenne dies in diesem Code "Aufblähen"):

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

Natürlich können Sie diese "Aufblähungs" -Idee verallgemeinern, um beliebige Einfügungen und Löschungen während der foreach-Schleife zu verarbeiten.

David Spector
quelle