Comment insérer un élément dans des tableaux à une position spécifique?


190

Imaginons que nous ayons deux tableaux:

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

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

Maintenant, je voudrais insérer array('sample_key' => 'sample_value')après le troisième élément de chaque tableau. Comment puis-je le faire?


Réponses:


208

array_slice()peut être utilisé pour extraire des parties du tableau, et l' opérateur de tableau+ union ( ) peut recombiner les parties.

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

Cet exemple:

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

donne:

Tableau
(
    [zéro] => 0
    [one] => 1
    [deux] => 2
    [my_key] => ma_valeur
    [trois] => 3
)

8
Vous devriez utiliser array_splice () comme M42 l'a suggéré. Il résout le problème en une seule ligne de code.
nickh

27
+ne doit pas être utilisé! Utilisez array_mergeplutôt! BEcause si les indices sont entiers (tableau normal, pas de hachage), +ne fonctionnera pas comme prévu !!!
TMS

4
@Tomas Que cela fonctionne comme prévu ou non dépend de vos attentes. array_mergeLe comportement de par rapport aux touches numériques n'est pas approprié pour cette question.
Artefacto

10
Au lieu d'utiliser, count($array)-3vous pouvez simplement spécifier null pour le même effet. De plus, utiliser array_mergecomme TMS suggéré ne vous obligera pas à utiliser un index unique. EXEMPLE: Ajouter "new-value" à un tableau existant:$b = array_merge( array_slice( $a, 0, 1, true ), array( 'new-value' ), array_slice( $a, 1, null, true ) );
Radley Sustaire

1
Il semble y avoir une certaine confusion à propos de +vs array_merge.. Si vous souhaitez insérer des éléments dans un tableau numérique, vous ne devriez pas l'utiliser +car il ne correspondra probablement pas à vos attentes. Mais vous ne devriez pas utiliser non array_mergeplus; pour les tableaux numériques, tout ce problème est résolu avec la array_splicefonction. Pour les tableaux associatifs ou mixtes, vous ne voulez probablement pas que les clés numériques soient réindexées, donc l'utilisation +est tout à fait appropriée.
meustrus

104

Pour votre premier tableau, utilisez array_splice():

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

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

production:

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

pour le second il n'y a pas d'ordre donc il suffit de faire:

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

Et triez les clés selon ce que vous voulez.


33
Le deuxième tableau a un ordre ... Tous les tableaux ont, car ils sont aussi des listes à double chaînage.
Artefacto

5
-1, comme mentionné "il n'y a pas d'ordre" est faux. De plus, array_splice détruit l'association clé / valeur dans le premier exemple (mais peut-être que l'OP l'a voulu).
Brad Koch

2
@Artefacto Les "tableaux" en PHP sont en fait des tables de hachage ordonnées . Les tableaux PHP agissent comme des tableaux, mais ce ne sont jamais vraiment des tableaux; ce ne sont pas non plus des listes liées ou des listes de tableaux.
Frederik Krautwald

1
5 heures plus tard j'ai enfin lu une réponse que je comprends, merci! Une chose supplémentaire à noter que si quelqu'un pousse un tableau associatif, il peut également spécifier "array" comme 4ème argument dans array_splice.. comme ceci: array_splice ($ array_1, 3, 0, ARRAY ($ array_name_to_insert));
Robert Sinclair

1
@FrederikKrautwald Depuis PHP 7, cette affirmation n'est pas vraie. PHP 7 utilise deux tableaux pour implémenter sa table de hachage + liste ordonnée. Voici un article de l'un des principaux développeurs PHP (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;
}

exemple:

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

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

Peut-être pas vraiment parfait, mais cela fonctionne.


11
vous essayez essentiellement de faire des épissures, ne réinventez pas la roue.
Paul Dragoonis

11
Non, il ne réinvente pas la roue. array_splice () ne permet pas de mettre la clé et la valeur. Seule valeur avec une position spécifique comme clé.
Kirzilla

oui, mais comme indiqué précédemment, array_splice ne prend pas en charge les tableaux associatifs. Je serais plus qu'heureux de voir une approche plus élégante.
clausvdb

Votre fonction est vraiment bonne, mais elle ne fonctionne pas correctement avec une position plus grande que la longueur du tableau (essayez d'exécuter ce array_insert ($ array_2, array ("wow" => "wow"), 4)). Mais cela peut être facilement corrigé. Votre réponse est excellente et vous avez répondu à ma question!
Kirzilla

13

Voici une fonction simple que vous pouvez utiliser. Il suffit de brancher et de jouer.

Il s'agit d'insérer par index, pas par valeur.

vous pouvez choisir de transmettre le tableau ou d'en utiliser un que vous avez déjà déclaré.

EDIT: Version plus courte:

   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
}

Vous pouvez maintenant tester le code en utilisant

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

Et le résultat est:

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

Juste une mention: au lieu de array_merge, on peut aussi utiliser + entre les tableaux de nos jours
roelleor

@roelleor Mais attention: "Si les tableaux d'entrée ont les mêmes clés de chaîne, la dernière valeur de cette clé écrasera la précédente. Si, cependant, les tableaux contiennent des touches numériques, la valeur la plus récente n'écrasera pas la valeur d'origine, mais sera ajouté. " - array_merge
long

5

Cette fonction prend en charge:

  • touches numériques et associées
  • insérer avant ou après la clé trouvée
  • ajouter à la fin du tableau si la clé n'est pas fondée

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;

    }

USAGE:

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

RÉSULTATS:

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

J'ai récemment écrit une fonction pour faire quelque chose de similaire à ce que vous essayez, c'est une approche similaire à la réponse de 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;
}

Fondamentalement, il s'insère à un point spécifique, mais évite l'écrasement en déplaçant tous les éléments vers le bas.


Essayez ceci magic_insert (3, array ("wow" => "wow"), $ array_2); Prenez $ array_2 du texte de la question.
Kirzilla

Je ne m'attendrais pas à ce que cela fonctionne puisque $ array_2 est associatif et que le concept de position n'est généralement pas pertinent dans une telle situation.
Peter O'Callaghan

4

Si vous ne savez pas que vous voulez l'insérer à la position n ° 3, mais que vous connaissez la clé que vous voulez insérer après, j'ai concocté cette petite fonction après avoir vu cette question.

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

Voici un violon du clavier pour le voir en action: http://codepad.org/5WlKFKfz

Remarque: array_splice () aurait été beaucoup plus efficace que array_merge (array_slice ()) mais les clés de vos tableaux insérés auraient été perdues. Soupir.


3

Approche plus propre (basée sur la fluidité d'utilisation et moins de 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;
}

Usage:

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

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

die(var_dump($colors));

2

Solution la plus simple, si vous souhaitez insérer (un élément ou un tableau) après une certaine clé:

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

Donc, si vous avez:

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

Et exécutez:

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

Tu vas avoir:

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

2

L'utilisation de array_splice au lieu de array_slice donne un appel de fonction en moins.

$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

Je fais ça comme


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

Code de format pls, utilisez le guide de format fourni dans le menu d'édition <3
RaisingAgent

1

Je viens de créer une classe ArrayHelper qui rendrait cela très facile pour les index numériques.

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

    }
}

Exemple:

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

Début $ array:

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

Résultat:

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

1

C'est une meilleure méthode pour insérer un élément dans un tableau à une certaine position.

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

J'avais besoin de quelque chose qui pourrait faire un insert avant, remplacer, après la clé; et ajoutez au début ou à la fin du tableau si la clé cible n'est pas trouvée. La valeur par défaut est d'insérer après la clé.

Nouvelle fonction

/**
 * 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 d'entrée

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

Production

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

Réponse très simple en 2 cordes à votre question:

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

Au début, vous insérez n'importe quoi dans votre troisième élément avec array_splice, puis attribuez une valeur à cet élément:

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

1

C'est une vieille question, mais j'ai posté un commentaire en 2014 et j'y reviens fréquemment. J'ai pensé que je laisserais une réponse complète. Ce n'est pas la solution la plus courte mais elle est assez simple à comprendre.

Insérez une nouvelle valeur dans un tableau associatif, à une position numérotée, en préservant les clés et en préservant l'ordre.

$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

Pas aussi concret que la réponse d'Artefacto, mais basé sur sa suggestion d'utiliser array_slice (), j'ai écrit la fonction suivante:

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

Fonctionnalités:

  • Insérer une ou plusieurs valeurs
  • Insertion de paires valeur / clé
  • Insertion avant / après la clé, ou par décalage

Exemples d'utilisation:

$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

Si vous cherchez simplement à insérer un élément dans un tableau à une certaine position (en fonction de la réponse @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

Voici ma 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

moyen simple .. utilisation 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);

Résultat..

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

2
Cela n'ajoute rien à tous les autres commentaires et réponses
j08691

0

Ceci est une autre solution 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

Vous pouvez insérer des éléments pendant une boucle foreach , puisque cette boucle fonctionne sur une copie du tableau d'origine, mais vous devez garder une trace du nombre de lignes insérées (j'appelle cela "bloat" dans ce code):

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

Évidemment, vous pouvez généraliser cette idée de «gonflement» pour gérer les insertions et les suppressions arbitraires pendant la boucle foreach.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.