====== Bash, Bashdb ======

===== Tutoriels =====

  * Guide avancé d'écriture des scripts Bash : http://abs.traduc.org/abs-3.1-fr/
  * Linux Script Programming
  * http://www.comptechdoc.org/os/linux/programming/script/linux_pgscript.html


===== Commandes internes =====

Aide
$ help commande
Ou sur page wab :
http://www.tldp.org/LDP/abs/html/internal.html

===== Bashdb =====

Bashdb = BASH with Debugger : à récupérer sur http://bashdb.sourceforge.net/
Bashdb nécessite bash version 3 : récupérer les sources de bash et la doc sur http://www.gnu.org/software/bash/

==== Scripts bash ====
Première ligne :
#! /bin/bash

Exécuter un script sans avoir mis le droit x (et sans le faire précéder de ./) :
$ source nom_du_script

Sinon, mettre le droit x :
$ chmod u+x nom_du_script
puis l'exécuter :
$ ./nom_du_script

===== Expressions régulières =====

http://www.funix.org/fr/unix/expr-sed.htm

===== Caractères spéciaux =====

cf. man echo :

\a	BEL
\\	\
\n	newline (saut ligne)
\b 	backspace (retour arrière)
\c	sans saut de ligne
\f	form feed
\r	CR
\t	tabulation
\v	tab vertical

Attention : dans la commande echo, -e est indispensable pour interpréter les caractères précédés de \ :
$ echo -e "abc\ndef"
abc
def
$ echo -e "abc\bdef"
abdef
$ echo -e "abc\tdef"
abc     def
$ echo -e "abc\fdef"
abc
   def
$ echo -e "abcde\rfg"
fgcde

Entrer un caractère spécial dans une commande immédiate
Par exemple pour initialiser la variable tab avec un caractère de tabulation, taper:
tab=" puis <ctrl><v> puis la touche tabulation.puis ".
Vérifier que la variable tab contient bien le caractère spécial :

echo "$tab" | od -a
0000000  ht  nl

echo "1${tab}2"
1       2

===== Déverminage, "Trace on/off" =====

# bash -vx ./monscript

dans le script :
set -vx				(active le débogage)
set +vx				(désactive le débogage)

Option de débogage :
Nom		Option		Description
No Exec		-n		Lit les commandes mais ne les exécute pas
Verbose		-v		Affiche toutes les lignes au moment où elles sont lues par le shell
Trace		-x		Affiche les commandes et leurs arguments lorsqu'elle sont exécutées

set -x envoie les messages vers stderr (fichier standard n° 2)
set +x les supprime
Pour récupérer les messages de stderr dans un fichier :
./monscript 2> /tmp/erreurs
ou bien
./monscript 2&1 > /tmp/erreurs

Le fichier est lu ligne à ligne.
Les lignes lues ne sont pas précédées du signe +, celles qui sont exécutées sont précédées de +

===== Utilisation des codes ascii =====

man ascii
Exemples :

En octal :
$ echo $'\125'
U

En décimal
$ echo $'\125'
U

en hexadécimal :
$ echo $'\x55'
U

==== Afficher le code ascii de chaîne, fichiers, etc. ====


hexdump
od

==== Afficher le code ascii d'un caractère ====

$ echo -n a |od -i
0000000     97
0000001

$ echo -n z |od -i
0000000    122
0000001

$ code=`echo -n a |od -i | awk ' {print $2} '`
$ echo $code
97

===== IFS =====

http://www.livefirelabs.com/unix_tip_trick_shell_script/oct_2003/10132003.htm

"Internal Field Separator", variable du shell.
Par défaut contient 3 caractères : space, tab, et newline
Utilisé pour délimiter les mots dans les commandes telles que read et set

$ echo "$IFS" | od -a
0000000  sp  ht  nl  nl
sp = space
ht = horizontal tab
nl = newline
le dernier nl est généré par la commande echo, en effet :
echo | od -a
0000000  nl

Pour que echo ne génère pas de "newline"
$ echo -n "$IFS" | od -a
0000000  sp  ht  nl

Idem en octal :
$ echo -n "$IFS" | od -b
0000000 040 011 012


==== Modifier IFS ====

OLDIFS=$IFS
IFS=$'\n'

Test du contenu :
echo "$IFS" | od -a
0000000  nl  nl

Puis aprés utilisation remettre IFS à sa valeur initiale :
IFS=$OLDIFS
unset OLDIFS

===== Décompte du temps, chronomètre =====

usleep n		ne fait rien pendant n microsecondes
usleep 10000000		"		"    10 secondes
echo $SECONDS		affiche le temps en secondes depuis le démarrage d'un shell, d'un script. Peut être remis à 0 : SECONDS=0

===== read =====
http://www.faqs.org/docs/bashman/bashref_55.html
http://linuxreviews.org/beginner/Bash-Beginners-Guide/en/x4195.html
et redirections :
http://www.tldp.org/LDP/abs/html/x12886.html

Attention !
read ne retourne pas les caractères IFS (sp tab et nl, cf. ci-dessus) :
car=" "
echo -n "$car" | od -a
=> 0000000  sp
mais :
read -n 1 car			# On tape sur la barre espace
echo -n "$car" | od -a
=> 0000000			# Comme si on n'avait rien tapé !

Pour que read n'interprète pas ces caractères, modifier IFS. 

==== Entrer au clavier un nom de fichier, avec autocomplétion du nom ====

echo "Entrez le nom du fichier :"
read  -e nom_fichier

==== Lire le contenu d'un fichier ligne à ligne ====

while read line
do
echo $line
done <fichier

Dans la boucle, stdin est redirigé vers le fichier, ce qui fait qu'une commande "read clavier" dans la boucle n'a aucun effet. Pour y remédier :
(cf. redirections http://www.tldp.org/LDP/abs/html/x12886.html)

# duplique stdin dans le "file descriptor" 6
exec 6<&0

while read line
do
echo -n "Taper sur une touche"
# lit sur le fd 6
read -s -n 1 touche <&6		# -s pas d'écho, -n 1 un seul caractère à taper
echo
echo
echo "Contenu de la ligne : " $line
echo "Touche : " $touche
echo
done <essai

# remet stdin comme avant la boucle et ferme le fd 6
exec 0<&6 6<&-

===== Boucles =====

Exemples

for I in 1 2 3 ; do echo $I; done
ou bien :
for ((I=1;I<=3;I++)); do echo $I; done
1
2
3

Avec un fichier "films" contenant par exemple :
Le train sifflera trois fois
Merlin l'Enchanteur

$ j=0 ; for i in `cat films` ; do echo $i ; ((j++)) ; done ; echo Il y a $j mots
Le
train
sifflera
trois
fois
Merlin
l'Enchanteur
Il y a 7 mots

Pour rompre le déroulement d'une boucle for, while ou until :
    * continue [n]
          revient au début de la boucle
          n = niveau de boucle
				n = 1 revient début de la boucle
				n = 2 revient au début de la boucle précédente
				etc.	
    * break [n]
          o sort d'une ou n boucles
          o n = niveau de boucle comme ci-dessus 
    * exit n
          o fin du script avec un code de sortie (n) 

===== ``, '' et "" =====

``	=> sortie de la commade incluse dans ``
Exemples : affectation de variable
TOTO=`ls *.txt`
echo $TOTO
0t.txt

''
	=> prend l'expression plus ou moins littéralement !?
TOTO='ls *.txt'
echo $TOTO
ls 0t.txt

===== history =====

Recherche rapide : <Ctrl><R> chaîne_à_chercher

history		affiche la liste des 500 dernières commandes
history | grep chaine_à chercher	affiche les commandes contenant "chaine_à_chercher"
!20		Pour rappeler la commande n° 20
!p		Pour rappeler la commande commençant par p (si plusieurs affiche toutes les commandes)
!tel		"					 tel
!-2		rappelle l'avant dernière commande

La liste des commandes semble être mémorisée dans le fichier .bash_history, mais les commandes
$ cat .bash_history
et
$ history
ne donnent pas le même résultat (sans doute une écriture différée des dernières commandes dans .bash_history) !

Pour effacer (par mesure de sécurité) l'historique :
$ history -c
et en plus supprimer le fichier .bash_history

==== Rappel de commandes ====

!$		dernière commande

==== pushd, popd ====

pour mémorise un chemin et y revenir.
Pour pushd, passer un répertoire en argument, sinon message d'erreur :
$ pushd
-bash: pushd: no other directory.
Pas d'argument pour popd.

Pour mémoriser l'emplacement actuel :
$ pushd ./ (ou pushd .)