Suite du cours //LINUX// le cours est tres long c'est pour ca je l partager en 4partie

Chapitre 7 : Les redirections.


Principe de base.


Normalement, les commandes reçoivent leurs paramètres sur le flux standard d'entrée (stdin), qui correspond généralement au clavier, et affichent le résultat sur le flux standard de sortie (stdout), qui correspond généralement à l'écran. Les messages d'erreur quant à eux sont renvoyés sur le flux standard d'erreur (stderr), qui correspond généralement à l'écran.
Les flux standard possèdent des descripteurs de fichier normalisés. Nous aurons ainsi 0 pour le stdin, 1 pour le stdout et 2 pour le stderr. Un programme peut utiliser d'autres descripteurs de fichier non standards comme par exemple ceux de fichiers qu'il a lui-même ouverts.
Les redirections permettent substituer d'autres flux de données aux flux standard. Ces nouveaux flux seront généralement des fichiers.
Les redirections de données en entrée.


Redirection d'entrée à partir d'un fichier.


La syntaxe pour effectuer une redirection d'entrée à partir d'un fichier est :

$ commande [n]< fichier
"n" représente le descripteur de fichier qui sera redirigé. S'il n'est pas mentionné, la redirection portera sur le flux d'entrée standard.
Redirection d'entrée à partir d'un descripteur de fichier.


La syntaxe pour effectuer une redirection d'entrée à partir d'un descripteur de fichier est :

$ commande [n]<&s
"n" représente le descripteur de fichier qui sera redirigé et "s" celui qui sera utilisé. Si "n" n'est pas mentionné, la redirection portera sur le flux d'entrée standard.
Les redirections de données en sorties.


Redirection de sortie vers un fichier.


La syntaxe pour effectuer une redirection de sortie vers un fichier est :

$ commande [n]> fichier
"n" représente le descripteur de fichier qui sera redirigé. S'il n'est pas mentionné, la redirection portera sur le flux de sortie standard.
Notez que ce type de redirection va détruire toutes les données contenues dans le fichier et les remplacer par les données provenant du flux de données. Il est possible d'ajouter les nouvelles données à la fin du fichier en utilisant la syntaxe suivante :

$ commande [n]>> fichier
Redirection de sortie vers un descripteur de fichiers.


La syntaxe pour effectuer une redirection de sortie vers un descripteur de fichier est :

$ commande [n]>&s
"n" représente le descripteur de fichier qui sera redirigé et "s" celui qui sera utilisé. Si "n" n'est pas mentionné, la redirection portera sur le flux de sortie standard. Ce type de redirection est très utilisé pour rediriger le flux d'erreur standard vers le flux de sortie standard qui sera lui-même redirigé vers un fichier. Nous aurons alors :

$ commande >fichier 2>&1
Les redirections multiples.


Il est possible d'effectuer des redirections multiples. Nous pouvons ainsi avoir simultanément une redirection de l'entrée standard depuis un fichier, de la sortie standard ver un fichier et la sortie d'erreur standard vers la sortie standard. Nous aurons alors :

$ commande <fichierin >fichierout 2>&1
Les "pipes".


Un "pipe", ou "tuyau" en français, consiste à envoyer le résultat d'une commande vers une deuxième. La syntaxe pour effectuer un "pipe" est :

$ commande1 | commande2


Chapitre 8 : Les scripts.


Introduction.


Comme nous l'avons vu, il existe énormément de commandes disponibles en Linux et chacune d'entre elles peut posséder un nombre impressionnant d'options. Cela permet certes d'obtenir des informations très précises, mais au prix d'un travail laborieux en introduction de commandes.
Linux, comme tous les systèmes UNIX, permet de créer facilement des scripts. Vous mettez toutes vos commandes dans un script que vous pourrez exécuter de manière aisée autant de fois que vous le désirez.
Ces scripts peuvent être en commandes systèmes ou en tout autre langage interprété comme perl, awk, etc. Pour être exécutables, vous devez avoir sur eux le droit d'exécution. La première ligne du script doit également indiquer quel programme va servir à interpréter le script. Cette ligne aura la syntaxe suivante :

#! /path/interpréteur
Comme exemple, nous pouvons avoir

#! /bin/sh # script Bourn shell

#! /bin/bash # script Bourn-again shell

#! /bin/csh # script C-shell

#! /usr/bin/perl # script perl
Les variables de passage des paramètres des scripts C-shell :


Il existe un tableau argv qui contient les paramètres passés au programme. Le premier élément du tableau porte l'indice 1 et contient le premier paramètre passé au programme. Il n'existe pas d'élément 0 à ce tableau et le nom du programme n'est pas non plus passé dans ce tableau.
Il existe des raccourcis au tableau argv : les varaibles $0 à $9. $0 contient le nom du programme et $1 à $9 les neufs premiers arguments. Pour accéder aux arguments suivants, il faut utiliser la commande "shift".


td>le nom du programme.</TD>

	argument d'indice n passé au programme.
$0
$1..$9	les 9 premiers arguments passés au programme.
$#	le nombre de paramètres.
$*	liste des paramètres.
$@	liste des paramètres, chaque élément est entre guillemets.

Les instructions utilisables dans les scripts C-shell :


Structure "if" :


Syntaxe :

if(<expression>)

<commades>

else if(<expression>)

<commades>

else

<commades>

endif
Structure "switch" :


Syntaxe :

switch(<string>)

case <pattern 1>:

<commades>

case <pattern 2>:

<commades>

default:

<commades>

endsw
Structure "foreach" :


Syntaxe :

foreach <variable> (<liste_de_valeur>)

<commandes>

end
L'instruction "foreach" va exécuter la boucle autant de fois qu'il y a de valeurs dans <liste_de_ valeurs> en donnant à <variable> chacune des valeurs de <liste_de_ valeurs>.
Structure "repeat" :


Syntaxe :

repeat <nombre> <commande>
<nombre> indique le nombre de fois que <commande> sera exécutée.
Structure "while" :


Syntaxe :

while <expression_vraie>

<commandes>

end
Instruction "break" :


L'instruction break permet de sortir de la boucle en cours.
Instruction "continue" :


L'instruction continue permet de revenir au début de la boucle en cours.