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?


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
)

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.


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.


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
)

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

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
)

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.


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.


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

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 
)

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

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

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 
)

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

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
)

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

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

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

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

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

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
)

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

-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.

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.