Différences

Ci-dessous, les différences entre deux révisions de la page.

--- projets:ecole:scripting:initiation_au_shell [Le 02/07/2007, 21:27] – Quelques modifs de forme didrocks
+++ projets:ecole:scripting:initiation_au_shell [Le 24/04/2026, 14:04] (Version actuelle) – <code> -> <code bash> pour + de lisibilité ! bcag2
@@ Ligne 1: / Ligne 1: @@
+{{tag>script shell brouillon programmation }}
+----
 ====== Initiation au Shell ======
@@ Ligne 5: / Ligne 7: @@
 -----------------
 ===== Généralités =====
-Le **Shell** est une interface entre l'utilisateur et le système d'exploitation. L'utilisateur entre des commandes, qui sont ensuite interprétées par le Shell, et celui-ci renvoye un certain résultat.
+Le **Shell** est une interface entre l'utilisateur et le système d'exploitation. L'utilisateur entre des commandes, qui sont ensuite interprétées par le Shell, et celui-ci renvoie un certain résultat.
 {{icons:iconnote.png  }}
@@ Ligne 26: / Ligne 27: @@
 À chaque entrée/sortie est associée un numéro appelé **descripteur de fichier** comme vous pouvez le voir dans ce tableau récapitulatif :
 ^ Entrées/Sorties             ^ Nom      ^ Numéro   ^
 | Entrée standard             |  stdin   |   0      |
 | Sortie standard             |  stdout  |   1      |
@@ Ligne 36: / Ligne 37: @@
 -----------------
 ===== Redirections =====
-{{icons:icone_danger.png  }}
+Les **redirections** permettent simplement (comme leur nom l'indique), de rediriger un des trois descripteurs de fichier vu plus haut vers à peu près tout ce que vous voulez. Les opérateurs utilisés sont ">", %%">>"%%, "<" et %%"<<"%%
->Dokuwiki remplace automatiquement > >  et < <(sans l'espace entre les deux) par un guillemet comme ça >> et comme ça <<, donc jusqu'à ce qu'une solution soit trouvée (par vous peut être...) pensez à faire le changement mentalement.
-Les **redirections** permettent simplement (comme leur nom l'indique), de rediriger un des trois descripteurs de fichier vu plus haut vers à peu près tout ce que vous voulez. Les opérateurs utilisés sont ">", ">>", "<", "<<".
 ==== Sorties ====
-Prenons un exemple, on connaît la commande "ls" qui donne la liste des fichiers d'un répertoire et on veut enregistrer le résultat dans un fichier. Pour cela on    va rediriger le résultat de la sortie standard dans le fichier test à l'aide de la commande suivante :
+Prenons un exemple, on connaît la commande "ls" qui donne la liste des fichiers d'un répertoire et on veut enregistrer le résultat dans un fichier. Pour cela on    va rediriger le résultat dela sortie standard dans le fichier test à l'aide de la commande suivante :
-<code>ls > test</code>
+<code bash>ls > test</code>
 De même si on veut enregistrer stderr de la commande "lfdfdfj", on utilise :
-<code>ls 2> test</code>
+<code bash>lfdfdfj 2> test</code>
 Dans le premier exemple, on peut constater que l'on ne précise pas le descripteur de fichier redirigé (1), en effet le descripteur de fichier redirigé par défaut est stdout.
@@ Ligne 59: / Ligne 56: @@
 Techniquement, lorsque ">" est utilisé le fichier vers lequel la sortie est redirigée est créé s'il n'existait pas auparavant, sinon il est écrasé.
-Pour conserver le fichier original, vous pouvez utiliser ">>" qui n'écrasera pas le contenu du fichier s'il existe déjà. Par exemple :
+Pour conserver le fichier original, vous pouvez utiliser %%">>"%% qui n'écrasera pas le contenu du fichier s'il existe déjà. Par exemple :
-<code>ls >> test</code>
+<code bash>ls >> test</code>
 Si test n'existe pas il sera créé, si il existe le résultat sera ajouté à son contenu (à la fin du fichier). De la même manière, vous pouvez rediriger stderr :
-<code>lfdfdfj 2>> test</code>
+<code bash>lfdfdfj 2>> test</code>
-Mais il est également possible de rediriger une sortie vers une autre sortie, par exemple "2>&1" siginifie "rediriger stderr vers ce que représente stdout". Ainsi
+Mais il est également possible de rediriger une sortie vers une autre sortie, par exemple "2>&1" signifie "rediriger stderr vers ce que représente stdout". Ainsi
-<code>ls > test 2>&1</code>
+<code bash>ls > test 2>&1</code>
 redirigera stdout et stderr dans le fichier test. Vous remarquerez que les redirections s'effectuent de droite à gauche : la sortie stderr 2 est tout d'abord redirigée vers la sortie stdout 1, puis la sortie standard de ls s'inscrit dans le fichier test.
@@ Ligne 75: / Ligne 72: @@
 ==== Entrées ====
-Pour rediriger vers l'entrée standard stdin, nous allons utiliser "<" et "<<".
+Pour rediriger vers l'entrée standard stdin, nous allons utiliser "<" et %%"<<"%%.
 "wc" permet de compter le nombre de lignes (option -l) ou de mots (option -w), plus d'informations dans la page man de wc, en entrée. Pour compter le nombre de lignes d'un fichier on peut donc utiliser :
-<code>wc -l < fichier</code>
+<code bash>wc -l < fichier</code>
 Cette commande donnera le même résultat car wc peut prendre un fichier comme paramètre :
-<code>wc -l fichier</code>
+<code bash>wc -l fichier</code>
-"<<" permet lui aussi de rediriger stdin mais jusqu'à une chaîne de caractère que l'on précisera : littéralement on pourrait dire que << transmet notre entrée standard (clavier) au programme à sa gauche, et cela jusqu'à ce qu'il rencontre une ligne EOF ((End of File : Fin de fichier)).
+%%"<<"%% permet lui aussi de rediriger stdin mais jusqu'à une chaîne de caractère que l'on précisera : littéralement on pourrait dire que %%<<%% transmet notre entrée standard (clavier) au programme à sa gauche, et cela jusqu'à ce qu'il rencontre une ligne EOF ((End of File : Fin de fichier)).
 Par exemple la commande suivante vous permettra de taper un texte, d'aller à la ligne autant de fois que vous voulez en appuyant sur Entrée, puis lorsque vous taperez EOF (pour End of File, fin du fichier) et entrée, elle comptera le nombre de lignes (celle de EOF non comprise) que vous avez entrées.
-<code>wc -l << EOF</code>
+<code bash>wc -l << EOF</code>
 Vous pouvez bien sur spécifier un chaîne différente de EOF comme FIN, END...
-En utilisant ">>" et "<<" nous pouvons facilement ajouter du texte dans un fichier de notre choix de la même manière qu'un éditeur de texte :
+En utilisant %%">>"%% et %%"<<"%% nous pouvons facilement ajouter du texte dans un fichier de notre choix de la même manière qu'un éditeur de texte :
-<code>cat >> fichier << EOF</code>
+<code bash>cat >> fichier << EOF</code>
 Le texte tapé sera ajouté au fichier jusqu'à ce que vous vous écriviez EOF et validiez par entrée.
+==== >/dev/null 2>&1 ====
+Expliquons cette syntaxe très souvent rencontrée et reprise sans explication : <code bash>commande >/dev/null 2>&1</code>
+Dans l'ordre, est exécuté :
+- commande (dont les stdout et stderr sont redirigées)
+- stdout vers /dev/null (le trou noir)
+- stderr vers stdout ... donc vers /dev/null
+La commande exécutée ne renverra ni sa sortie, ni ses messages d'erreur.
+C'est équivalent à : <code bash>commande > /dev/null 2 > /dev/null</code>
 {{icons:iconnote.png  }}
@@ Ligne 108: / Ligne 118: @@
 Si vous avez besoin de plus d'informations sur une commande n'hésitez pas à consulter son manuel via la commande :
-<code>man nom_du_programme</code>
+<code bash>man nom_du_programme</code>
 Pour cette partie, consulter http://doc.ubuntu-fr.org/console/commandes_de_base pour les commandes fondadamentales : cp, mv, ls, cd, rm, chmod, chown et find.
@@ Ligne 116: / Ligne 126: @@
 Pour présenter l'outil **cut** nous allons par exemple considérer que nous voulons obtenir le premier mot (correspondant au nom de l'utilisateur) du fichier /etc/passwd.
 Avec cut, vous pouvez supprimer une partie de chaque ligne d'un fichier, soit en indiquant un séparateur (avec l'option -d), soit en indiquant la position (via -c).
 Voyons tout de suite un exemple :
-<code>cut -d: -f1 /etc/passwd</code>
+<code bash>cut -d: -f1 /etc/passwd</code>
 L'option "-d:" indique que le **séparateur** sera ":", et "-f1" indique que l'on veut récupérer seulement la **première partie**.
 {{:icons:icontip.png  }}
@@ Ligne 129: / Ligne 139: @@
 On peut aussi récupérer plusieurs parties en une seule fois en les séparant par des virgules, ici les parties 1 et 5 :
-<code>cut -d" " -f1,5 un_fichier</code>
+<code bash>cut -d" " -f1,5 un_fichier</code>
 Maintenant si l'on travaille en fonction de la position :
-<code>cut -c 1-10 /etc/passwd</code>
+<code bash>cut -c 1-10 /etc/passwd</code>
 Vous l'aurez compris cette commande récupère les caractères de 1 à 10 du fichier passwd.
@@ Ligne 143: / Ligne 153: @@
 Par exemple, on désire afficher les 5 premières lignes du fichier /var/log/Xorg.0.log :
-<code>head -n 5 /var/log/Xorg.0.log</code>
+<code bash>head -n 5 /var/log/Xorg.0.log</code>
 Pour les 5 dernières :
-<code>tail -n 5 /var/log/Xorg.0.log</code>
+<code bash>tail -n 5 /var/log/Xorg.0.log</code>
-Pour récupérer le résultat d'une commande, nous allons utiliser l'opérateur | appelé **pipe** (qui signifie tuyau...), son fonctionnement sera expliqué plus bas. Pour récupérer les 5 dernières du résultat de dmesg :
+Pour récupérer le résultat d'une commande, nous allons utiliser l'opérateur | appelé **pipe** (qui signifie tuyau...), son fonctionnement sera expliqué plus bas. Pour récupérer les 5 dernières du résultat dedmesg :
-<code>dmesg | tail -n 5</code>
+<code bash>dmesg | tail -n 5</code>
 L'option -f permet d'afficher, à chaque fois qu'ils ont lieu, les ajouts au fichier, par exemple :
-<code>tail -f /var/log/syslog</code>
+<code bash>tail -f /var/log/syslog</code>
 ===== Les pipes =====
@@ Ligne 163: / Ligne 173: @@
 ==== Présentation de "|" ====
 Cet opérateur permet d'envoyer la **sortie standard** d'un programme **vers** **l'entrée standard** d'un second programme, cela permet ainsi l'enchaînement des commandes. Par exemple :
-<code>ls | wc -l</code>
+<code bash>ls | wc -l</code>
 La sortie standard de "ls" devient l'entrée standard de "wc -l".
 Autres exemples :
-<code>cat fichier | wc -l</code>
+<code bash>cat fichier | wc -l</code>
-<code>ls -l | sort</code>
+<code bash>ls -l | sort</code>
 {{:icons:icontip.png  }}
 >sort permet de trier les lignes d'un fichier texte, pour plus d'information "man sort".
 Vous pouvez bien sûr étendre cela à plus de deux programmes :
-<code>cat fichier | wc -l | wc -L</code>
+<code bash>cat fichier | wc -l | wc -L</code>
 Vous pouvez aussi utiliser les redirections vues précédemment :
-<code>ls -la > fichier | wc -l</code>
+<code bash>ls -la > fichier | wc -l</code>
 Dans le cas de "ls -la > fichier" nous pouvons remarquer qu'il n'y a rien sur stdout ou stderr. Pour pallier à cela le programme tee permet de copier l'entrée standard sur la sortie standard et dans un fichier : "ls -la | tee fichier".
 Ainsi on utilisera :
-<code>ls -la | tee fichier | wc -l</code>
+<code bash>ls -la | tee fichier | wc -l</code>
 ==== Présentation de "&" ====
@@ Ligne 196: / Ligne 206: @@
 Cet opérateur permet de lancer simultanément deux commandes dont la première sera lancée en arrière plan. Par exemple :
-<code>ls & ls -la</code>
+<code bash>ls & ls -la</code>
 {{icons:iconnote.png  }}
->Vous pouvez aussi l'utiliser pour mettre un programme en arrière plan : "ed &". Pour reprendre la main sur ce programme il faut utiliser la commande fg.
+Vous pouvez aussi l'utiliser pour mettre un programme en arrière plan : "ed &". Pour reprendre la main sur ce programme il faut utiliser la commande fg.
 ==== Présentation de "&&" ====
 Pour pouvoir bien comprendre ce que fait cet opérateur il faut d'abord parler rapidement des **codes de retour** : quand vous lancez une commande, si elle se termine correctement alors le code de retour est "0", ce qui correspond à un succès, dans le cas contraire le code de retour est différent de 0 (bien entendu les codes de retour différents de 0 ont une signification qui ne sera pas expliquée ici).
 Si par exemple vous rentrez une commande erronée, le code de retour sera différent de 0 : "fgsfdg".
 Pour voir le code de retour de la dernière commande lancée :
-<code>echo $?</code>
+<code bash>echo $?</code>
 L'opérateur "&&" permet de lancer une commande si et seulement si la première (celle à gauche de l'opérateur) s'est correctement terminée :
-<code>ls && ls /</code>
+<code bash>ls && ls /</code>
 Si la commande "ls" se termine correctement alors "ls /" sera exécutée. Un second exemple :
-<code>fdgfdsg && ls</code>
+<code bash>fdgfdsg && ls</code>
 ==== Présentation de "||" ====
-C'est simplement l'inverse de "&&". La commande à gauche de l'opérateur est éxécutée seulement si le code de retour de la première commande est différent de 0 (donc s'il y a eu une erreur) :
+C'est simplement l'inverse de "&&". La commande à droite de l'opérateur est exécutée seulement si le code de retour de la première commande est différent de 0 (donc s'il y a eu une erreur) :
-<code>fhgfdsjk || ls</code>
+<code bash>fhgfdsjk || ls</code>
 Dans ce cas "ls" sera exécuté.
@@ Ligne 229: / Ligne 240: @@
 ==== Présentation de ";" ====
-Cet opérateur est équivalent à un retour à la ligne, c'est à dire que "ls; ls -l" éxecutera "ls" dans un premier temps, et une fois la première commande finie, quelque soit le code de retour "ls -l" sera exécuté.
+Cet opérateur est équivalent à un retour à la ligne, c'est à dire que "ls; ls -l" exécutera "ls" dans un premier temps puis, une fois la première commande finie et quel que soit son code de retour, "ls -l" sera exécuté.
 --------------------------------
 ===== Les expressions régulières =====
@@ Ligne 239: / Ligne 251: @@
 Pour commencer nous allons chercher grâce à elles des mots dans le dictionnaire /usr/share/dict/french, malheureusement celui-ci a des problèmes d'accents, on va donc le convertir en un fichier où l'on pourra lire les accents :
-<code>iconv -f ISO-8859-15 -t UTF-8 /usr/share/dict/french > /tmp/french.utf8</code>
+<code bash>iconv -f ISO-8859-15 -t UTF-8 /usr/share/dict/french > /tmp/french.utf8</code>
 Pour plus d'informations sur iconv, voir la page du manuel. Maintenant notre dictionnaire est /tmp/french.utf8 .
@@ Ligne 245: / Ligne 257: @@
 Nous allons chercher les mots qui finissent par -er, pour cela on parcourt le fichier avec grep et on ne sort que les lignes finissant par -er :
-<code>grep 'er$' /tmp/french.utf8</code>
+<code bash>grep 'er$' /tmp/french.utf8</code>
 L'opérateur **$** indique donc la **fin de ligne**.
@@ Ligne 251: / Ligne 263: @@
 Maintenant on désire chercher les mots commençant par absol- :
-<code>grep '^absol' /tmp/french.utf8</code>
+<code bash>grep '^absol' /tmp/french.utf8</code>
 L'opérateur **^** indique le **début d'une ligne**.
 On cherche maintenant les mots de 4 caractères commençant et finissant par un t, pour cela on utilise l'opérateur "**.**" qui remplace n'importe quel caractère, il est parfois appelé **wildcard** :
-<code>grep '^t..t$' /tmp/french.utf8</code>
+<code bash>grep '^t..t$' /tmp/french.utf8</code>
-Pour avoir exactement la ligne contenant "coucou", qui doit donc commencer et fnir par coucou :
+Pour avoir exactement la ligne contenant "coucou", qui doit donc commencer et finir par coucou :
-<code>grep '^coucou$' /tmp/french.utf8</code>
+<code bash>grep '^coucou$' /tmp/french.utf8</code>
 ==== Les modificateurs ====
-* représente **0 ou plus** caractères. Exemple : d* = 0 ou plus fois "d"
+  * * représente **0 ou plus** caractères. Exemple : d* = 0 ou plus fois "d".
-+ représente **1 ou plus** caractères.
+  * + représente **1 ou plus** caractères.
-? représente **0 ou 1** caractères.
+  * ? représente **0 ou 1** caractère.
 Par exemple si l'on cherche les mots commençant par "t" et finissant par "tant" :
-<code>grep '^t.*tant$' /tmp/french.utf8</code>
+<code bash>grep '^t.*tant$' /tmp/french.utf8</code>
 "^t" nous donne les mots commençant par "t", "tant$" prends ceux finissant par "tant" et au milieu on veut 0 ou plus fois n'importe quel caractère, donc le ".".
 On veut maintenant chercher les mots contenant "m" ou "mm", pour cela on va utiliser une expression régulière étendue, il faudra donc utiliser l'option "-E" de grep :
-<code>grep -E 'm{1,2}' /tmp/french.utf8</code>
+<code bash>grep -E 'm{1,2}' /tmp/french.utf8</code>
+Remarque : cette expression donne les mots contenant 1 ou 2 m consécutifs ou non.
 {{:icons:icontip.png  }}
->Les expressions régulières étendues se calculent moins rapidement que celles de base, pour alléger les programmes elles sont regroupées et accesibles via -E.
+>Les expressions régulières étendues se calculent moins rapidement que celles de bases, pour alléger les programmes elles sont regroupées et accessibles via -E.
-Pour être toujours plus fou, on veut maintenant trouver tous les noms finissant par "eux" ou "eut" pour créer des nom de domaines en ".eu". Pour cela on prend les mots qui commencent par n'importe quoi grâce à "^.*", puis qui termine par "x" ou "t" grâce à "[xt]", tout ça avec "eu" au milieu bien sûr :
+Pour être toujours plus fou, on veut maintenant trouver tous les noms finissant par "eux" ou "eut" pour créer des noms de domaines en ".eu". Pour cela on prend les mots qui commencent par n'importe quoi grâce à "^.*", puis qui terminent par "x" ou "t" grâce à "[xt]", tout ça avec "eu" au milieu bien sûr :
-<code>grep '^.*eu[xt]$' /tmp/french.utf8</code>
+<code bash>grep '^.*eu[xt]$' /tmp/french.utf8</code>
 On peut ainsi chercher les jeux pour KDE et pour GNOME, en supposant que tout jeu pour KDE qui se respecte commence par un "k" et par "g" pour GNOME. Pour cela on cherche tous les jeux, et on ne garde que ceux qui commencent par "k" ou "g" :
-<code>apt-cache search games | grep '^[gk]'</code>
+<code bash>apt-cache search games | grep '^[gk]'</code>
 Maintenant on veut chercher les jeux qui ne commencent ni par "g" ni par "k" :
-<code>apt-cache search games | grep '^[^gk].*' | grep -v '^lib'</code>
+<code bash>apt-cache search games | grep '^[^gk].*' | grep -v '^lib'</code>
-Comme on l'a déjà vu [^gk] retourne ce qui commence par un "g" ou un "k", le "^" devant l'expression **[]** joue le rôle de **négation** : on prends ceux qui ne commencent ni par "g" ni par "k". Puis grâce à ".*" on accepte n'importe quelle fin. Mais cette requette renvoie beaucoup trop de résultats, on effectue donc un deuxième filtrage en éliminant ceux qui commencent par "lib" grâce à l'option -v de grep qui sort les lignes correspondant à la condition.
+Comme on l'a déjà vu [^gk] retourne ce qui commence par un "g" ou un "k", le "^" devant l'expression **[]** joue le rôle de **négation** : on prends ceux qui ne commencent ni par "g" ni par "k". Puis grâce à ".*" on accepte n'importe quelle fin. Mais cette requête renvoie beaucoup trop de résultats, on effectue donc un deuxième filtrage en éliminant ceux qui commencent par "lib" grâce à l'option -v de grep qui enlève les lignes correspondant à la condition.
 Autre exemple instructif :
-<code>ls / | grep -E '^m(edia|root)</code>
+<code bash>ls / | grep -E '^m(edia|root)'</code>
 Les parenthèses permettent d'isoler un regroupement, et le | correspond à "où". Ceci renvoie donc les fichiers/dossiers à la racine commençant par media ou mroot.
 Alors que :
-<code>ls / | grep -E '^media|root'</code>
+<code bash>ls / | grep -E '^media|root'</code>
-Renvoie les fichiers/dossiers commençant par media ou par root.
+renvoie les fichiers/dossiers commençant par media ou par root.
 ==== Sed ====
 L'utilisation de cet outil se fait comme ceci :
+<code bash>echo "du texte" | sed 's/(qui)/(parquoi)'</code>
-<code>sed -e 'expression' [-e 'expression] [fichier]</code>
+Ex : Pour remplacer la premiere occurence :
-ou
+<code bash>echo "jean.durand@gmail.com" | sed 's/@/ at /' | sed 's/\./ pOiNt /'</code>
-<code>echo "du texte" | sed 'une_seule_expression'</code>
+renvoie :
-Un premier exemple de substitution :
+<code bash>jean pOiNt durand at gmail.com</code>
-<code>echo "jean.durand@gmail.com" | sed 's/@/ at /' | sed 's/\./ pOiNt /'</code>
+On remplace le "." par " pOiNt " et le "@" par " at ", on voit ici que l'on a mis "\" devant le ".", le "\" est le caractère d'échappement : le "." est alors considéré comme le caractère ".".
-Renvoie :
+De même si on veut remplacer "/" par "slash", on utiliserait
-<code>jean pOiNt durand at gmail.com</code>
+<code bash>s/\// slash /</code>
-On remplace le "." par " pOiNt " et le "@" par " at ", on voit ici que l'on a mis "\" devant le ".", le "\" est le caractère d'échappement : le "." est alors considéré comme le caractère ".".
+On peut faire la même chose en moins long en utilisant l'autre version de sed:
-De même si on veut remplacer "/" par "slash", on utiliserait **s/\//slash/** .
+<code bash>echo "jean.durand@gmail.com" | sed -e 's/@/ at /' -e 's/\./ pOiNt /'</code>
-On peut faire la même chose en moins long en utilisant l'autre version de sed:
+Pour toute les occurrences ,on peut aussi utiliser :
+<code bash>s///g</code>
+oû :
+<code bash>echo "jean.durand@gmail.com" | sed -e 's/@/ at /' -e 's/\./ pOiNt /g'</code>
+qui donnera :
+<code bash>jean pOINT durand at gmail pOINT com</code>
-<code>echo "jean.durand@gmail.com" | sed -e 's/@/ at /' -e 's/\./ pOiNt /'</code>
+On peut de même l'appliquer sur des fichiers :
-On peut aussi utiliser **s///g** pour remplacer toutes les occurences d'une chaîne de caractères et non seulement la première :
+<code bash>sed 's/kikoo/#kikoolol/g' /etc/config.txt</code>
-<code>echo "jean.durand@gmail.com" | sed -e 's/@/ at /' -e 's/\./ pOiNt /g'</code>
+Ceci remplace toute occurrence de "kikoo" par "#kikoolol" dans le fichier /etc/config.txt mais ne le modifie pas, le résultat est donné sur la sortie standard. Pour modifier le fichier il faut ajouter l'option -i à sed.
-Remplace les deux occurences du ".".
+On peut enfin spécifier l’occurrence à remplacer :
-On peut de même l'appliquer sur des fichiers :
+<code bash>echo "moimoimoi" | sed 's/moi/toi/3'</code>
-<code>sed 's/kikoo/#kikoolol/g' /etc/config.txt</code>
+Donne :
-Ceci remplace toute occurence de "kikoo" par "#kikoolol" dans le fichier /etc/config.txt mais ne le modifie pas, le résultat est donné sur la sortie standard. Pour modifier le fichier il faut ajouter l'option -i à sed.
+<code bash>moimoitoi</code>
-On peut enfin spécifier l'occurence à remplacer :
+<note warning>l'action de l'option /n (n=1,2,3...) et /g sur un fichier n'est pas identique
+en effet
+si /g modifie bien toutes les occurrences du fichier
+/n ne modifie que la première ligne du fichier
+c'est pas clair : un exemple
-<code>echo "moimoimoi" | sed 's/moi/toi/3'</code>
+le fichier1 contient 3 lignes identiques kikoo
-Donne :
+le fichier2 contient kikookikookikoo et 2 lignes kikoo
-<code>moimoitoi</code>
+résultat de
+sed -i 's/kikoo/#kikoo/2 :
-Nous allons maintenant voir l'utilisation de variables avec sed ce qui permet d'échanger, de déplacer des parties d'une chaîne de caractères. Exemple :
+le fichier1 n'est pas modifié !
+le fichier 2 devient kikoo#kikookikoo les 2 autres lignes ne sont pas modifiées
+----------------------------------------------------------
+résultat de
+sed -i 's/kikoo/#kikoo/g  : les deux fichiers sont modifiés
+tous les kikoo deviennent #kikoo
+----------------------------------------------------------
+</note>
+Nous allons maintenant voir l'utilisation de variables avec sed ce qui permet d'échanger, de déplacer des parties d'une chaîne de caractères. Exemple :
-<code>echo "jean.durand"  | sed -r 's/(.*)\.(.*)/\2.\1/'</code>
+<code bash>echo "jean.durand"  | sed -r 's/(.*)\.(.*)/\2.\1/'</code>
 (.*) représente l'affectation des variables et \n la n-ième variable, ici on met donc ce qu'il y a avant le point ("\.") dans \1 et ce qu'il y a après dans \2 puis on met \2 devant \1, on obtient :
-<code>durand.jean</code>
+<code bash>durand.jean</code>
 Pour terminer nous allons voir un exemple pratique : nous avons de nombreux dossiers contenant de nombreux mp3 nommés selon le schéma Knoklezout_au_taquet-Jamendo-David_TMX.mp3 et on désire avoir le nom d'artiste avant le titre de la chanson tout en enlevant la publicité pour Jamendo.
 Pour cela nous allons utiliser **rename** (qui vient avec perl) et nos chères expressions régulières :
-<code>rename 's/^(.*)-Jamendo-(.*)\.mp3/$2_-_$1.mp3/' *.mp3</code>
+<code bash>rename 's/^(.*)-Jamendo-(.*)\.mp3/$2_-_$1.mp3/' *.mp3</code>
 Le principe est le même qu'avec sed sauf que les variables sont notées $n et non plus \n : on met ce qu'il y a avant "-Jamendo-" dans $1 et ce qu'il y a après (".mp3" non compris) dans $2 puis on formate comme on le veut.
-**rename** renomme les fichiers dans le dossier courrant, pour plus de sécurité on peut utiliser **rename -n 's///'** qui nous affiche les changements sans les effectuer, puis les effectuer une fois que l'on est sûr.
+**rename** renomme les fichiers dans le dossier courant, pour plus de sécurité on peut utiliser ** rename -n 's/'** qui nous affiche les changements sans les effectuer, puis les effectuer une fois que l'on est sûr.
---------------------------
 ===== Liens =====
@@ Ligne 390: / Ligne 425: @@
 {{icons:iconnote.png  }}
->Les expressions régulières sont utilisés en Python, Perl , Ruby, PHP, Java, C, C++, par des programmes comme sed, awk, grep, vim, rename, ou encore des filtres dans apache et lighttpd ( mod_rewrite, vhosts ...), adblock dans firefox... Cette liste est bien sûr exhaustive.
+>Les expressions régulières sont utilisés en Python, Perl , Ruby, PHP, Java, C, C++, par des programmes comme sed, awk, grep, vim, rename, ou encore des filtres dans apache et lighttpd ( mod_rewrite, vhosts ...), adblock dans firefox... Cette liste est bien sûr non exhaustive.
 -----------------
-Rédigé par : [[:utilisateurs:qazer]], ptitdav69 et Wazzaaabid
+Rédigé par : [[:utilisateurs:qazer|jeromeg]], ptitdav69 et Wazzaaabid

Différences

Outils pour utilisateurs

Outils du site

Outils de la page

Divers