Adding element at specified index location in an array. Powershell

If we need flat array in result, we can use sum operator:

Code bellow is adding [string]'Word' at position 4 of $array1

$new_array = @($array1[0..3]) + @('Word') + @($array1[4..5])

use-case is concatenate two flat arrays together, or add some data at some position of fixed array.

This is how i managed it. Wrapped into a function. Although you may have issues. if your array values are very long.

$myArray = @("how","to","slice","into","an","array")

Function Insert-ToArray($Array, $insertAfter, $valueToInsert){
#find the index of value before insertion
$insertPoint = $Array.IndexOf($insertAfter)
#split the array into two parts
$firstHalf = $Array[0..$insertPoint]
$secondHalf = $Array[($insertPoint +1)..$Array.Length]
#slice into a new array
$newArray = @($firstHalf,$valueToInsert,$secondHalf)
return $newArray
#returning this new array means you can assign it over the old array
}

$myArray = Insert-ToArray -Array $myArray -insertAfter "slice" -valueToInsert "something"

$myArray

As you claim you are trying to understand how to work without List, I'll explain how arrays work behind the scenes. This kind of data manipulation is mostly encountered on low-level programming, like data structures classes and C programming. High-level languages like Java, C# and Powershell do employ these techniques, but actual implementations are way hidden from the user. Still, the runtime does something akin these steps.

Array as a basic data structure do not actually support insert. Array supports only read and write operations. Think an array as a squared maths paper, in which each array cell is a square on the paper. Write some text into the paper (pipe chars illustriate the squares and numbers are indexes):

 0 1 2 3 4 5 6 7
|t|s|t| |t|e|x|t|

Now consider inserting missing e letter into the word tst to make it test. What'll happen? A new array is needed:

 0 1 2 3 4 5 6 7 8
|t|e|s|t| |t|e|x|t|

Note that after inserting e into 2nd cell, all the remaining letters are moved one step forward. So what happened? The insertion routine you did by hand was like so,

1. Copy items from original array into new array until read index is insertion index
2. Add inserted character into new array at insertion index
3. Copy items from original array into new array. Insertion index is one more than read index

As you can see, the process is a bit cubersome. When "inserting" a letter on the paper, you don't create new, empty cell in the original array. You have to copy all the elements by hand.

As an alternative for a brand new array, you can resize the array by adding an extra cell into it. Then, instead of copying letters to new array, you'd start from the end of the array and copy letters one step forward until at the insertion index. Then you add the inserted letter and stop. So,

 0 1 2 3 4 5 6 7 8
|t|s|t| |t|e|x|t| | # start
|t|s|t| |t|e|x|t|t| # moved last t to the end
|t|s|t| |t|e|x|x|t| # overwrite old t with x
|t|s|t| |t|e|e|x|t| # overwrite old x with e
|t|s|t| |t|t|e|x|t| # and so on
|t|s|t| | |t|e|x|t|
|t|s|t|t| |t|e|x|t|
|t|s|s|t| |t|e|x|t| # insert location reached after this
|t|e|s|t| |t|e|x|t| # don't overwrite s with t but e. Done!

Now that you understand how array insertion works, mjolinor's example is easy to understand. A new array is created by copying elements from start to insertion point, adding the insert and copying the rest of the array contents.

You can do it with array slicing:

$array = @(1,2,4,5)
$value = 3
$index  = 2

$array = $array[0..($index -1)] + $value + $array[$index..($array.Length -1)]

$array

Function InsertToArray($Array, $insertIndex, $valueToInsert){
    return @(
        for ($i = 0; $i -lt $insertIndex; $i++) {
            $Array[$i]
        }
        $valueToInsert
        for ($i = $insertIndex; $i -lt $Array.Length; $i++) {
            $Array[$i]
        }
    )
}

PowerShell accepts negative index values, by counting backward from the end of the array. In that spirit, I wrote another function to insert a value into an array at a specified index, which also works with negative indexes. (Pedantically, I chose "Merge" for the function name because I didn't find "Insert" in the output of the Get-Verb cmdlet.)

function Merge-IntoArray {
    param(
        [Parameter(Mandatory=$true)] [Object[]]$Array,
        [Parameter(Mandatory=$true)] [int]$Index,
        [Parameter(Mandatory=$true)] [Object]$Value
    )
    if ($Index -eq 0 -or $Index -le -$Array.Count) {
        $Result = @($Value) + $Array
    }
    elseif ($Index -lt 0 -and $Index -gt -$Array.Count) {
        $Result = $Array[-($Array.Count)..($Index-1)] + @($Value) + $Array[$Index..-1]
    }
    elseif ($Index -ge $Array.Count) {
        $Result = $Array + @($Value)
    }
    else {
        $Result = $Array[0..($Index-1)] + @($Value) + $Array[$Index..($Array.Count-1)]
    }
    return $Result
}

Here is a PowerShell Core one-liner that tests indexes ranging through every edge case:

PS > $a='a'..'d'; foreach ($i in -5..5) { "$((Merge-IntoArray $a $i 'xxx') -join ', ')  <-- inserted at index $i"}
xxx, a, b, c, d  <-- inserted at index -5
xxx, a, b, c, d  <-- inserted at index -4
a, xxx, b, c, d  <-- inserted at index -3
a, b, xxx, c, d  <-- inserted at index -2
a, b, c, xxx, d  <-- inserted at index -1
xxx, a, b, c, d  <-- inserted at index 0
a, xxx, b, c, d  <-- inserted at index 1
a, b, xxx, c, d  <-- inserted at index 2
a, b, c, xxx, d  <-- inserted at index 3
a, b, c, d, xxx  <-- inserted at index 4
a, b, c, d, xxx  <-- inserted at index 5