Travailler avec les tableaux dans les scripts de shell Linux - Partie 8

Nous ne pouvons pas imaginer un langage de programmation sans le concept de tableaux. Peu importe comment ils sont mis en œuvre entre diverses langues. Au lieu de cela, les tableaux nous aident à consolider des données, similaires ou différentes, sous un seul nom symbolique.

Ici, comme nous sommes préoccupés par les scripts de coquille, cet article vous aidera à jouer avec des scripts de coquille qui utilisent ce concept de tableaux.

Initialisation et utilisation du tableau

Avec des versions plus récentes de Bash, il prend en charge les tableaux unidimensionnels. Un tableau peut être explicitement déclaré par le déclarer coquille.

Declare -a var 

Mais il n'est pas nécessaire de déclarer des variables de tableau comme ci-dessus. Nous pouvons insérer des éléments individuels pour tableau directement comme suit.

var [xx] = 

où 'xx' dénote l'index du tableau. Pour les éléments du tableau de déréférence, utilisez la syntaxe du support bouclé, i.e.

$ var [xx] 

Note: L'indexation du tableau commence toujours par 0.

Un autre moyen pratique d'initialiser un tableau entier consiste à utiliser la paire de parenthèses comme indiqué ci-dessous.

var = (element1 element2 element3… elementn) 

Il existe encore une autre façon d'attribuer des valeurs aux tableaux. Cette façon d'initialisation est une sous-catégorie de la méthode précédemment expliquée.

array = ([xx] = [xx] =…) 

Nous pouvons également lire / affecter des valeurs à la table pendant le temps d'exécution à l'aide du lire coquille.

Lire -Un tableau 

Maintenant, lors de l'exécution de l'instruction ci-dessus dans un script, il attend une entrée. Nous devons fournir les éléments de tableau séparés par l'espace (et non le retour du chariot). Après être entré dans les valeurs, appuyez sur Entrée pour terminer.

Pour traverser les éléments du tableau, nous pouvons également utiliser pour la boucle.

pour je dans "$ array [@]" faire #Access chaque élément comme $ je… fait 

Le script suivant résume le contenu de cette section particulière.

#!/ bin / bash array1 [0] = un array1 [1] = 1 echo $ array1 [0] echo $ array1 [1] array2 = (un deux trois) echo $ array2 [0] echo $  array2 [2] array3 = ([9] = nine [11] = 11) echo $ array3 [9] echo $ array3 [11] read -a array4 for i in "$ array4 [@] "Do Echo $ J'ai fait la sortie 0 

Diverses opérations sur les tableaux

Bon nombre des opérations de chaîne standard fonctionnent sur des tableaux . Regardez l'exemple de script suivant qui implémente certaines opérations sur les tableaux (y compris les opérations de chaîne).

#!/ bin / bash array = (pomme chauve chat chien elephant grenouille) #print premier élément echo $ array [0] echo $ array: 0 #display tous les éléments echo $ array [@] echo $ array [array [ @]: 0 #display tous les éléments sauf le premier echo $ array [@]: 1 #display elements dans une gamme echo $ array [@]: 1: 4 #Length of First Element echo $ # array [0] echo $ # array #number of elements echo $ # array [*] echo $ # array [@] #replacing substring echo $ array [@] // a / a exiit 0 

Voici la sortie produite lors de l'exécution du script ci-dessus.

Apple pomme pomme bat chat chien éléphant grenouille pomme chauve chat chien éléphant grenouille batte chat chien éléphant grenouille bat chat chien éléphant 5 5 6 6 pomme chauve chat chien éléphant grenouille 

Je pense qu'il n'y a aucune signification à expliquer le script ci-dessus en détail car il est explicite. Si nécessaire, je consacrerai une partie de cette série exclusivement sur les manipulations de cordes.

Substitution de commande par des tableaux

La substitution de commande attribue la sortie d'une commande ou de plusieurs commandes dans un autre contexte. Ici, dans ce contexte de tableaux, nous pouvons insérer la sortie des commandes en tant qu'éléments individuels des tableaux. La syntaxe est la suivante.

array = ($ (commande)) 

Par défaut, le contenu dans la sortie de la commande séparée par des espaces blancs est branché sur le tableau sous forme d'éléments individuels. Le script suivant répertorie le contenu d'un répertoire, qui sont des fichiers avec 755 autorisations.

#!/ bin / bash err = 27 ext = 0 si [$ # -ne 1]; puis écho "Utilisation: 0 $" exit $ err fi if [ ! -D 1 $]; ECHO ECHO "Le répertoire 1 $ n'existe pas" Exit $ err fi temp = ($ (Find 1 $ -maxdepth 1 -Type f)) pour i dans "$ temp [@]" do perm = $ (ls -l $ i) si ['expr $ perm: 0: 10: "-rwxr-xr-x"' -eq 10]; puis echo $ i ## * / fi fait exit $ ext 

Simulation des tableaux bidimensionnels

Nous pouvons facilement représenter une matrice bidimensionnelle en utilisant un tableau à 1 dimension. Dans Ordre majeur en rangée Les éléments de représentation dans chaque rangée d'une matrice sont progressivement stockés dans les index de tableau de manière séquentielle. Pour une matrice MXN, la formule pour la même.

matrice [i] [j] = array [n * i + j] 

Regardez un autre exemple de script pour ajouter 2 matrices et imprimer la matrice résultante.

#!/ bin / bash read -p "Entrez l'ordre de matrice [mxn]:" t m = $ t: 0: 1 n = $ t: 2: 1 echo "Entrez les éléments de la première matrice" pour i in ' SEQ 0 $ (($ m-1)) 'Do pour j dans' seq 0 $ (($ n-1)) 'lisez x [$ (($ n * $ i + $ j))] fait écho " Entrez les éléments de la deuxième matrice "pour i dans 'seq 0 $ (($ m-1))' faites pour j dans 'seq 0 $ (($ n-1))' lisez y [$ (($ n * $ i + $ j))] z [$ (($ n * $ i + $ j))] = $ (($ x [$ (($ n * $ i + $ j))] + $ y [$ (($ n * $ i + $ j))])) fait fait écho "matrice après l'ajout est" pour i dans 'seq 0 $ (($ m-1))' faire pour j dans 'seq 0 $ (((( $ n-1)) 'do echo -ne "$ z [$ (($ n * $ i + $ j))] \ t" fait echo -e "\ n" 

Même s'il existe des limites pour la mise en œuvre des tableaux à l'intérieur des scripts de coquille, il devient utile dans une poignée de situations, surtout lorsque nous gérons avec la substitution de commandement. En regardant d'un point de vue administratif, le concept de tableaux a ouvert la voie au développement de nombreux scripts de fond dans les systèmes GNU / Linux.