FAQ LinuxConsultez toutes les FAQ

Par exemple, vous utilisez le Shell zsh, et vous voulez savoir à quel(s) PID (Processus IDentification) il(s) est(sont) lié(s).

La commande fuser retourne les différents PID de zsh :

1
2
$ fuser /bin/zsh 
/bin/zsh: 1942e 2860e 2996e 3469m 3487e 4527m 4607e

• c : répertoire courant ;
• e : programme en cours d'exécution ;
• f : fichier ouvert. f est omis par défaut ;
• r : répertoire racine ;
• m : fichier projeté en mémoire, ou bibliothèque partagée.

1
2
3
4
5
6
7
8
9
$ ps -aux | grep zsh 
francois 1942 0.0 0.0 3560 4 vc/1 S 10:24 0:00 -zsh 
francois 2860 0.0 0.9 3900 2484 pts/1 S 13:43 0:00 /bin/zsh 
francois 2996 0.0 0.8 3692 2212 pts/2 S 14:01 0:00 /bin/zsh 
root 3469 0.0 0.8 3612 2084 pts/1 S 15:25 0:00 zsh 
francois 3487 0.0 1.0 3976 2580 pts/1 S 15:25 0:00 zsh 
root 4527 0.0 0.9 3768 2308 pts/2 S 19:49 0:00 zsh 
francois 4607 0.2 0.8 3728 2268 pts/2 R 20:13 0:00 zsh 
francois 4632 0.0 0.2 1904 760 pts/2 R 20:14 0:00 grep zsh

$ ps -ef | grep zsh

Ce sont les opérateurs permettant de gérer les flux de données.

La redirection ">" permet de stocker la sortie d'un programme dans un fichier. Cela crée le fichier s'il n'existait pas, et efface son contenu s'il existe (il faut donc faire attention !) :

$ cat fichier1 > fichier_sauvegarde

$ cat ajout >> fichier_sauvegarde

1
2
$ cat < nom_du_fichier 
$ cat < fichier1 > fichier_sauvegarde

Le caractère "|" permet de lier des commandes entre elles. La sortie standard d'une commande devient l'entrée standard de la commande suivante :

$ cat fichier | grep YES

$ cat fichier | ls

$ cat fichier | grep YES | sed 's/YES/NO/'

Voici la signification du sticky bit :

• sur un fichier : un programme exécutable sera maintenu en zone de swap après la fin de son exécution, ce qui accélérera les chargements ultérieurs ;
• sur un répertoire : un fichier du répertoire ne peut être supprimé que par son propriétaire.

chmod a+t

chmod a-t

À l'aide des commandes grep et cut, on va extraire l'occurrence "/home/francois" du fichier /etc/passwd :

1
2
$ cat /etc/passwd | grep francois 
francois:x:502:502::/home/francois:/bin/zsh

$ grep "francois" /etc/passwd

1
2
$ grep "francois" /etc/passwd | cut -f6 -d: 
/home/francois

awk -F ":" '($0 ~ "francois"){print $6}' /etc/passwd

La commande find permet de faire le plus rapidement possible ce genre de traitement.

Pour afficher les fichiers vieux de plus de 24 heures :

$ find . -ctime +1

$ find . -ctime +1 -exec rm -f  \{\} \;

Ce caractère signifie que la commande sera exécutée en tâche de fond.
Ainsi vous aurez toujours accès au Shell pour exécuter d'autres commandes sur le terminal :

$ xmms &

Quand on lance une application depuis le terminal (xpdf, emacs...), on veut souvent reprendre la main sur ce même terminal, non ?

Mais on a oublié le "&" magique ! C'est terrible, il va falloir tout refermer pour tout réouvrir !

Eh bien non : imaginons le cas :

$ xpdf toto.pdf

$ bg

Il existe de nombreux programmes FTP en mode console.
Voici un exemple pour exécuter des commandes FTP automatiquement :

$ lftp -c "open nom_de_domaine ; user login password ; mput src destination ; ls"

1
2
3
4
$ ncftp -u login -p passwd host << EOF 
get fichier 
ls 
EOF

La commande screen permet de lancer des processus non graphiques, qui seront rattachés au processus init.

Ainsi, vous pourrez enlever votre programme de votre console et le rappelez quand vous le désirez. Pour cela, commençons par créer un screen :

screen -dmS nom_du_screen  'commande_a_lancer'

CTRL+A CTRL+D

screen -x nom_du_screen

1
2
3
4
5
$ toto="bonjour le monde"  
$ echo ${toto:$((${#toto}-10))}  
r le monde 
$ echo ${toto: -10} # version plus simple 
r le monde

• ${var:x} : extrait la sous chaîne de $var à partir caractère n° x jusqu'à la fin ;
• $((....)) : permet de faire des calculs.

1) Avec la commande seq :

1
2
3
for i in $(seq 1 10); do 
   # traitements itérés avec i allant de 1 à 10 
done

1
2
3
4
5
6
7
for i in (( i=1 ; i<=10 ; i++ )); do 
   # traitements itérés avec i allant de 1 à 10 
done 
  
for i in {1..10}; do 
    # traitements itérés avec i allant de 1 à 10 
done

Lorsqu'on lance une commande avec le caractère & à la fin, la commande est lancée en tâche de fond mais reste rattachée à votre terminal. Vous pouvez continuer à travailler sur le terminal, mais si vous le quittez, la tâche de fond est détruite (rapport père/fils).

Si vous lancez une commande avec nohup en préfixe (exemple : nohup ma_tache.sh), alors votre tâche est détachée de son père et rattachée à l'init si vous quittez votre terminal...

Pour lire la première ligne d'un fichier uniquement :

1
2
read -r premiere_ligne < fichier 
echo "$premiere_ligne"

1
2
3
while read -r ligne; do  
    echo "$ligne" 
done < fichier

1
2
3
4
while read -r colonne1 colonne2 toutLeResteDeLaLigne; do  
   ligneComplete="$colonne1 $colonne2 $toutLeResteDeLaLigne" 
   echo "$ligneComplete" 
done < fichier

1
2
3
4
while IFS=';' read -r colonne1 colonne2 toutLeResteDeLaLigne; do 
   ligneComplete="$colonne1;$colonne2;$toutLeResteDeLaLigne" 
   echo "$ligneComplete" 
done < fichier.csv

1
2
3
4
while IFS=';' read -ra tableau; do 
    ligneComplete="${tableau[@]}" 
    echo "$ligneComplete" 
done < fichier.csv

1
2
3
4
5
6
while read -r ligne; do  
   IFS=';' 
   set -- $ligne # éclatement de la ligne en paramètres positionnels 
   echo "première colonne : $1" 
   echo "ligne complète : $@" 
done < fichier.csv

Voici une liste non exhaustive de redirections possibles, avec :

• stdout: la sortie standard d'une commande ;
• stderr: la sortie d'erreur d'une commande.

commande 2>&1

1
2
3
$ commande >fichier 2>&1 
# ou 
$ commande 1>fichier 2>&1

$ commande 2>/dev/null

$ commande 2>&1 1>/dev/null

1
2
3
$ commande >/dev/null 2>&1 
# ou 
$ commande 1>/dev/null 2>&1

$ commande 3>&1 1>&2 2>&3 3>&-

$ commande [args] 1>commande.out 2>commande.err

$ commande 2> >(sed 's/^/Err : /' >&2)

commande 2>&1 | tee fichier

La boucle for s'effectue sur une liste de valeur :

1
2
3
for var in val1 val2 ...; do 
    # ... 
done

1
2
3
for var in $(commande); do 
    # ... 
done

1
2
3
commande|while read -r; do 
    # la variable $REPLY contient la ligne parcourue 
done

1
2
3
4
5
6
7
8
9
while read -r; do 
    # la variable $REPLY contient la ligne parcourue 
done < <(commande) 
  
# ou 
  
while read -r; do 
    # la variable $REPLY contient la ligne parcourue 
done <<< "$(commande)" # les doubles quotes sont importantes ici

La commande ls est généralement superflue dans les scripts voire potentiellement génératrice de bogues (dans le cas où on l'utilise avec une boucle for par exemple).

Pour parcourir les fichiers d'un répertoire, il suffit d'utiliser le métacaractère « * » (wildcard) :

1
2
3
for fichier in *; do 
    # ... 
done

1
2
3
4
5
6
7
8
9
10
11
12
# préciser une extension 
for fichier in *.log; do 
    # ... 
done 
  
# préciser un chemin de répertoire à parcourir 
dir="/home/votre_nom/rep" 
for fichier in "$rep"/*; do 
    # ... 
done 
  
# ...

1
2
3
stat -c "%A" fichier  
# au lieu de 
ls -l fichier|cut -d" " -f1

Vous souhaitez trouver dans quels fichiers se trouve la chaine "CHAINE", lister leur chemin (relatif à notre position), et afficher les lignes contenant cette chaine de caractères.

Pour cela, vous pouvez utiliser un grep récursif :

$ grep -Rn "CHAINE" repertoire/

$ grep --color -Rn "CHAINE" repertoire/

$ find repertoire/ -type f -user nom_user -perm /u+x -name "*.sh" -exec grep --color -Hn "CHAINE" {} 2>/dev/null \;

De manière générale, il faut encadrer les variables par des doubles quotes dans ses scripts, notamment lorsque l'on utilise la commande test ou son fork [ afin d'éviter ce genre d'erreurs.

Ceci ne s'applique pas lorsque l'on utilise la syntaxe Bash des doubles crochets [[ (commande test étendue).

La commande qui va suivre vous permettra de supprimer tous les fichiers dans le dossier courant prototypé de la sorte :

find . -name '*~' -print -delete -o -name '#*#' -print -delete

Pendant l'exécution d'un script, il peut arriver qu'on ait besoin de demander des informations à un utilisateur ; qu'il s'agisse d'une simple confirmation (continuer [Yn] :), ou d'une donnée plus large (quel est le chemin du fichier à traiter), il est question de lire des données depuis l'entrée standard avec la commande read.

read -p 'continuer [Yn] : '

1
2
3
4
5
6
7
  
$ read -a tableau 
'mlk mlk' poi 
$ printf '-> %s\n' "${tableau[@]}" 
-> 'mlk 
-> mlk' 
-> poi

1
2
3
4
5
$ read -a tableau 
mlk\ mlk poi 
$ printf '-> %s\n' "${tableau[@]}" 
-> mlk mlk 
-> poi

1
2
3
4
5
$ IFS=';' read -a tableau 
mlk mlk;poi 
$ printf '-> %s\n' "${tableau[@]}" 
-> mlk mlk 
-> poi

Par défaut, grep retourne uniquement les lignes correspondant à la recherche effectuée. Toutefois, il est aussi possible d'afficher un nombre de lignes avant et après les lignes concernées par la recherche grâce aux options :

• -B NUM : pour afficher NUM lignes avant la ligne concernée ;
• -A NUM : pour afficher NUM lignes après la ligne concernée ;
• -C NUM : pour afficher NUM lignes avant et après la ligne concernée.