Como inserir elemento em matrizes na posição específica?

190

Vamos imaginar que temos duas matrizes:

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

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

Agora, gostaria de inserir o array('sample_key' => 'sample_value')terceiro elemento de cada matriz. Como eu posso fazer isso?

Kirzilla
fonte

Respostas:

208

array_slice()pode ser usado para extrair partes da matriz, e o operador da matriz de+ união ( ) pode recombinar as partes.

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

Este exemplo:

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

dá:

Matriz
(
    [zero] => 0
    [um] => 1
    [dois] => 2
    [my_key] => my_value
    [três] => 3
)
Artefacto
fonte
8
Você deve usar array_splice () como sugerido por M42. Ele resolve o problema em apenas uma linha de código.
nickh
27
+não deve ser usado! Use em array_mergevez disso! Porque se os índices são inteiros (matriz normal, não hash), +não funcionarão conforme o esperado !!!
TMS
4
@ Tomas Se funciona como esperado ou não, depende de suas expectativas. array_mergeO comportamento de teclas numéricas não é apropriado para esta pergunta.
Artefacto
10
Em vez de usar, count($array)-3você pode simplesmente especificar nulo para o mesmo efeito. Além disso, usar array_mergeo TMS sugerido não exigirá o uso de um índice exclusivo. EXEMPLO: Adicione "novo valor" a uma matriz existente:$b = array_merge( array_slice( $a, 0, 1, true ), array( 'new-value' ), array_slice( $a, 1, null, true ) );
Radley Sustaire
1
Parece haver alguma confusão sobre +vs. array_merge. Se você deseja inserir itens em uma matriz numérica, não deve usá- +la porque provavelmente não corresponderá às suas expectativas. Mas você também não deve usar array_merge; para matrizes numéricas, todo esse problema é resolvido com a array_splicefunção Para matrizes associativas ou mistas, você provavelmente não deseja que as chaves numéricas sejam indexadas novamente, portanto, o uso +é totalmente apropriado.
precisa saber é
104

Para sua primeira matriz, use array_splice():

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

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

resultado:

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

para o segundo não há pedido, então você só precisa fazer:

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

E ordene as chaves do jeito que você quiser.

Toto
fonte
33
A segunda matriz tem uma ordem ... Todas as matrizes têm, pois também são listas com links duplos.
Artefacto
5
-1, como mencionado "não há ordem", é falso. Além disso, array_splice destrói a associação de chave / valor no primeiro exemplo (mas talvez o OP pretendesse isso).
Brad Koch
2
@Artefacto "Arrays" em PHP são, de fato, tabelas de hash ordenadas . Matrizes PHP agem como matrizes, mas nunca são realmente matrizes; nem são listas vinculadas ou listas de matriz.
Frederik Krautwald
1
5 horas depois, finalmente li uma resposta, entendo, obrigado! Uma coisa extra a ser observada é que, se alguém estiver pressionando um array associativo, ele também poderá especificar "array" como o 4º argumento em array_splice ... assim: array_splice ($ array_1, 3, 0, ARRAY ($ array_name_to_inserir));
Robert Sinclair
1
@FrederikKrautwald Desde o PHP 7, essa afirmação não é verdadeira. O PHP 7 usa duas matrizes para implementar sua tabela de hash + lista ordenada. Aqui está um artigo de um dos principais desenvolvedores de PHP (Nikic): nikic.github.io/2014/12/22/…
CubicleSoft
19

código:

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

exemplo:

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

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

Pode não parecer realmente perfeito, mas funciona.

clausvdb
fonte
11
você está basicamente tentando fazer emendas, não reinvente a roda.
Paul Dragoonis 28/07/10
11
Não, ele não está reinventando a roda. array_splice () não permite colocar chave e valor. Somente valor com posição específica como chave.
Kirzilla
Sim, mas como observado anteriormente, array_splice não suporta matrizes associativas. Eu ficaria mais do que feliz em ver uma abordagem mais elegante.
Clausvdb 28/07/10
Sua função é realmente boa, mas não funciona apropriadamente com posições maiores que o comprimento do array (tente executar este array_insert ($ array_2, array ("wow" => "wow"), 4)). Mas pode ser facilmente consertado. Sua resposta é ótima e você respondeu minha pergunta!
Kirzilla
13

Aqui está uma função simples que você poderia usar. Basta conectar e reproduzir.

Isso é Inserir por índice, não por valor.

você pode optar por passar a matriz ou usar uma que você já declarou.

EDIT: Versão mais curta:

   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
}

Agora você pode testar o código usando

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

E o resultado é:

//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
fonte
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
fonte
Apenas uma menção: em vez de array_merge, pode-se também usar + entre matrizes hoje em dia
roelleor
@roelleor Mas tenha cuidado: "Se as matrizes de entrada tiverem as mesmas chaves de sequência, o valor posterior dessa chave substituirá a anterior. Se, no entanto, as matrizes contiverem teclas numéricas, o valor posterior não substituirá o valor original, mas será anexado ". - array_merge
long
5

Esta função suporta:

  • teclas numéricas e assoc
  • inserir antes ou depois da chave fundada
  • anexa ao final da matriz se a chave não for fundada

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;

    }

USO:

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

RESULTADOS:

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ć
fonte
4

Recentemente, escrevi uma função para fazer algo semelhante ao que parece que você está tentando, é uma abordagem semelhante à resposta do 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;
}

Basicamente, ele é inserido em um ponto específico, mas evita a substituição deslocando todos os itens para baixo.

Peter O'Callaghan
fonte
Experimente este magic_insert (3, array ("uau" => "uau"), $ array_2); Pegue $ array_2 do texto da pergunta.
Kirzilla
Eu não esperaria que isso funcionasse, já que $ array_2 é associativo e o conceito de posição geralmente não é relevante nessa situação.
Peter O'Callaghan
4

Se você não sabe que deseja inseri-lo na posição 3, mas conhece a chave que deseja inseri-lo depois, desenvolvi essa pequena função depois de ver esta pergunta.

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

Aqui está um violino do codepad para vê-lo em ação: http://codepad.org/5WlKFKfz

Nota: array_splice () teria sido muito mais eficiente que array_merge (array_slice ()), mas as chaves das matrizes inseridas seriam perdidas. Suspiro.

Tom Auger
fonte
3

Abordagem mais limpa (com base na fluidez de uso e menos código).

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

Uso:

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

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

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

Solução mais simples, se você deseja inserir (um elemento ou matriz) após uma determinada chave:

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

Então, se você tem:

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

E execute:

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

Você terá:

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

Usar array_splice em vez de array_slice fornece uma menos chamada de função.

$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
fonte
2

Eu faço isso como


    $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
fonte
Código de formato pls, use o guia de formato fornecido no menu de edição <3
RaisingAgent 10/10
1

Acabei de criar uma classe ArrayHelper que tornaria isso muito fácil para índices numéricos.

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

    }
}

Exemplo:

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

Começando $ array:

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

Resultado:

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

Este é o melhor método para inserir o item na matriz em alguma posição.

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říž
fonte
1

Eu precisava de algo que pudesse fazer uma inserção antes, substituir, depois da chave; e adicione no início ou no final da matriz se a chave de destino não for encontrada. O padrão é inserir após a chave.

Nova função

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

Código de entrada

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

Resultado

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
fonte
1

Resposta muito simples de 2 cordas à sua pergunta:

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

Primeiro, insira qualquer coisa no seu terceiro elemento com array_splice e atribua um valor a esse elemento:

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

Esta é uma pergunta antiga, mas eu postei um comentário em 2014 e frequentemente volto a isso. Eu pensei em deixar uma resposta completa. Essa não é a solução mais curta, mas é fácil de entender.

Insira um novo valor em uma matriz associativa, em uma posição numerada, preservando chaves e preservando a ordem.

$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
fonte
0

Não tão concreto quanto a resposta do Artefacto, mas baseado em sua sugestão de usar array_slice (), escrevi a seguinte função:

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

Recursos:

  • Inserindo um ou vários valores
  • Inserindo par (es) de valor-chave
  • Inserir antes / depois da tecla ou por deslocamento

Exemplos de uso:

$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
fonte
0

Caso você esteja apenas procurando inserir um item em uma matriz em uma determinada posição (com base na resposta @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
fonte
0

Aqui está a minha versão:

/**
 * 
 * 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;
}
desenvolvedor beta
fonte
0

maneira fácil .. usando 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);

Resultado..

Array
(
    [0] => zero
    [1] => one
    [2] => two
    [3] => sample_value
    [4] => three
)
Omair
fonte
2
Isso não adiciona nada a todos os outros comentários e respostas
j08691 26/02
0

Esta é outra solução em 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
fonte
-1

Você pode inserir elementos durante um loop foreach , já que esse loop funciona em uma cópia da matriz original, mas é necessário acompanhar o número de linhas inseridas (eu chamo isso de "inchaço" neste código):

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

Obviamente, você pode generalizar essa idéia de "inchaço" para lidar com inserções e exclusões arbitrárias durante o loop foreach.

David Spector
fonte