How to add a prefix to every element of an array in shell

In Bash, zsh or ksh93u+m 1.0.6 or newer¹, you can use the ${parameter/#pattern/string} pattern substitution parameter expansion operator to prepend -l to each array element. You may then redefine your array like this:

array=( "${array[@]/#/-l}" )

Note that if the source was sparse, a relatively uncommon case, this will reset the indexes to 0 through N-1.

^{¹ That operator is initially from ksh93 in 1993, but initially didn't perform any substitution if the pattern was empty. yash and mksh also support that operator but yash still behaves like ksh93 originally and in mksh, it cannot be performed on array expansions.}

The only array in Bourne or standard (POSIX, SUS, XPG, LSB, Debian-policy...) sh syntax is the list of positional parameters ($1, $2...) that one can set as a whole with:

set -- 'first element' 'second
element
with newlines' 3 4...

(set -- only needed if the first element may start with - or + or if the list may be empty, not needed in that example, but good habit to get into in the general case).

To prefix each with some string, in sh, you'd need a loop:

for element do
  set -- "$@" "prefix$element"
  shift
done

Arrays are a feature originally from the csh shell, though ksh, and most other shells also added arrays of their own thereafter but in incompatible fashions¹, which is the main reason why POSIX couldn't add array support for sh (in particular, the sh specification is mostly based on ksh, and the array design in ksh (mostly copied by bash) is among the worst of them all).

The

array=('first element' 'second
element
with newlines' 3 4...)

syntax is that (initially in 1991) of the zsh shell, whose array design is more inspired by that of csh (from the late 70s) than that of ksh (from the early 80s) where the corresponding syntax was rather set -A array -- 'first element'..., though that zsh syntax has been copied since by other shells including ksh93, bash (in 1996; bash had not array before that) and yash (though only the latter has an array design otherwise close to that of zsh).

In zsh, to prefix something to an array, you just do:

array=( prefix$^array )

Where $^array expands the array rc-style (after set -o rcexpandparam, you can just use $array instead of $^array).

And since, there, the array of positional parameters is also available in the $argv array, you can do the same for positional parameters with:

argv=( prefix$^argv )

In ksh (and bash which copied its array design), arrays are not really arrays but more associative arrays with keys limited to positive integers or so-called sparse arrays.

To add a prefix to the values of the elements, whilst keeping the keys intact, you'd need a loop:

for key in "${!array[@]}"; do
  array[key]=prefix${array[key]}
done

(which won't work in ksh88/pdksh, you need ksh93, bash or mksh).

array=( "${array[@]/#/prefix}" )

(zsh, bash, ksh93u+m 1.0.6+ only)

would work but will unsparsify the array, so will change the keys if the array was initially sparse.

Example in bash:

bash-5.2$ array[12]=foo array[67]=bar
bash-5.2$ typeset -p array
declare -a array=([12]="foo" [67]="bar")
bash-5.2$ for key in "${!array[@]}"; do
  array[key]=prefix${array[key]}
done
bash-5.2$ typeset -p array
declare -a array=([12]="prefixfoo" [67]="prefixbar")
bash-5.2$ array=( "${array[@]/#/prefix}" )
bash-5.2$ typeset -p array
declare -a array=([0]="prefixprefixfoo" [1]="prefixprefixbar")

That's not a problem in your case as your array is not sparse to start with and you likely don't care about key values anyway.

In the rc shell and derivatives:

array = ( prefix$array )

In the fish shell:

set array prefix$array

^{¹ For details on array support in various Bourne-like shells, see Test for array support by shell}

Interesting. The bash substitution given above does not work for ksh.

$ ksh
$ array=("A" "B" "ElementC" "ElementE")
$ echo  "${array[@]/#/-l}"
A B ElementC ElementE
$ Version AJM 93u+ 2012-08-01

My ksh version to replace the original array is:

array=(  "${array[@]/#+(?)/-l\1}" )

This says match one or more of any character at the start of the string and replace it with -l followed by the original string.

It seems ksh does not match zero length strings the way bash does.

This improved (thanks @ilkkachu) version works if any elements of the array have spaces, such as:

ksh $ array=("A" "B" "ElementC" "Element  E")
ksh $ newArray=(  "${array[@]/#+(?)/-l\1}" )
ksh $ for ii in ${!newArray[@]};do echo "$ii ${newArray[ii]} ";done
0 -lA
1 -lB
2 -lElementC
3 -lElement  E