@fox Delta :

Merci pour la page d'arithmetiques, tres instructives d'ailleurs, mais après lecture attentive je n'ai pas trouvé comment ou compris comment créer de manière incrémentée une variable et enregister dans celle-ci.

Je continu a chercher, merci aussi pour le lien awk, faut que je prenne plus de temps pour le ire et non survoler, mais merci.....................
As-tu essaye les boucles for ? Elles sont faites pour ca. En voici l'algorithme: 
Pour i de 1 a limite
    afficher tab(i)
Fin Pour
L'incrementation se fait toute seule, et tu peux utiliser le contenu de ta variable incrementee. Par contre, je ne connais pas la syntaxe en bash, donc je te laisse chercher :-D
Mais nul doute qu'en tapant quelque chose comme "bash boucle for", ou alors "bash for loop" dans google, tu devrais trouver ton bonheur.
@fox Delta :

ok, j'ai bien compris pour les boucles ou loop, mais en fait je ne veux faire une boucle pour afficher, mais enregistrer dans une variable qui sera incrémentée,
du style :
tab(1) vers memo(1)
tab(2) vers memo(2)
tab(3) vers memo(3)
etc, etc....................

et en fait j'ai essayé pleins d'écriture différentes, avec des $, des {, des [, des (, etc.............. mais rien n'y fait je n'arrive pas a memoriser autre chose que la valeur (1)....
je sais que je deconnes a un endroit mais, la, je vois pas ou, je j'arretes pas de me taper les guides, ou on parle des loop, des while, des for, mais jamais un exemple ou c'est la variable qui mémorise qui est incrementée.

Merci quand meme
while [ $i -lt $limite ]
do
memo[$i]=$[${TABLEAU[$i]}]     (*)
i=$[$i+1]
done
Tu recopies le tableau TABLEAU dans memo.
La ligne (*) devrait être 
memo[$i]=${TABLEAU[$i]}
Ou pour faire une copie plus simplement, à la place de la boucle précédente : 
memo=${TABLEAU[@]}
Pour une boucle for (j'aime cette solution-là, même s'il y a l'autre avec seq) : 
for ((i=1;$i<=14;i++)); do
    echo $i
done
Voila pourquoi je n'aime pas vraiment la bash... 
memo[$i]=$[${TABLEAU[$i]}]
Trop de crochets a memoriser... Etant donne que j'ai commence a programmer en Fortran, qui est un langage tres clair, les instructions du bash me paraissent vraiment confuses.
Il est vrai que le perl n'est pas toujours tres clair, mais au moins, il a ete pense comme un langage a part entiere, avec des regles et tout et tout ! Bon, ce que je lui reproche, c'est son cote trop simpliste pour la declaration des variables, il y a trop de confusions possibles... Mais c'est mieux que rien du tout.

Pikachu, tu sais si des reformes du bash sont prevues pour nettoyer tout ca ?
@Pikachu_2014 et Fox Delta :
Merci pour vos propositions, mais déjà essayé et ca marche pas.........................

@Pikachu_2014 :
je ne veux pas afficher mais mémoriser pour m'en servir ailleurs dans le script............

Merci quand meme, c'est sympa de m'avoir proposer qqch
Je ne comprend pas tout... Tu veux stocker la valeur de la variable d'incrementation ? Ou alors stocker une valeur d'un tableau dans un autre tableau ?
Si la deuxieme proposition correspond a ton cas, je suppose que un simple tab1 = tab2 ferait l'affaire...
Mais je dois dire que je suis un peu perdu.

Est-il possible que tu nous ecrive un algorithme de ce que tu veux faire, comme j'ai fait avec la boucle for ?
@ Fox Delta :
OK, voici mon cas :
dans mon repertoire j'ai blabla blibli bloblo titi tata et toutou, savoir que ce sont des repertoires eux aussi (logique identique si c'estait des fichiers)
je fais un tableau de tout ca avec ::TABLEAU=( $(dir repertoire) )
on sait que ${TABLEAU[$i]} placé dans une boucle ou un while va lire la valeur $i
et ce que je voudrais c'est : mémoriser dans memo$i la valeur de ${TABLEAU[$i]} (ou $i=1, puis 2, puis 3,etc)
donc faire une boucle de memorisation incrémentée par $i en meme temps que je lis la valeur du tableau (lecture incrémentée elle aussi par $i)

ou autrement dit, a chaque boucle de lecture, je memorise dans une variable incrémentée à l'identique que la boucle de lecture.
Je crois que je saisis ton probleme. Ce que tu veux, c'est pour chaque valeur de ton tableau, lui associer une variable dont le nom comporte le numero... En gros faire
memo1 = tableau(1)
memo2 = tableau(2)
...
memon = tableau(n)

L'ennui, c'est que je ne pense pas qu'il soit possible de creer des variables comme ca. Il faut lui donner explicitement un nom, ecrire clairement memo1, memo2, etc...

Alors la question qui se pose est: peux-tu effectuer toutes les operations que tu projettais de faire sur ta nouvelle variable au sein meme de ta boucle ? 
Pour i de 1 a limite
   memo = tableau(i)
   operation1 sur memo
   operation2 sur memo
   etc...
fin pour
Ou alors, peux tu travailler directement sur la valeur contenue dans ton tableau ? Je dirais oui a priori, mais je ne connais pas ton cas dans tous ses details.
@ Fox Delta :

C'est exactement ce que je veux faire, et je vois que tu arrives à la même conclusion que moi, mais c'est pas kool, ni tres autonome comme principe,

Merci quand meme pour ton aide, je vais voir pour trouver une autre logique a ce que je veux faire................

Merci encore........................
Dans l'esprit de ce que je t'ai ecrit, tu pourrais utiliser un module dans ta boucle. Un truc du genre 
Pour i de 1 a limite
    appeler module(tableau(i))
fin de pour
L'idee est de mettre dans le module toutes les operations que tu souhaites effectuer sur la valeur de ton tableau, et de passer en argument de ce module le contenu de ton tableau. Ce qui est beaucoup plus puissant que ce que tu projettais de faire, car tu peux utiliser ton module n'importe ou dans ton script. Mais la, on commence a atteindre des notions de programmation avancee, on en arrive a un debut de concept de programmation orientee objet... Tu vas devenir super bon 8-)

Pour ce qui est du module en lui-meme, il me faudrait l'avis de Pikachu, mais je pense qu'il pourrait tout simplement s'agir d'un nouveau script que tu appelles en lui passant des arguments. Encore une fois, je n'ai pas de pobleme a te montrer comment ca marcher en perl, mais en bash... En tout cas, ca te fait une nouvelle piste a explorer.
Du coup, moi aussi j'ai compris... La commande eval devrait arranger ça. Un exemple : 
$ i=3
$ eval memo$i=14
$ echo $memo3
14

$ j=17
$ eval memo$j=\"Ça marche\"
$ echo $memo17
Ça marche
eval permet d'interpréter la chaîne qui lui est passée en paramètre.

Ceci dit, ça m'a l'air un tantinet compliqué, ton histoire... Pourquoi as-tu besoin de copier les éléments de ton tableau dans de simples variables ?
C'est quand meme particulier comme utilisation de la commande eval...
Mais ca ne sert a priori pas a grand chose de recopier le contenu d'un tableau dans des variables, etant donne que tu possedes deja ton information dans ton tableau. Ce que je veux dire, c'est que tu peux directement effectuer tes operations sur le contenu de ton tableau. Mais bon, je l'ai deja dit ca je crois.
La seule utilisation que je vois pourrait etre de tenter de saturer ta RAM... Tu n'aime tellement pas ton PC que tu veux le martyriser ? :-D:hammer:
@fox Delta :
Décidément tu trouves les solutions auxquelles je commence a peine a reflechir, je disais re-penser ma logique, et en meme temps que je remaniais mon script en pensant a d'eventels modules disponibles et utilisables a tout moment, voila que tu me proposes la meme chose, par contre, pour la programmation objet, ok peut-ere, mais vu que je sais meme pas de quoi tu parles (objet ??????????????), la je te reponds oui t'as surement raison vu que je sait pas.

D'ailleurs a ce propos, pendant que tu me parlais de module, je cherchais dans mon coin pour voir comment ca fonctionnait.
D'ailleurs, 2questions sans réelles importance mais juste par curiosité, pourquoi le module doit-il etre ecrit avant de pouvoir etre appelé par le script ou est le module, et meme si ca change rien dans l'exemple on disait d'appeler un module par : module $* alors que juste module sans rien derriere fonctionne pareil ???????????

@Pikachu_2014 :
merci pour eval, je n'ai pas testé encore, car parti sur le remaniement de mon script et de sa logique, mais effectivement je vois pas pourquoi j'ai voulu me compliqué la vie en stockant le retour d'un tableau dans des variables, donc on est d'accord, mais je voulais trouver une solution quant au fait de pouvoir incrementer une variable en meme temps que je memorisait quelque chose dedans..

Merci en tout cas pour vos aides respectives ainsi que pour la patience et le temps pris a m'aider.....

D'ailleurs, un collegue me disait cet apres-midi, ok kool ton script, mais si tu veux t'en servir sur un autre OS linux, genre debian ou suse, ca fonctionnera pareil ?????

Je lui ai répondu oui, pas trop convaincu, mais pour moi, ormis les rpms qui sont des deb sous debian, y aurait-il pour vous des differences dont je devrais tenir compte, au cas ou, et vous auriez une commande qui me dirait sur quel OS precisement je tourne (pour moi c'est FC6 i686 avec un kernel 2948) ???????????
Hello Berok37 !

Je peux repondre a la moitie de tes questions sur les modules... C'est a dire une !
Le module de doit pas etre reellement ecrit avant ton programme principal, mais il doit etre evidemment present quelque part lorsque tu lances ton script...
Apres, concretement, tu peux ecrire ton module dans un fichier separe de ton programme principal. Ou alors si tu mets tout dans un seul fichier, effectivement, il vaut mieux que ce soit place avant. Le probleme est simple: le bash est un langage interprete, ton fichier script est donc lu depuis le debut, et les instructions sont executees au fur et a mesure. Donc si ton module n'est pas place avant les instructions qui l'utilisent, bash ne saura pas ou le trouver... C'est sans doute la raison pour laquelle ton module doit etre place avant.

Pour les langages compiles, le probleme est different. Car a la compilation, le programme va chercher tout ce dont il a besoin pour creer le programme. Il suffit juste de specifier ou chercher. Et donc les modules peuvent etre avant, ou apres le programme principal, ou meme dans un fichier separe. Et a ce moment la, mettre les modules avant le programme principal tient d'avantage de la convention, pour avoir des programmes plus clairs.

Pour la portabilite de ton script, je pense que la reponse est oui. Le bash est un langage commun a la plupart des distributions linux. Sauf evidemment particularites des OS, comme les rpm et les deb que tu as si bien souligne. En revanche, son interprestation peut-etre differente... Est-ce qu'une Suse ou Debian utilise un fichier fstab ??? Ca tient de la cuisine interne a l'OS, donc meme si ton script est execute, et bien execute, il est possible que rien ne se passe, car les fichiers ont des noms differents...
bon sa fait quelque temps que je t'ai pas revenu 😉.
Je vais être chiant mais bon en perl je treouvais sa mieux car au moin c'était du multiplateforme. Sinon tu as aussi la TCL qui ressemble au perl. Peut être Fox Delta devrait regardé le TCL pour la déclaration de variables si c'est ce qui l'embete un peu en perl.
Sinon pour faire quelquechose de portable 
 uname -a
et d'après les information de la commande tu excute la partie du script correspondant à l'OS