26. Tableaux

#!/bin/bash


aire[11]=23
aire[13]=37
aire[51]=UFOs

# Les membres d'un tableau peuvent ne pas être consécutifs ou contigus.

# Certains membres peuvent rester non initialisés.
# Les trous dans le tableau sont OK.
# En fait, les tableaux avec des données "écartées" sont utiles dans les tableurs.


echo -n "aire[11] = "
echo ${aire[11]}    #  {accolades} nécessaires.

echo -n "aire[13] = "
echo ${aire[13]}

echo "Le contenu de aire[51] est ${aire[51]}."

# Le contenu d'une variable non initialisée d'un tableau n'affiche rien (variable nulle).
echo -n "aire[43] = "
echo ${aire[43]}
echo "(aire[43] non affecté)"

echo

# Somme de deux variables tableaux affectée à une troisième.
aire[5]=`expr ${aire[11]} + ${aire[13]}`
echo "aire[5] = aire[11] + aire[13]"
echo -n "aire[5] = "
echo ${aire[5]}

aire[6]=`expr ${aire[11]} + ${aire[51]}`
echo "aire[6] = aire[11] + aire[51]"
echo -n "aire[6] = "
echo ${aire[6]}
# Ceci échoue car ajouter un entier à une chaîne de caractères n'est pas permis.

echo; echo; echo

# -----------------------------------------------------------------
# Autre tableau, "aire2".
# Autre façon d'affecter les variables d'un tableau...
# nom_tableau=( XXX YYY ZZZ ... )

aire2=( zero un deux trois quatre )

echo -n "aire2[0] = "
echo ${aire2[0]}
# Aha, indexage commençant par 0 (le premier élément du tableau est [0], et non
# pas [1]).

echo -n "aire2[1] = "
echo ${aire2[1]}    # [1] est le deuxième élément du tableau.
# -----------------------------------------------------------------

echo; echo; echo

# -----------------------------------------------
# Encore un autre tableau, "aire3".
# Encore une autre façon d'affecter des variables de tableau...
# nom_tableau=([xx]=XXX [yy]=YYY ...)

aire3=([17]=dix-sept [24]=vingt-quatre)

echo -n "aire3[17] = "
echo ${aire3[17]}

echo -n "aire3[24] = "
echo ${aire3[24]}
# -----------------------------------------------

exit 0

#!/bin/bash
# poem.sh : affiche joliment un des poèmes préférés de l'auteur du document.

# Lignes d'un poème (simple stanza).
Ligne[1]="I do not know which to prefer,"
Ligne[2]="The beauty of inflections"
Ligne[3]="Or the beauty of innuendoes,"
Ligne[4]="The blackbird whistling"
Ligne[5]="Or just after."

# Attribution.
Attrib[1]=" Wallace Stevens"
Attrib[2]="\"Thirteen Ways of Looking at a Blackbird\""
# Ce poème est dans le domaine public (copyright expiré).

echo

for index in 1 2 3 4 5    # Cinq lignes.
do
  printf "     %s\n" "${Ligne[index]}"
done

for index in 1 2          # Deux lignes.
do
  printf "          %s\n" "${Attrib[index]}"
done

echo

exit 0

# Exercice :
# ---------
# Modifiez ce script pour afficher joliment un poème à partir d'un fichier de
# données au format texte.

#!/bin/bash
# array-strops.sh : Opérations sur des chaînes comprises dans des tableaux.
# Script de Michael Zick.
# Utilisé avec sa permission.

#  En général, toute opération sur des chaînes avec la notation ${nom ... }
#+ peut être appliquée aux éléments de type chaîne de caractères d'un tableau
#+ en utilisant la notation ${nom[@] ... } ou ${nom[*] ...}.


tableauZ=( un deux trois quatre cinq cinq )

echo

# Extraction de la dernière sous-chaîne
echo ${tableauZ[@]:0}   # un deux trois quatre cinq cinq
                        # Tous les éléments.

echo ${tableauZ[@]:1}   # deux trois quatre cinq cinq
                        # Tous les éléments après element[0].

echo ${tableauZ[@]:1:2} # deux trois
                        # Seulement les deux éléments après element[0].

echo "-----------------------"

#  Suppression d'une sous-chaîne
#  Supprime la plus petite correspondance au début de(s) chaîne(s),
#+ la sous-chaîne étant une expression rationnelle.

echo ${tableauZ[@]#q*e} # un deux trois cinq cinq
                        # Appliqué à tous les éléments du tableau.
                        # Correspond à "quatre" et le supprime.

# Correspondance la plus longue au début d'une chaîne
echo ${tableauZ[@]##t*s}  # un deux quatre cinq cinq
                        # Appliqué à tous les éléments du tableau.
                        # Correspond à "trois" et le supprime.

# Plus petite correspondance à partir de la fin de(s) chaîne(s)
echo ${tableauZ[@]%r*s} # un deux t quatre cinq cinq
                        # Appliqué à tous les éléments du tableau.
                        # Correspond à "rois" et le supprime.

# Plus longue correspondance à partir de la fin des chaînes.
echo ${tableauZ[@]%%t*s}  # un deux quatre cinq cinq
                        # Appliqué à tous les éléments du tableau.
                        # Correspond à "trois" et le supprime.

echo "-----------------------"

# Remplacement de sous-chaînes

# Remplace la première occurence d'une sous-chaîne
echo ${tableauZ[@]/cin/XYZ} # un deux trois quatre XYZq XYZq
                            # Appliqué à tous les éléments de la sous-chaîne.

# Remplace toutes les occurences de la sous-chaîne
echo ${tableauZ[@]//in/YY}  # un deux trois quatre cYYq cYYq
                            # Appliqué à tous les éléments de la sous-chaîne.

# Supprime toutes les occurences de la sous-chaîne
# Ne pas spécifier un remplacement suppose une 'suppression'.
echo ${tableauZ[@]//ci/}    # un deux trois quatre nq nq
                            # Appliqué à tous les éléments de la sous-chaîne.

# Remplace le début des occurences de la sous-chaîne
echo ${tableauZ[@]/#ci/XY}  # un deux trois quatre XYnq XYnq
                            # Appliqué à tous les éléments de la sous-chaîne.

# Remplace la fin des occurences de la sous-chaînes
echo ${tableauZ[@]/%nq/ZZ}  # un deux trois quatre ciZZ ciZZ
                            # Appliqué à tous les éléments de la sous-chaîne.

echo ${tableauZ[@]/%u/XX}   # XX deXX trois qXXXXX cinq cinq
                            # Pourquoi ?

echo "-----------------------"


# Avant de regarder awk (ou autre chose)
# Rappel :
#   $( ... ) est une substitution de commande.
#   Les fonctions sont lancées en tant que sous-processus.
#   Les fonctions écrivent leur propre sortie vers stdout.
#   Les affectations lisent le stdout de la fonction.
#   La notation nom[@] spécifie une opération "for-each".

nouvellechaine() {
    echo -n "!!!"
}

echo ${tableauZ[@]/%u/$(nouvellechaine)}
# !!!n de!!!x trois q!!!atre cinq cinq
# Q.E.D: L'action de remplacement est une 'affectation'.

#  Accéder au "For-Each"
echo ${tableauZ[@]//*/$(nouvellechaine arguments_optionnels)}
#  Maintenant, si Bash passait juste la chaîne correspondante comme $0 à la
#+ fonction appelée...

echo

exit 0

#!/bin/bash
# script-array.sh : Charge ce script dans un tableau.
# Inspiré d'un e-mail de Chris Martin (merci !).

contenu_script=( $(cat "$0") )   #  Enregistre le contenu de ce script ($0)
                                 #+ dans un tableau.

for element in $(seq 0 $((${#contenu_script[@]} - 1)))
  do                #  ${#contenu_script[@]}
                    #+ donne le nombre d'éléments dans le tableau.
                    #
                    #  Question:
                    #  Pourquoi seq 0  est-il nécessaire ?
                    #  Essayez de le changer en seq 1.
  echo -n "${contenu_script[$element]}"
                    # Affiche tous les champs de ce script sur une seule ligne.
  echo -n " -- "    # Utilise " -- " comme séparateur de champs.
done

echo

exit 0

# Exercice :
# ---------
#  Modifiez ce script de façon à ce qu'il s'affiche lui-même dans son format
#+ original, entier avec les espaces blancs, les retours ligne, etc.

#!/bin/bash

declare -a couleurs
#  Toutes les commandes suivantes dans ce script traiteront
#+ la variable "couleurs" comme un tableau.

echo "Entrez vos couleurs favorites (séparées par une espace)."

read -a couleurs  #  Entrez au moins trois couleurs pour démontrer les
                  #+ fonctionnalités ci-dessous.
#  Option spéciale pour la commande 'read'
#+ permettant d'affecter les éléments dans un tableau.

echo

nb_element=${#couleurs[@]}
# Syntaxe spéciale pour extraire le nombre d'éléments d'un tableau.
#     nb_element=${#couleurs[*]} fonctionne aussi.
#
#  La variable "@" permet de diviser les mots compris dans des guillemets
#+ (extrait les variables séparées par des espaces blancs).
#
#  Ceci correspond au comportement de "$@" et "$*"
#+ dans les paramètres de positionnement.

index=0

while [ "$index" -lt "$nb_element" ]
do    # Liste tous les éléments du tableau.
  echo ${couleurs[$index]}
  let "index = $index + 1"
  # ou index+=1 avec Bash 3.1 et suivants
done
# Chaque élément du tableau est listé sur une ligne séparée.
# Si ceci n'est pas souhaité, utilisez echo -n "${couleurs[$index]} "
#
# Pour le faire avec une boucle "for":
#   for i in "${couleurs[@]}"
#   do
#     echo "$i"
#   done
# (Thanks, S.C.)

echo

#  Encore une fois, liste tous les éléments d'un tableau, mais en utilisant une
#+ méthode plus élégante.
  echo ${couleurs[@]}        # echo ${couleurs[*]} fonctionne aussi.

echo

# La commande "unset" supprime les éléments d'un tableau ou un tableau entier.
unset couleurs[1]            # Supprime le deuxième élément d'un tableau.
                             # Même effet que   couleurs[1]=
echo  ${couleurs[@]}         # Encore un tableau liste, dont le deuxième
                             # élément est manquant.

unset couleurs               # Supprime le tableau entier.
                             #  unset couleurs[*] et
                             #+ unset couleurs[@] fonctionnent aussi.
echo; echo -n "couleurs parties."
echo ${couleurs[@]}          #  Affiche le tableau une nouvelle fois, maintenant
                             #+ vide.

exit 0

#!/bin/bash
# empty-array.sh

#  Merci à Stephane Chazelas pour l'exemple original
#+ et à Michael Zick et Omair Eshkenazi pour son extension.


#  Un tableau vide n'est pas la même chose qu'un tableau composé d'éléments
#+ vides.

tableau0=( premier deuxieme troisieme )
tableau1=( '' )   # "tableau1" consiste en un élément vide.
tableau2=( )      # Pas d'éléments . . . "tableau2" est vide.
tableau3=(   )    # Que peut-on dire de ce tableau ?

echo
AfficheTableau()
{
echo
echo "Éléments de tableau0 :  ${tableau0[@]}"
echo "Éléments de tableau1 :  ${tableau1[@]}"
echo "Éléments de tableau2 :  ${tableau2[@]}"
echo "Éléments de tableau3 :  ${tableau3[@]}"
echo
echo "Longueur du premier élément du tableau0 = ${#tableau0}"
echo "Longueur du premier élément du tableau1 = ${#tableau1}"
echo "Longueur du premier élément du tableau2 = ${#tableau2}"
echo "Longueur du premier élément du tableau3 = ${#tableau3}"
echo
echo "Nombre d'éléments du tableau0 = ${#tableau0[*]}"  # 3
echo "Nombre d'éléments du tableau1 = ${#tableau1[*]}"  # 1  (Surprise !)
echo "Nombre d'éléments du tableau2 = ${#tableau2[*]}"  # 0
echo "Nombre d'éléments du tableau3 = ${#tableau3[*]}"  # 0
}

# ===================================================================

AfficheTableau

# Essayons d'étendre ces tableaux.

# Ajouter un élément à un tableau.
tableau0=( "${tableau0[@]}" "nouveau1" )
tableau1=( "${tableau1[@]}" "nouveau1" )
tableau2=( "${tableau2[@]}" "nouveau1" )
tableau3=( "${tableau3[@]}" "nouveau1" )

AfficheTableau

# ou
tableau0[${#tableau0[*]}]="nouveau2"
tableau1[${#tableau1[*]}]="nouveau2"
tableau2[${#tableau2[*]}]="nouveau2"
tableau3[${#tableau3[*]}]="nouveau2"

AfficheTableau

# Lors d'un ajout comme ci-dessus ; les tableaux sont des piles ('stacks')
# La commande ci-dessus correspond à un 'push'
# La hauteur de la pile est :
hauteur=${#tableau2[@]}
echo
echo "Hauteur de pile pour tableau2 = $hauteur"

# L'opération 'pop' est :
unset tableau2[${#tableau2[@]}-1] #  L'index des tableaux commence à zéro,
hauteur=${#tableau2[@]}           #+ ce qui signifie que le premier élément se
                                  #+ trouve à l'index 0.
echo
echo "POP"
echo "Nouvelle hauteur de pile pour tableau2 = $hauteur"

AfficheTableau

# Affiche seulement les 2è et 3è éléments de tableau0.
de=1            # Numérotation débutant à zéro.
a=2             #
tableau3=( ${tableau0[@]:1:2} )
echo
echo "Éléments de tableau3 :  ${tableau3[@]}"

# Fonctionne comme une chaîne (tableau de caractères).
# Essayez les autres formes de "chaînes".

# Remplacement :
tableau4=( ${tableau0[@]/deuxieme/2è} )
echo
echo "Éléments de tableau4 :  ${tableau4[@]}"

# Remplacez toutes les chaînes correspondantes.
tableau5=( ${tableau0[@]//nouveau?/ancien} )
echo
echo "Éléments de tableau5 :  ${tableau5[@]}"

# Juste quand vous commencez à vous habituer...
tableau6=( ${tableau0[@]#*nouveau} )
echo # Ceci pourrait vous surprendre.
echo "Éléments du tableau6 :  ${tableau6[@]}"

tableau7=( ${tableau0[@]#nouveau1} )
echo # Après tableau6, ceci ne devrait plus être une surprise.
echo "Éléments du tableau7 :  ${tableau7[@]}"

# Qui ressemble beaucoup à...
tableau8=( ${tableau0[@]/nouveau1/} )
echo
echo "Éléments du tableau8 :  ${tableau8[@]}"

#  Donc, que pouvez-vous conclure de ceci ?

#  Les opérations sur des chaînes sont réalisées sur chaque éléments
#+ de var[@] à la suite.
#  Donc : Bash supporte les opérations vectorielles sur les chaînes.
#  Si le résultat est une chaîne de longueur vide,
#+ l'élément disparaît dans l'affectation résultante.

#  Question, ces chaînes sont-elles entre simples ou doubles guillemets ?

zap='nouveau*'
tableau9=( ${tableau0[@]/$zap/} )
echo
echo "Éléments du tableau9 :  ${tableau9[@]}"

# Juste au moment où vous pensiez être toujours en pays connu...
tableau10=( ${tableau0[@]#$zap} )
echo
echo "Éléments du tableau10 :  ${tableau10[@]}"

# Comparez le tableau7 avec le tableau10.
# Comparez le tableau8 avec le tableau9.

# Réponse : Cela doit être des simples guillemets.

exit 0

#! /bin/bash
# array-assign.bash

#  Les opérations sur les tableaux sont spécifiques à Bash,
#+ d'où le ".bash" dans le nom du script.

# Copyright (c) Michael S. Zick, 2003, All rights reserved.
# License: Unrestricted reuse in any form, for any purpose.
# Version: $ID$
#
# Clarification et commentaires supplémentaires par William Park.

#  Basé sur un exemple de Stephane Chazelas
#+ qui est apparu dans le livre : Advanced Bash Scripting Guide.

# Format en sortie de la commande 'times' :
# CPU Utilisateur <espace> CPU système
# CPU Utilisateur du fils mort <space> CPU système du fils mort

#  Bash a deux versions pour l'affectation de tous les éléments d'un tableau
#+ vers une nouvelle variable tableau.
#  Les deux jetent les éléments à référence nulle
#+ avec Bash version 2.04, 2.05a et 2.05b.
#  Une affectation de tableau supplémentaire qui maintient les relations de
#+ [sousscript]=valeur pour les tableaux pourrait être ajoutée aux nouvelles
#+ versions.

#  Construit un grand tableau en utilisant une commande interne,
#+ mais tout ce qui peut construire un tableau de quelques milliers d'éléments
#+ fera l'affaire.

declare -a grandElement=( /dev/* ) # Tous les fichiers de /dev...
echo
echo 'Conditions : Sans guillemets, IFS par défaut, Tout élément'
echo "Le nombre d'éléments dans le tableau est ${#grandElement[@]}"

# set -vx



echo
echo '- - test: =( ${array[@]} ) - -'
times
declare -a grandElement2=( ${grandElement[@]} )
# Notez les parenthèses  ^                    ^
times


echo
echo '- - test: =${array[@]} - -'
times
declare -a grandElement3=${grandElement[@]}
# Pas de parenthèses cette fois-ci.
times

#  Comparer les nombres montre que la deuxième forme, indiquée par
#+ Stephane Chazelas, est de trois à quatre fois plus rapide.
#
#  Comme William Park l'explique :
#+ Le tableau grandElement2 est affecté élément par élément à cause des parenthèses
#+ alors que grandElement3 est affecté en une seule chaîne.
#  Donc, en fait, vous avez :
#                   grandElement2=( [0]="..." [1]="..." [2]="..." ... )
#                   grandElement3=( [0]="... ... ..." )
#
#  Vérifiez ceci avec : echo ${grandElement2[0]}
#                       echo ${grandElement3[0]}

#  Je continuerais à utiliser la première forme dans mes descriptions d'exemple
#+ parce que je pense qu'il s'agit d'une meilleure illustration de ce qu'il se
#+ passe.

#  Les portions réutilisables de mes exemples contiendront réellement la
#+ deuxième forme quand elle est appropriée en ce qui concerne sa rapidité.

# MSZ : Désolé à propos de ce survol précédent.

#  Note :
#  -----
#  Les instructions "declare -a" des lignes 31 et 43 ne sont pas strictement
#  nécessaires car c'est implicite dans l'appel de Array=( ... )
#  Néanmoins, éliminer ces déclarations ralentit l'exécution des sections
#  suivantes du script.
#  Essayez et voyez ce qui se passe.

exit 0

#! /bin/bash
# CopieTableau.sh
#
# Ce script a été écrit par Michael Zick.
# Utilisé ici avec sa permission.

#  Guide pratique "Passage par nom & Retour par nom"
#+ ou "Construire votre propre instruction d'affectation".


CopieTableau_Mac() {

# Constructeur d'instruction d'affectation

    echo -n 'eval '
    echo -n "$2"                    # Nom de la destination
    echo -n '=( ${'
    echo -n "$1"                    # Nom de la source
    echo -n '[@]} )'

# Cela peut être une seule commande.
# Une simple question de style.
}

declare -f CopieTableau                     # Fonction "Pointeur".
CopieTableau=CopieTableau_Mac               # Constructeur d'instruction.

Hype()
{

# Hype le tableau nommé $1. 
# (L'ajoute au tableau contenant "Really Rocks".)
# Retour dans le tableau nommé $2.

    local -a TMP
    local -a hype=( Really Rocks )

    $($CopieTableau $1 TMP)
    TMP=( ${TMP[@]} ${hype[@]} )
    $($CopieTableau TMP $2)
}

declare -a avant=( Advanced Bash Scripting )
declare -a apres

echo "Tableau avant = ${avant[@]}"

Hype avant apres !!!!!!!!!!!!!!!!!!!!!!!!!

echo "Tableau après = ${apres[@]}"

# Trop de 'hype' ?

echo "Qu'est-ce que ${apres[@]:3:2}?"

declare -a modeste=( ${apres[@]:2:1} ${apres[@]:3:2} )
#                  -- extraction de la sous-chaine --

echo "Tableau modeste = ${modeste[@]}"

# Qu'arrive-t'il à 'avant' ?

echo "Tableau avant = ${avant[@]}"

exit 0

#! /bin/bash
# array-append.bash

# Copyright (c) Michael S. Zick, 2003, All rights reserved.
# License: Unrestricted reuse in any form, for any purpose.
# Version: $ID$
#
# Légèrement modifié au niveau formatage par M.C.


# Les opérations sur les tableaux sont spécifiques à Bash.
# Le /bin/sh de l'UNIX standard n'a pas d'équivalent.


#  Envoyer la sortie de ce script à 'more'
#+ de façon à ce que le terminal affiche page par page.


# Sous-script imbriqué.
declare -a tableau1=( zero1 un1 deux1 )
# Sous-script léger ([1] n'est pas défini).
declare -a tableau2=( [0]=zero2 [2]=deux2 [3]=trois3 )

echo
echo '- Confirmez que ce tableau est vraiment un sous-script. -'
echo "Nombre d'éléments : 4"        # Codé en dur pour illustration.
for (( i = 0 ; i < 4 ; i++ ))
do
    echo "Élément [$i] : ${tableau2[$i]}"
done
# Voir aussi l'exemple de code plus général dans basics-reviewed.bash.


declare -a dest

# Combinez (ajoutez) deux tableaux dans un troisième.
echo
echo 'Conditions : Sans guillemets, IFS par défaut, opérateur tous-éléments-de'
echo '- Éléments indéfinis non présents, sous-scripts non maintenus. -'
# # Les éléments indéfinis n'existent pas ; ils ne sont pas réellement supprimés.

dest=( ${tableau1[@]} ${tableau2[@]} )
# dest=${tableau1[@]}${tableau2[@]} # Résultats étranges, probablement un bogue.

# Maintenant, affiche le résultat.
echo
echo "- - Test de l'ajout du tableau - -"
cpt=${#dest[@]}

echo "Nombre d'éléments : $cpt"
for (( i = 0 ; i < cpt ; i++ ))
do
    echo "Élément [$i] : ${dest[$i]}"
done

# Affecte un tableau sur un élément d'un tableau simple (deux fois).
dest[0]=${tableau1[@]}
dest[1]=${tableau2[@]}

# Affiche le résultat.
echo
echo '- - Test du tableau modifié - -'
cpt=${#dest[@]}

echo "Nombre d'éléments : $cpt"
for (( i = 0 ; i < cpt ; i++ ))
do
    echo "Élément [$i] : ${dest[$i]}"
done

# Examine le deuxième élément modifié.
echo
echo '- - Réaffecte et affiche le deuxième élément - -'

declare -a sousTableau=${dest[1]}
cpt=${#sousTableau[@]}

echo "Nombre d'éléments: $cpt"
for (( i = 0 ; i < cpt ; i++ ))
do
    echo "Element [$i] : ${sousTableau[$i]}"
done

#  L'affectation d'un tableau entier sur un seul élément d'un autre tableau
#+ utilisant l'opérateur d'affectation de tableau '=${ ... }' a converti le
#+ tableau en cours d'affectation en une chaîne de caractères, les éléments
#+ étant séparés par une espace (le premier caractère de IFS).

# Si les éléments originaux ne contenaient pas d'espace blanc ...
# Si la tableau original n'est pas un sous-script ...
# Alors nous pouvons récupérer la structure du tableau original.

# Restaurer à partir du second élément modifié.
echo
echo "- - Affichage de l'élément restauré - -"

declare -a sousTableau=( ${dest[1]} )
cpt=${#sousTableau[@]}

echo "Nombre d'éléments : $cpt"
for (( i = 0 ; i < cpt ; i++ ))
do
    echo "Élément [$i] : ${sousTableau[$i]}"
done
echo '- - Ne dépends pas de ce comportement - -'
echo '- - Ce comportement est sujet à modification - -'
echo '- - dans les versions de Bash ultérieures à la version 2.05b - -'

# MSZ : Désolé pour la confusion précédente.

exit 0

#!/bin/bash
# bubble.sh : Tri bulle, en quelque sorte.

# Rappelle l'algorithme de tri bulle. Enfin, une version particulière...

#  À chaque itération successive à travers le tableau à trier, compare deux
#+ éléments adjacents et les échange s'ils ne sont pas ordonnés.
#  À la fin du premier tour, l'élémennt le "plus lourd" est arrivé tout en bas.
#  À la fin du deuxième tour, le "plus lourd" qui suit est lui-aussi à la fin
#+ mais avant le "plus lourd".
#  Et ainsi de suite.
#  Ceci signifie que chaque tour a besoin de se balader sur une partie de plus
#+ en plus petite du tableau.
#  Vous aurez donc noté une accélération à l'affichage lors des derniers tours.


echange()
{
  # Échange deux membres d'un tableau
  local temp=${Pays[$1]}      #  Stockage temporaire
                              #+ pour les éléments à échanger.
  Pays[$1]=${Pays[$2]}
  Pays[$2]=$temp
  
  return
}  

declare -a Pays  #  Déclaration d'un tableau,
                 #+ optionnel ici car il est initialisé tout de suite après.

#  Est-il permis de diviser une variable tableau sur plusieurs lignes en
#+ utilisant un caractère d'échappement ?
#  Oui.

Pays=(Hollande Ukraine Zaire Turquie Russie Yémen Syrie \
Brésil Argentine Nicaragua Japon Mexique Vénézuela Grèce Angleterre \
Israël Pérou Canada Oman Danemark France Kenya \
Xanadu Qatar Liechtenstein Hongrie)

# "Xanadu" est la place mythique où, selon Coleridge,
#+ Kubla Khan a décrété un summum de plaisir.


clear                 # Efface l'écran pour commencer.

echo "0: ${Pays[*]}"  # Liste le tableau entier lors du premier tour.

nombre_d_elements=${#Pays[@]}
let "comparaisons = $nombre_d_elements - 1"

index=1 # Nombre de tours.

while [ "$comparaisons" -gt 0 ]          # Début de la boucle externe.
do

  index=0  #  Réinitialise l'index pour commencer au début du tableau à chaque
           #+ tour.

  while [ "$index" -lt "$comparaisons" ] # Début de la boucle interne.
  do
    if [ ${Pays[$index]} \> ${Pays[`expr $index + 1`]} ]
    #  Si non ordonné...
    #  Rappelez-vous que \> est un opérateur de comparaison ASCII à l'intérieur
    #+ de simples crochets.

    #  if [[ ${Pays[$index]} > ${Pays[`expr $index + 1`]} ]]
    #+ fonctionne aussi.
    then
      echange $index `expr $index + 1`  # Échange.
    fi  
    let "index += 1" # Ou index+=1 sur Bash 3.1 et suivants
  done # Fin de la boucle interne.
  
# ----------------------------------------------------------------------
# Paulo Marcel Coelho Aragao suggère les boucles for comme alternative simple.
#
# for (( dernier = $nombre_d_elements - 1 ; dernier > 0 ; dernier-- ))
##                  Corrigé par C.Y. Hunt             ^  (Merci)
# do
#     for (( i = 0 ; i < dernier ; i++ ))
#     do
#         [[ "${Pays[$i]}" > "${Pays[$((i+1))]}" ]] \
#             && echange $i $((i+1))
#     done
# done
# ----------------------------------------------------------------------
 
let "comparaisons -= 1" #  Comme l'élément le "plus lourd" est tombé en bas,
                        #+ nous avons besoin de faire une comparaison de moins
                        #+ à chaque tour.

echo
echo "$index: ${Pays[@]}"  # Affiche le tableau résultat à la fin de chaque tour
echo
let "index += 1"                # Incrémente le compteur de tour.

done                            # Fin de la boucle externe.
                                # Fini.

exit 0

#!/bin/bash
# embedded-arrays.sh
# Tableaux intégrés et références indirectes.

# Script de Dennis Leeuw.
# Utilisé avec sa permission.
# Modifié par l'auteur du document.


TABLEAU1=(
        VAR1_1=valeur11
        VAR1_2=valeur12
        VAR1_3=valeur13
)

TABLEAU2=(
        VARIABLE="test"
        CHAINE="VAR1=valeur1 VAR2=valeur2 VAR3=valeur3"
        TABLEAU21=${TABLEAU1[*]}
)       # TABLEAU1 intégré dans ce deuxième tableau.

function affiche () {
        OLD_IFS="$IFS"
        IFS=$'\n'       #  Pour afficher chaque élément du tableau
                        #+ sur une ligne séparée.
        TEST1="TABLEAU2[*]"
        local ${!TEST1} # Voir ce que se passe si vous supprimez cette ligne.
        #  Référence indirecte.
        #  Ceci rend accessible les composants de $TEST1 à cette fonction.


        #  Voyons où nous en sommes arrivés.
        echo
        echo "\$TEST1 = $TEST1"       #  Simplement le nom de la variable.
        echo; echo
        echo "{\$TEST1} = ${!TEST1}"  #  Contenu de la variable.
                                      #  C'est ce que fait une référence
                                      #+ indirecte.
        echo
        echo "-------------------------------------------"; echo
        echo


        # Affiche la variable
        echo "Variable VARIABLE : $VARIABLE"
        
        # Affiche un élément de type chaîne
        IFS="$OLD_IFS"
        TEST2="CHAINE[*]"
        local ${!TEST2}      # Référence indirecte (comme ci-dessus).
        echo "Élément chaîne VAR2 : $VAR2 à partir de CHAINE"

        # Affiche un élément du tableau
        TEST2="TABLEAU21[*]"
        local ${!TEST2}      # Référence indirecte (comme ci-dessus).
        echo "Élément du tableau VAR1_1 : $VAR1_1 à partir de TABLEAU21"
}

affiche
echo

exit 0

#   Comme l'indique l'auteur du script,
#+ "vous pouvez facilement l'étendre pour créer des hashs nommés en bash."
#   Exercice (difficile) pour le lecteur : l'implémenter.

#!/bin/bash
# sieve.sh (ex68.sh)

# Crible d'Ératosthene
# Ancien algorithme pour trouver les nombres premiers.

# Ceci s'exécute bien moins rapidement que le programme équivalent écrit en C.

LIMITE_BASSE=1       # Commençant avec 1.
LIMITE_HAUTE=1000    # Jusqu'à 1000.
# (Vous pouvez augmenter cette valeur...  si vous avez du temps devant vous.)

PREMIER=1
NON_PREMIER=0

let DIVISE=LIMITE_HAUTE/2
# Optimisation :
# Nécessaire pour tester les nombres à mi-chemin de la limite supérieure (pourquoi ?).


declare -a Premiers
# Premiers[] est un tableau.


initialise ()
{
# Initialise le tableau.

i=$LIMITE_BASSE
until [ "$i" -gt "$LIMITE_HAUTE" ]
do
  Premiers[i]=$PREMIER
  let "i += 1"
done
# Assume que tous les membres du tableau sont coupables (premiers) avant d'être
# reconnus innocent.
}

affiche_premiers ()
{
# Affiche les membres du tableau Premiers[] indiqués comme premiers.

i=$LIMITE_BASSE

until [ "$i" -gt "$LIMITE_HAUTE" ]
do

  if [ "${Premiers[i]}" -eq "$PREMIER" ]
  then
    printf "%8d" $i
    # 8 espaces par nombre rend l'affichage joli, avec colonne.
  fi
  
  let "i += 1"
  
done

}

examine () # Examine minutieusement les non premiers.
{

let i=$LIMITE_BASSE+1
# Nous savons que 1 est premier, donc commençons avec 2.

until [ "$i" -gt "$LIMITE_HAUTE" ]
do

if [ "${Premiers[i]}" -eq "$PREMIER" ]
#  Ne nous embêtons pas à examiner les nombres déjà examinés (indiqués comme
#+ non premiers).
then

  t=$i

  while [ "$t" -le "$LIMITE_HAUTE" ]
  do
    let "t += $i "
    Premiers[t]=$NON_PREMIER
    # Indiqué comme non premier tous les multiples.
  done

fi  

  let "i += 1"
done  


}


# =========================================================
# main ()
# Appeler les fonctions séquentiellement.
initialise
examine
affiche_premiers
# C'est ce qu'ils appelent de la programmation structurée.
# =========================================================

echo

exit 0



# --------------------------------------------------------------------------- #
# Le code ci-dessous ne sera pas exécuté à cause du exit ci-dessus.

# Cette version améliorée de Sieve, par Stephane Chazelas,
# s'exécute un peu plus rapidement.

# Doit être appelé avec un argument en ligne de commande (limite des premiers).

LIMITE_HAUTE=$1                   # À partir de la ligne de commande.
let DIVISE=LIMITE_HAUTE/2         # Mi-chemin du nombre max.

Premiers=( '' $(seq $LIMITE_HAUTE) )

i=1
until (( ( i += 1 ) > DIVISE ))  # A besoin de vérifier à mi-chemin.
do
  if [[ -n $Premiers[i] ]]
  then
    t=$i
    until (( ( t += i ) > LIMITE_HAUTE ))
    do
      Premiers[t]=
    done
  fi  
done  
echo ${Premiers[*]}

exit 0

#!/bin/bash
# stack.sh : simulation d'une pile place-down

#  Similaire à la pile du CPU, une pile "place-down" enregistre les éléments
#+ séquentiellement mais les récupère en ordre inverse, le dernier entré étant
#+ le premier sorti.

BP=100            # Pointeur de base du tableau de la pile.
                  # Commence à l'élément 100.

SP=$BP            # Pointeur de la pile.
                  # Initialisé à la base (le bas) de la pile.

Donnees=          # Contenu de l'emplacement de la pile.
                  # Doit être une variable globale à cause de la limitation
                  #+ sur l'échelle de retour de la fonction.

declare -a pile


place()           # Place un élément dans la pile.
{
if [ -z "$1" ]    # Rien à y mettre ?
then
  return
fi

let "SP -= 1"     # Déplace le pointeur de pile.
pile[$SP]=$1

return
}

recupere()               # Récupère un élément de la pile.
{
Donnees=                 # Vide l'élément.

if [ "$SP" -eq "$BP" ]   # Pile vide ?
then
  return
fi                       #  Ceci empêche aussi SP de dépasser 100,
                         #+ donc de dépasser la capacité du tampon.

Donnees=${pile[$SP]}
let "SP += 1"            # Déplace le pointeur de pile.
return
}

rapport_d_etat()          # Recherche ce qui se passe
{
echo "-------------------------------------"
echo "RAPPORT"
echo "Pointeur de la pile = $SP"
echo "\""$Donnees"\" juste récupéré de la pile."
echo "-------------------------------------"
echo
}


# =======================================================
# Maintenant, amusons-nous...

echo

# Voyons si nous pouvons récupérer quelque chose d'une pile vide.
recupere
rapport_d_etat

echo

place garbage
recupere
rapport_d_etat     # Garbage in, garbage out.      

valeur1=23; place $valeur1
valeur2=skidoo; place $valeur2
valeur3=FINAL; place $valeur3

recupere              # FINAL
rapport_d_etat
recupere              # skidoo
rapport_d_etat
recupere              # 23
rapport_d_etat        # dernier entré, premier sorti !

#  Remarquez comment le pointeur de pile décrémente à chaque insertion et
#+ incrémente à chaque récupération.

echo

exit 0

# =======================================================


# Exercices :
# ----------

# 1)  Modifier la fonction "place()" pour permettre le placement de plusieurs
#   + éléments sur la pile en un seul appel.

# 2)  Modifier la fonction "recupere()" pour récupérer plusieurs éléments de la
#   + pile en un seul appel de la fonction.

# 3)  Ajouter une vérification des erreurs aux fonctions critiques.
#     C'est-à-dire, retournez un code d'erreur
#   + dépendant de la réussite ou de l'échec de l'opération,
#   + et réagissez en effectuant les actions appropriées.

# 4)  En utilisant ce script comme base, écrire une calculatrice 4 fonctions
#   + basée sur une pile.

#!/bin/bash

# Les célèbres "Q-series" de Douglas Hofstadter :

# Q(1) = Q(2) = 1
# Q(n) = Q(n - Q(n-1)) + Q(n - Q(n-2)), pour n>2

#  C'est une série chaotique d'entiers avec un comportement étrange et non
#+ prévisible.
# Les 20 premiers termes de la série étaient :
# 1 1 2 3 3 4 5 5 6 6 6 8 8 8 10 9 10 11 11 12 

#  Voir le livre d'Hofstadter, _Goedel, Escher, Bach: An Eternal Golden Braid_,
#+ p. 137, ff.


LIMITE=100        # Nombre de termes à calculer.
LONGUEURLIGNE=20  # Nombre de termes à afficher par ligne.

Q[1]=1            # Les deux premiers termes d'une série sont 1.
Q[2]=1

echo
echo "Q-series [$LIMITE termes] :"
echo -n "${Q[1]} "             # Affiche les deux premiers termes.
echo -n "${Q[2]} "

for ((n=3; n <= $LIMITE; n++))  # Conditions de boucle style C.
do   # Q[n] = Q[n - Q[n-1]] + Q[n - Q[n-2]]  for n&gt;2
#  Nécessaire de casser l'expression en des termes intermédiaires
#+ car Bash ne gère pas très bien l'arithmétique des tableaux complexes.

  let "n1 = $n - 1"        # n-1
  let "n2 = $n - 2"        # n-2
  
  t0=`expr $n - ${Q[n1]}`  # n - Q[n-1]
  t1=`expr $n - ${Q[n2]}`  # n - Q[n-2]
  
  T0=${Q[t0]}              # Q[n - Q[n-1]]
  T1=${Q[t1]}              # Q[n - Q[n-2]]

Q[n]=`expr $T0 + $T1`      # Q[n - Q[n-1]] + Q[n - Q[n-2]]
echo -n "${Q[n]} "

if [ `expr $n % $LONGUEURLIGNE` -eq 0 ]    # Formate la sortie.
then   #      ^ Opérateur modulo
  echo # Retour chariot pour des ensembles plus jolis.
fi

done

echo

exit 0

# C'est une implémentation itérative de la Q-series.
# L'implémentation récursive plus intuitive est laissée comme exercice.
# Attention : calculer cette série récursivement prend BEAUCOUP de temps.

#!/bin/bash
# twodim.sh : Simuler un tableau à deux dimensions.

# Un tableau à une dimension consiste en une seule ligne.
# Un tableau à deux dimensions stocke les lignes séquentiellement.

Lignes=5
Colonnes=5
# Tableau de 5 sur 5.

declare -a alpha     # char alpha [Lignes] [Colonnes];
                     # Déclaration inutile. Pourquoi ?

charge_alpha ()
{
local rc=0
local index


for i in A B C D E F G H I J K L M N O P Q R S T U V W X Y
do  # Utilisez des symbôles différents si vous le souhaitez.
  local ligne=`expr $rc / $Colonnes`
  local colonne=`expr $rc % $Lignes`
  let "index = $ligne * $Lignes + $colonne"
  alpha[$index]=$i
  # alpha[$ligne][$colonne]
  let "rc += 1"
done  

#  Un peu plus simple
#+   declare -a alpha=( A B C D E F G H I J K L M N O P Q R S T U V W X Y )
#+ mais il manque néanmoins le "bon goût" d'un tableau à deux dimensions.
}

affiche_alpha ()
{
local ligne=0
local index

echo

while [ "$ligne" -lt "$Lignes" ]  # Affiche dans l'ordre des lignes -
do                                # les colonnes varient
                                  # tant que ligne (la boucle externe) reste
                                  # identique
  local colonne=0
  
  echo -n "       "
  
  while [ "$colonne" -lt "$Colonnes" ]
  do
    let "index = $ligne * $Lignes + $colonne"
    echo -n "${alpha[index]} "  # alpha[$ligne][$colonne]
    let "colonne += 1"
  done

  let "ligne += 1"
  echo

done  

# Un équivalent plus simple serait
#   echo ${alpha[*]} | xargs -n $Colonnes

echo
}

filtrer ()     # Filtrer les index négatifs du tableau.
{

echo -n "  "  # Apporte le tilt.
              # Expliquez comment.

if [[ "$1" -ge 0 &&  "$1" -lt "$Lignes" && "$2" -ge 0 && "$2" -lt "$Colonnes" ]]
then
    let "index = $1 * $Lignes + $2"
    # Maintenant, l'affiche après rotation.
    echo -n " ${alpha[index]}"
    #           alpha[$ligne][$colonne]
fi    

}
  



rotate ()  #  Bascule le tableau de 45 degrés
{          #+ (le "balance" sur le côté gauche en bas).
local ligne
local colonne

for (( ligne = Lignes; ligne > -Lignes; ligne-- ))
do  # Traverse le tableau en sens inverse. Pourquoi ?

  for (( colonne = 0; colonne < Colonnes; colonne++ ))
  do

    if [ "$ligne" -ge 0 ]
    then
      let "t1 = $colonne - $ligne"
      let "t2 = $colonne"
    else
      let "t1 = $colonne"
      let "t2 = $colonne + $ligne"
    fi  

    filtrer $t1 $t2   # Filtre les index négatifs du tableau.
                      # Que se passe-t'il si vous ne le faites pas ?
  done

  echo; echo

done 

#  Rotation du tableau inspirée par les exemples (pp. 143-146) de
#+ "Advanced C Programming on the IBM PC", par Herbert Mayer
#+ (voir bibliographie).
#  Ceci ne fait que montrer que ce qui est fait en C peut aussi être fait avec
#+ des scripts shell.

}


#----- Maintenant, que le spectacle commence. --------#
charge_alpha     # Charge le tableau.
affiche_alpha    # L'affiche.
rotate           # Le fait basculer sur 45 degrés dans le sens contraire des
                 # aiguilles d'une montre.
#-----------------------------------------------------#

exit 0

# C'est une simulation assez peu satisfaisante.
#
# Exercices :
# ----------
# 1)  Réécrire le chargement du tableau et les fonctions d'affichage
#     d'une façon plus intuitive et élégante.
#
# 2)  Comprendre comment les fonctions de rotation fonctionnent.
#     Astuce : pensez aux implications de l'indexage arrière du tableau.
#
# 3)  Réécrire ce script pour gérer un tableau non carré, tel qu'un 6 sur 4.
#     Essayez de minimiser la distorsion lorsque le tableau subit une rotation.