Bash
Tableaux

Assignations de tableaux

Affectation de liste

Si vous êtes familier avec Perl, C ou Java, vous pourriez penser que Bash utilisera des virgules pour séparer les éléments du tableau, mais ce n’est pas le cas; Bash utilise plutôt des espaces:

 # Array in Perl
 my @array = (1, 2, 3, 4);

 # Array in Bash
 array=(1 2 3 4)

Créez un tableau avec de nouveaux éléments:

array=('first element' 'second element' 'third element')

Affectation des indices

Créez un tableau avec des index d'éléments explicites:

array=([3]='fourth element' [4]='fifth element')

Affectation par index

array[0]='first element'
array[1]='second element'

Affectation par nom (tableau associatif)

declare -A array
array[first]='First element'
array[second]='Second element'

Affectation dynamique

Créez un tableau à partir de la sortie d'une autre commande, par exemple, utilisez seq pour obtenir une plage de 1 à 10:

array=(`seq 1 10`)

Affectation à partir des arguments d'entrée du script:

array=("$@")

Affectation dans les boucles:

while read -r; do
    #array+=("$REPLY")     # Array append
    array[$i]="$REPLY"     # Assignment by index
    let i++                # Increment index 
done < <(seq 1 10)  # command substitution
echo ${array[@]}    # output: 1 2 3 4 5 6 7 8 9 10

où $REPLY est toujours l'entrée courante

Accès aux éléments du tableau

Imprimer l'élément à l'index 0

echo "${array[0]}"

echo "${arr[@]: -1 }"

echo "${array[-1]}"

Imprimer tous les éléments, chacun cité séparément

echo "${array[@]}"

Imprimer tous les éléments en une seule chaîne entre guillemets

echo "${array[*]}"

Imprimer tous les éléments de l'index 1, chacun cité séparément

echo "${array[@]:1}"

Imprimer 3 éléments de l'index 1, chacun cité séparément

echo "${array[@]:1:3}"

Opérations sur les cordes

Si vous vous référez à un seul élément, les opérations sur les chaînes sont autorisées:

array=(zero one two)
echo "${array[0]:0:3}" # gives out zer (chars at position 0, 1 and 2 in the string zero)
echo "${array[0]:1:3}" # gives out ero (chars at position 1, 2 and 3 in the string zero)

si ${array[$i]:N:M} donne une chaîne de la N ième position ( à partir de 0) dans la chaîne ${array[$i]} avec M caractères suivants.

Longueur du tableau

${#array[@]} donne la longueur du tableau ${array[@]} :

array=('first element' 'second element' 'third element')
echo "${#array[@]}" # gives out a length of 3

Cela fonctionne également avec des chaînes dans des éléments simples:

echo "${#array[0]}"    # gives out the lenght of the string at element 0: 13

Modification de tableau

Changer d'index

Initialiser ou mettre à jour un élément particulier du tableau

array[10]="elevenths element"    # because it's starting with 0

array+=('fourth element' 'fifth element')

Remplacez le tableau entier par une nouvelle liste de paramètres.

array=("${array[@]}" "fourth element" "fifth element")

Ajouter un élément au début:

array=("new element" "${array[@]}")

Insérer

Insérer un élément à un index donné:

arr=(a b c d)
# insert an element at index 2
i=2
arr=("${arr[@]:0:$i}" 'new' "${arr[@]:$i}")
echo "${arr[2]}" #output: new

Effacer

Supprimer les index de tableau à l'aide de la commande unset intégrée:

arr=(a b c)
echo "${arr[@]}"   # outputs: a b c
echo "${!arr[@]}"  # outputs: 0 1 2
unset -v 'arr[1]'
echo "${arr[@]}"   # outputs: a c
echo "${!arr[@]}"  # outputs: 0 2

Fusionner

array3=("${array1[@]}" "${array2[@]}")

Cela fonctionne également pour les tableaux épars.

Réindexer un tableau

Cela peut être utile si des éléments ont été supprimés d'un tableau ou si vous n'êtes pas certain qu'il existe des lacunes dans le tableau. Pour recréer les index sans lacunes:

array=("${array[@]}")

Itération du tableau

L'itération Array se décline en deux versions: foreach et le classique for-loop:

a=(1 2 3 4)
# foreach loop
for y in "${a[@]}"; do
    # act on $y
    echo "$y"
done
# classic for-loop
for ((idx=0; idx < ${#a[@]}; ++idx)); do
    # act on ${a[$idx]}
    echo "${a[$idx]}"
done

Vous pouvez également parcourir la sortie d'une commande:

a=($(tr ',' ' ' <<<"a,b,c,d")) # tr can transform one character to another
for y in "${a[@]}"; do
    echo "$y"
done

Détruire, supprimer ou supprimer un tableau

Pour détruire, supprimer ou supprimer un tableau:

unset array

Pour détruire, supprimer ou supprimer un seul élément de tableau:

unset array[10]

Tableaux associatifs

declare -A aa 

aa[hello]=world
aa[ab]=cd
aa["key with space"]="hello world"

aa=([hello]=world [ab]=cd ["key with space"]="hello world")

echo ${aa[hello]}
# Out: world

echo "${!aa[@]}"
#Out: hello ab key with space

echo "${aa[@]}"
#Out: world cd hello world

for key in "${!aa[@]}"; do
    echo "Key:   ${key}"
    echo "Value: ${array[$key]}"
done

# Out:
# Key:   hello
# Value: world
# Key:   ab
# Value: cd
# Key:   key with space
# Value: hello world

echo "${#aa[@]}"
# Out: 3

Liste des index initialisés

Récupère la liste des index inialisés dans un tableau

$ arr[2]='second'
$ arr[10]='tenth'
$ arr[25]='twenty five'
$ echo ${!arr[@]}
2 10 25

En boucle à travers un tableau

Notre exemple de tableau:

arr=(a b c d e f)

Utiliser une boucle for..in :

for i in "${arr[@]}"; do
    echo "$i"
done

for ((i=0;i<${#arr[@]};i++)); do
    echo "${arr[$i]}" 
done

L' utilisation while boucle:

i=0
while [ $i -lt ${#arr[@]} ]; do
    echo "${arr[$i]}"
    i=$((i + 1))
done

i=0
while (( $i < ${#arr[@]} )); do
    echo "${arr[$i]}"
    ((i++))
done

Utiliser une boucle until :

i=0
until [ $i -ge ${#arr[@]} ]; do
    echo "${arr[$i]}"
    i=$((i + 1))
done

i=0
until (( $i >= ${#arr[@]} )); do
    echo "${arr[$i]}"
    ((i++))
done

Tableau de la chaîne

stringVar="Apple Orange Banana Mango"
arrayVar=(${stringVar// / })

Chaque espace dans la chaîne indique un nouvel élément dans le tableau résultant.

echo ${arrayVar[0]} # will print Apple
echo ${arrayVar[3]} # will print Mango

De même, d'autres caractères peuvent être utilisés pour le délimiteur.

stringVar="Apple+Orange+Banana+Mango"
arrayVar=(${stringVar//+/ })
echo ${arrayVar[0]} # will print Apple
echo ${arrayVar[2]} # will print Banana

Fonction d'insertion de tableau

Cette fonction va insérer un élément dans un tableau à un index donné:

insert(){
    h='
################## insert ########################
# Usage:
#   insert arr_name index element
#
#   Parameters:
#       arr_name    : Name of the array variable
#       index       : Index to insert at
#       element     : Element to insert
##################################################
    '
    [[ $1 = -h ]] && { echo "$h" >/dev/stderr; return 1; }
    declare -n __arr__=$1   # reference to the array variable
    i=$2                    # index to insert at
    el="$3"                 # element to insert
    # handle errors
    [[ ! "$i" =~ ^[0-9]+$ ]] && { echo "E: insert: index must be a valid integer" >/dev/stderr; return 1; }
    (( $1 < 0 )) && { echo "E: insert: index can not be negative" >/dev/stderr; return 1; }
    # Now insert $el at $i
    __arr__=("${__arr__[@]:0:$i}" "$el" "${__arr__[@]:$i}")
}

Usage:

insert array_variable_name index element

Exemple:

arr=(a b c d)
echo "${arr[2]}" # output: c
# Now call the insert function and pass the array variable name,
# index to insert at
# and the element to insert
insert arr 2 'New Element'
# 'New Element' was inserted at index 2 in arr, now print them
echo "${arr[2]}" # output: New Element
echo "${arr[3]}" # output: c

Lire un fichier entier dans un tableau

Lecture en une seule étape:

IFS=$'\n' read -r -a arr < file

Lecture en boucle:

arr=()
while IFS= read -r line; do
  arr+=("$line")
done

mapfile -t arr < file
readarray -t arr < file