Multi-dimensions des tableaux en Bash

Bash ne dispose pas d'un tableau multi-dimensionnel. Mais vous pouvez simuler un peu le même effet avec des tableaux associatifs. Voici un exemple de tableau associatif de faire semblant d'être utilisé comme un tableau multi-dimensionnel:

declare -A arr
arr[0,0]=0
arr[0,1]=1
arr[1,0]=2
arr[1,1]=3
echo "${arr[0,0]} ${arr[0,1]}" # will print 0 1

Si vous ne déclarez pas le tableau associatif (avec -A), le ci-dessus ne fonctionne pas. Par exemple, si vous omettez le declare -A arr ligne, le echo imprime 2 3 au lieu de 0 1, parce que 0,0, 1,0 et un tel sera pris comme une expression arithmétique et évalués à 0 (la valeur à droite de l'opérateur virgule).

Indépendant du shell utilisé (sh, ksh, bash, ...) ce qui suit est une approche qui fonctionne assez bien pour la n-dimensions des tableaux (l'échantillon couvre un tableau en 2 dimensions).

Dans l'exemple de la ligne de séparation (1ère dimension) est le caractère espace. Pour l'introduction d'un séparateur de champ (2ème dimension) le standard unix outil tr est utilisé. Supplémentaires séparateurs pour les dimensions supplémentaires peuvent être utilisés de la même manière.

Bien sûr, la performance de cette approche n'est pas très bien, mais si la performance n'est pas un des critères de cette approche est assez générique et peut résoudre de nombreux problèmes:

array2d="1.1:1.2:1.3 2.1:2.2 3.1:3.2:3.3:3.4"

function process2ndDimension {
    for dimension2 in $*
    do
        echo -n $dimension2 "   "
    done
    echo
}

function process1stDimension {
    for dimension1 in $array2d
    do
        process2ndDimension `echo $dimension1 | tr : " "`
    done
}

process1stDimension

La sortie de cet exemple ressemble à ceci:

1.1     1.2     1.3     
2.1     2.2     
3.1     3.2     3.3     3.4 

Expansion de Paul réponse - voici ma version de travail associatifs les sous-ensembles dans bash:

declare -A SUB_1=(["name1key"]="name1val" ["name2key"]="name2val")
declare -A SUB_2=(["name3key"]="name3val" ["name4key"]="name4val")
STRING_1="string1val"
STRING_2="string2val"
MAIN_ARRAY=(
  "${SUB_1[*]}"
  "${SUB_2[*]}"
  "${STRING_1}"
  "${STRING_2}"
)
echo "COUNT: " ${#MAIN_ARRAY[@]}
for key in ${!MAIN_ARRAY[@]}; do
    IFS=' ' read -a val <<< ${MAIN_ARRAY[$key]}
    echo "VALUE: " ${val[@]}
    if [[ ${#val[@]} -gt 1 ]]; then
        for subkey in ${!val[@]}; do
            subval=${val[$subkey]}
            echo "SUBVALUE: " ${subval}
        done
    fi
done

Il fonctionne avec un mélange de valeurs dans le tableau principal - chaînes/tableaux/assoc. les tableaux

La clé ici est d'envelopper le sous-tableaux simples citations et utilisation * au lieu de @ au moment d'enregistrer un subarray à l'intérieur du tableau principal et il serait donc stockés dans une seule et même chaîne séparée par des espaces: "${SUB_1[*]}"

Puis il le rend facile à analyser un tableau de que si la boucle à travers les valeurs avec IFS=' ' read -a val <<< ${MAIN_ARRAY[$key]}

Le code ci-dessus sorties:

COUNT:  4
VALUE:  name1val name2val
SUBVALUE:  name1val
SUBVALUE:  name2val
VALUE:  name4val name3val
SUBVALUE:  name4val
SUBVALUE:  name3val
VALUE:  string1val
VALUE:  string2val

Je vous poste la suite, car il est très simple et claire de la pour imiter (au moins dans une certaine mesure, le comportement d'un tableau à deux dimensions dans Bash. Il utilise un ici-fichier (voir le manuel de Bash) et read (un Bash builtin commande):

## Store the "two-dimensional data" in a file ($$ is just the process ID of the shell, to make sure the filename is unique)
cat > physicists.$$ <<EOF
Wolfgang Pauli 1900
Werner Heisenberg 1901
Albert Einstein 1879
Niels Bohr 1885
EOF
nbPhysicists=$(wc -l physicists.$$ | cut -sf 1 -d ' ')     # Number of lines of the here-file specifying the physicists.

## Extract the needed data
declare -a person     # Create an indexed array (necessary for the read command).                                                                                 
while read -ra person; do
    firstName=${person[0]}
    familyName=${person[1]}
    birthYear=${person[2]}
    echo "Physicist ${firstName} ${familyName} was born in ${birthYear}"
    # Do whatever you need with data
done < physicists.$$

## Remove the temporary file
rm physicists.$$

De sortie:

Physicist Wolfgang Pauli was born in 1900
Physicist Werner Heisenberg was born in 1901
Physicist Albert Einstein was born in 1879
Physicist Niels Bohr was born in 1885

La façon dont il fonctionne:

• Les lignes dans le fichier temporaire créé à jouer le rôle de celui-dimensions des vecteurs, où les espaces vides (ou autre caractère de séparation que vous choisissez; voir la description de la read commande dans le manuel de Bash) séparer les éléments de ces vecteurs.
• Puis, à l'aide de la read de commande avec ses -a option, on boucle sur chaque ligne du fichier (jusqu'à ce que nous atteignons la fin du fichier). Pour chaque ligne, nous pouvons attribuer les champs souhaités (= mots) à un tableau, qui nous a déclaré juste avant la boucle. Le -r option pour le read commande empêche les barres obliques inverses d'agir comme des caractères d'échappement, dans le cas où nous avons tapé des barres obliques inverses dans l'ici-document physicists.$$.

En conclusion, un fichier est créé comme un 2D-tableau, et ses éléments sont extraits à l'aide d'une boucle sur chaque ligne, et l'utilisation de la capacité de la read commande à assigner des mots pour les éléments d'un (indexée) tableau.

Légère amélioration:

Dans le code ci-dessus, le fichier physicists.$$ est donnée en entrée à la while boucle, de sorte qu'il est en fait passé à la read de commande. Toutefois, je trouve que cela pose des problèmes quand j'ai une autre commande de demander pour l'entrée à l'intérieur de la while boucle. Par exemple, le select commande attend à l'entrée standard, et si elle est placée à l'intérieur de la while de la boucle, il va prendre une entrée de physicists.$$, au lieu de les demander dans la ligne de commande pour la saisie de l'utilisateur.
Pour corriger cela, j'utilise le -u option de read, qui permet de lire à partir d'un descripteur de fichier. Nous n'avons qu'à créer un descripteur de fichier (avec le exec commande) correspondant à physicists.$$ et de le donner à la -u option de lire, comme dans le code suivant:

## Store the "two-dimensional data" in a file ($$ is just the process ID of the shell, to make sure the filename is unique)
cat > physicists.$$ <<EOF
Wolfgang Pauli 1900
Werner Heisenberg 1901
Albert Einstein 1879
Niels Bohr 1885
EOF
nbPhysicists=$(wc -l physicists.$$ | cut -sf 1 -d ' ')     # Number of lines of the here-file specifying the physicists.
exec {id_nuclei}<./physicists.$$     # Create a file descriptor stored in 'id_nuclei'.

## Extract the needed data
declare -a person     # Create an indexed array (necessary for the read command).                                                                                 
while read -ra person -u "${id_nuclei}"; do
    firstName=${person[0]}
    familyName=${person[1]}
    birthYear=${person[2]}
    echo "Physicist ${firstName} ${familyName} was born in ${birthYear}"
    # Do whatever you need with data
done

## Close the file descriptor
exec {id_nuclei}<&-
## Remove the temporary file
rm physicists.$$

Avis que le descripteur de fichier est fermé à la fin.

Bash ne supporte tableau multidimensionnel, mais nous pouvons mettre en œuvre à l'aide d'Associer tableau. Ici, les indices sont la clé pour récupérer la valeur. Associer tableau est disponible dans bash version 4.

#!/bin/bash

declare -A arr2d
rows=3
columns=2

for ((i=0;i<rows;i++)) do
    for ((j=0;j<columns;j++)) do
        arr2d[$i,$j]=$i
    done
done


for ((i=0;i<rows;i++)) do
    for ((j=0;j<columns;j++)) do
        echo ${arr2d[$i,$j]}
    done
done

echo "Enter no of terms"
read count
for i in $(seq 1 $count)
do
  t=` expr $i - 1 `
  for j in $(seq $t -1 0)
  do
    echo -n " "
  done
  j=` expr $count + 1 `
  x=` expr $j - $i `
  for k in $(seq 1 $x)
  do
    echo -n "* "
  done
  echo ""
done