tite fractale

À la découverte d’UNIX

1. Introduction

Cette page comporte certains jugements personnels et peut être considérée comme de la propagande pour les logiciels libres et la philosophie UNIX. Je tenais, en plus de faire une activité sur le shell, à dissoudre quelques clichés ou contre-vérités que l’on peut entendre même au plus haut niveau universitaire ou dans des campagnes marketing d’une grande entreprise.

Sur cette page je vais faire quelques rappels historiques sur UNIX et ses héritiers, quelques mises aux points sur certains abus de langage et clichés, et quelques considérations sur les systèmes d’exploitations libres contemporains, considérations positives ou négatives. Malgré tous mes efforts, il est possible qu’ils soient encore un peu longs et que vous préfériez aller directement à l’activité.

2. Un peu d’histoire

Paragraphes basés sur cet article et quelques autres liés depuis cette page.

2.1. Origines

En 1969, Kenneth Thompson développe un système d’exploitation baptisé UNIX (nom déposé, jeu de mot sur Multics), écrit en assembleur. Un tel langage étant difficile à organiser sur des projet d’une telle ampleur, Dennis Ritchie est poussé à inventer quelques années plus tard un langage plus adapté, qui deviendra le C, qui a permis de coder des UNIX moins dépendants de la machine.

2.2. Une famille

Arbre généalogique UNIX

Depuis cette époque, UNIX a vu beaucoup d’évolutions et de versions distinctes, développées séparément, mais qui ont respecté les idées fondamentales des origines. Ces idées tissent les liens de parenté de ce que l’on appelle « la famille des UNIX ». L’informatique doit beaucoup à ces deux pionniers, plus qu’à des commerciaux vénérés qui auraient pu éclipser la mort de Dennis Ritchie en octobre 2011.

Pour une frise mise à jour régulièrement, consulter http://futurist.se/gldt/.

2.3. Idée fondamentale

S’il y en a une à retenir, prenons celle-ci :

Des outils très simples, ne faisant qu’une seule chose, mais très bien, que l’on peut aisément faire travailler ensemble.

L’orthogonalité (sorte d’indépendance) et la flexibilité des outils qui, s’ils étaient isolés, seraient tout juste utiles voire à peine utilisables, permettent de dépasser la somme des potentiels de chacun en les combinant intelligemment.

C’est ce principe qui est illustré dans l’activité qui est proposée sur cette page.

Pour plus de détails, voir l’article Wikipedia sur la philosophie d’Unix et ces pages méditatives (en anglais).

2.4. Autres systèmes d’exploitation libres

[ Celebrate 30 years of GNU! ]

Sur ces bases Richard Stallman, lance en septembre 1983 le projet GNU qui vise à réécrire un UNIX libre. Un effet, Richard Stallman a travaillé (et travaille encore), via la Fondation du logiciel libre, à l’élaboration d’outils pour garder le contrôle des logiciels, logiciels que les professionnels, mais aussi les particuliers, utilisent sur leurs machines.

Le concept des logiciels libres doit être distingué des logiciels gratuits (c’est le même mot en anglais : free) et, distinction plus subtile, des logiciels ouverts. Pour une explication détaillée, voir une section d’un article Wikipedia, ou mieux, les articles de Richard Stallman lui-même :

N’oublions pas que les formats (formats de fichiers, protocoles de communication…) ont aussi une grande importance. Des formats ouverts sont nécessaires pour garantir une meilleure interopérabilité, sans limite dans le temps, et pour garantir une indépendance par rapport aux logiciels qui ont créé les fichiers.

Toutes ces notions étant à mettre en opposition aux licences propriétaires, logiciels propriétaires, formats propriétaires. Le livre de Roberto Di Cosmo Le hold-up planétaire est très complet sur le sujet.

Ces efforts ainsi que l’arrivée d’un noyau ouvert, MINIX, développé par Andrew Tannenbaum, puis d’un noyau libre, Linux, développé par Linus Torvalds, ont permis à une myriade de développeurs bénévoles de faire progresser les logiciels libres afin qu’ils puissent être :

Parallèlement aux systèmes de type GNU/Linux :

Aujourd’hui, on dispose de systèmes d’exploitation libres très complets, qui n’ont rien à envier aux systèmes propriétaires. En effet, depuis leurs ancêtres que l’on ne pouvait utiliser qu’en ligne de commande (en lisant et en tapant du texte, voir plus loin), les systèmes de type Unix disposent de gestionnaires graphiques et éventuellement gestionnaires de fenêtres et de bureaux complets (explorateur graphique de fichiers, icônes sur un fond d’écran, menus pour lancer les applications…), qui ont même pour certain l’air de venir du futur.

Pour nuancer ce tableau idyllique de liberté, notons tout de même que très peu de distributions sont 100% libres, sans parler du matériel, qui est loin d’être libre, même si des efforts sont faits en ce sens.

3. Mises au point

3.1. Linux

Personnage Dialogue
Puriste : « Je n’utilise pas Windows. »
Candide : « Tu as un Mac ? »
Puriste : « Non. »
Candide : « Ah, t’as installé Linux ! »
Puriste : « Disons plutôt que j’ai une distribution du type GNU/Linux. »

Ici, le puriste corrige le candide en soulignant qu’utiliser le mot Linux seul pour désigner un système d’exploitation est un abus langage, Linux n’est qu’un noyau (pour le vérifier, son code source est disponible ici) et l’installer seul sur une machine ne la rendrait pas utilisable.

Pour compliquer encore la situation, GNU/Linux n’est pas le seul couple qui permet d’utiliser un système d’exploitation libre sur un ordinateur. Nous avons évoqué plus haut les systèmes de la famille BSD. D’autre part, pour les autres matériels, il existe souvent des systèmes d’exploitation alternatifs libres :

Malheureusement cet abus a fini par s’installer même chez les utilisateurs des systèmes d’exploitation libres, comme le prouve cet article Wikipedia. Cette controverse est bien sûr abondamment discutée dans le milieu et les arguments de chacuns sont répertoriés dans cet autre article Wikipedia.

Pour conclure, il faut aussi bien savoir expliquer ce qu’est vraiment Linux aux candides, que tempérer les puristes.

3.2. Autres clichés

3.2.1. Ligne de commande

Le développement d’UNIX a bien sûr été fait sur des machines très anciennes, les PDP-7 et les PDP-11, sans interface graphique.

Depuis, les utilisateurs de systèmes de type UNIX ont pu installer des interfaces graphiques, et certains n’utilisent jamais d’interface en ligne de commande. C’est donc un cliché de dire que les linuxiens tapent des lignes de commande toute la journée.

D’un autre côté, ce cliché a, comme tous les clichés, une base solidement ancrée dans la vérité : certains utilisateurs ont apprivoisé les idées fondamentales d’UNIX, et contrôlent leur machine au travers de l’interpréteur de commandes, mais en mode texte simulé. En effet, certains programmes ont été écrits pour retrouver la simplicité et la puissance des idées fondamentales d’UNIX (voir par exemple l’activité proposée sur cette page), dans une interface graphique moderne. D’autre part, les environnements en mode texte. permettent d’utiliser des programmes certes un peu plus limités en fonctionnalités, mais beaucoup moins gourmands en ressources, comme :

Autres liens connexes 

3.2.2. Sécurité

La sécurité des systèmes Unix dépend surtout des qualités de l’administrateur. Les équipes marketting d’Apple se moquent de nous (en même temps, c’est leur travail) et insultent la mémoire de D.Ritchie en laissant ce paragraphe et ce logo sur une de leurs pages :

plaque UNIX

Mac OS X repose sur une structure UNIX à toute épreuve qui le rend résistant aux virus informatiques. Vous n'avez donc pas à craindre de perdre le fruit de votre dur labeur. Pour encore plus de sécurité, Safari, le navigateur web signé Apple, vous avertit dès que vous téléchargez une application. Et Apple sort régulièrement des mises à jour de sécurité gratuites, que les possesseurs de Mac peuvent télécharger automatiquement.

Pour ce qui est des virus, lire la page qui y est consacrée sur le wiki d’Ubuntu.

3.2.3. Stabilité

On ne peut pas dire « Linux est plus stable que Windows » en général, même si certains facteurs du paragraphe suivant peuvent le laisser penser. Cela dépend de la version de Windows (XP est par exemple une des plus solide versions de Windows, puisque plus éprouvé) et cela dépend des distributions (les approches au niveau de la sécurité et les rythmes de développement sont très différents d’une distribution à une autre).

4. Intérêt de telles distributions

Scoop (mai 2013) : les habitants de l’ISS ne peuvent pas se tromper !

4.1. hérités unix

En cours de rédaction…

outils simples à combiner

tout est fichier

http://fr.wikipedia.org/wiki/Filesystem_Hierarchy_Standard

http://fr.wikipedia.org/wiki/R%C3%A9pertoire_racine

partoches

droits

4.2. autres

En cours de rédaction…

maîtrise totale de la machine si admin (configuration mais aussi applications (code ouvert et libre et potentiellement vérifié par des experts bénévoles mêmes si les systèmes actuels sont devenus des puits de savoir insondables.

gratuité de millions d’applis (bien avant les Markets)

gestion paquets, dépendances, mises à jour (parfois dans l'heure)

activité communauté (logiciels (progrès fonctionnalités mais aussi sécurité) mais aussi doc, tutos, traductions)

evolution maitrisée et pas tape a loeil, quoique... voir formats plus haut

bureaux sophistiqués videos (effets, tiling, bureaux virtuels)

légère, voire ultra-léger si pas d’interface graphique CLI obligé

tourne sur des machines très limitées ou vieilles (Psion, rajeunir vieille machine),

temps réel,

5. Points négatifs

En cours de rédaction…

Adaptation est difficile (que l’on retrouve aussi sur Windows ou certaines suites bureautiques lors de changement majeur de versions)

Certains périphériques (acquisition ou autre), virtualisation ou wine

isolement (peu repandu chez voisins (ext3), formats fichiers)

trop de choix

6. Le shell

6.1. Principe

Tout ce qui suit est à tester. Comment ? En lisant et en retapant les commandes. En effet, avec une interface en ligne de commande, il suffit de savoir écrire et lire. Pas besoin de trouver un bouton, une entrée de menu cachée, un clic droit improbable…

Notez que les commandes expliquées ici sont très puissantes et ont souvent beaucoup d’options qui permettent de changer leur comportement. Seul le rôle principal ou utile pour cette activité a été énoncé. Pour une documentation complète sur une commande particulière, utiliser la commande man (pour manual ou manuel en anglais), voire la commande man man. Il y a bien sûr un article Wikipedia sur la commande man.

Mais comment se mettre en mode « ligne de commande » ?

6.2. Différentes versions

6.2.1. Systèmes de type UNIX (Apple Macintosh inclus)

Lancer un terminal ou une console (suivant la dénomination utilisée sur votre machine). Vous avez ainsi accès au shell de votre système, qui peut être bash, zsh, csh, ksh, fish…

Notez qu’il est possible d’utiliser un système de type UNIX sans l’installer sur sa machine, grâce aux distributions « live ». Le système d’exploitation est en quelque sorte installé sur un medium amovible, CD-ROM ou clef USB.

6.2.2. Dans un navigateur

6.2.3. Windows

6.2.3.1. Ce qui est possible par défaut

Le mieux est de ne pas utiliser Windows bien sûr, et d’utiliser par exemple une distribution live en y lançant un terminal (ou une console selon la dénomination utilisée sur la distribution live).

Windows possède une interface en ligne de commande, command.exe ou cmd.exe, accessible par exemple en faisant ‡+R puis cmd et Entrée. On peut ainsi, pour pas très cher, se faire passer pour un pirate expérimenté. Au passage, il est préférable d’utiliser Console2 plutôt que la console fournie par défaut.

Malheureusement, cette console n’offre pas la puissance des commandes que l’on veut étudier ici.

6.2.3.2. Ce que l’on peut installer

GNU on Windows

C’est le compromis idéal entre puissance et simplicité. Le projet est ouvert et libre et il est sur Github.

Pour une installation « portable », exécuter un installateur, choisir le type d’installation minimale, et utiliser ce fichier pour rendre les commandes accessibles.

Cygwin

Installer la version de base de Cygwin ou même Mini-Cygwin est suffisant pour tester l’activité. Cygwin sera très certainement installé dans C:\cygwin, alors que Mini-Cygwin est portable et peut s’installer n’importe où, par exemple sur un support amovible. Attention, Mini-Cygwin ne possède pas la commande touch.

msysgit

Ce projet se dit être la version officielle de Git sous Windows. Voici un lien vers la page des téléchargements. Aux dernières nouvelles, la 1.8.3 fonctionnait très bien.

Des instructions pour l'installation sont disponibles dans les premières diapos de cette présentation.

Comme le développement de Git a été basé sur un environnement POSIX, lancer git-bash nous plonge dans un environnement de type UNIX en ligne de commande.

win-bash

Non testé encore. L’archive pèse autour de 5Mo.

http://win-bash.sourceforge.net/

Mobaxterm

Non testé encore. Le fichier d’installation est assez lourd : 14Mo.

http://mobaxterm.mobatek.net/

Connexion distante

Le principe est de créer un compte sur un serveur UNIX distant et de s’y connecter.

Liste des serveurs gratuits testés :

En plus de cette liste en voici d’autres, non testés :

Il suffit ensuite de s’y connecter par exemple avec :

6.2.4. Android

Android est un système d’exploitation basé sur le noyau Linux, mais ne laisse pas l’utilisateur facilement accéder au shell. Pour ce faire, vous pouvez installer :

6.3. Ruses

Taper des commandes peut sembler fastidieux quand on ne tape pas vite. Même quand on tape vite, on peut vouloir être aidé. Voici deux des mécanismes importants en ligne de commande :

TAB

La touche tabulation permet parfois de compléter le nom des commandes ou les noms de fichiers. C’est le complètement ou la complétion.

Flèches du curseur

Suivant les interpréteurs, il est possible de rappeler une commande tapée précédemment, un remontant avec la flèche du haut. Une fois la commande trouvée, appuyer sur Entrée l’exécute.

6.4. L’invite

Aussi appelé prompt en anglais, signale à l’utilisateur que la machine est prête à recevoir une commande. Il est possible de le personnaliser pour afficher l’heure, le répertoire courant, le nom de l’utilisateur, le nom de la machine sur laquelle on travaille… Une multitude de tutoriels existent sur Internet à ce sujet.

[shelltest@shell ~]$ echo $PS1
[\u@\h \w]\$
[shelltest@shell ~]$ PS1="taper une commande SVP: "
taper une commande SVP: bla
command not found: bla
taper une commande SVP: PS1=": "
: bla
command not found: bla
:

Si jamais votre prompt devient >, c’est que vous n’avez pas bien fermé les ", ou fait précéder un " par un \ (anti-slash).

Pour sortir de ce mauvais pas, tenter de fermer avec un guillemet ou, plus brutal, tenter Control + C.

~ est l’abbréviation du répertoire home de l’utilisateur, l’équivalent pour les systèmes UNIX du Mes Documents de Windows, voir cette question sur unix.stackexcange.com.

Notez que dans le jargon UNIX, un dossier se désigne par le mot répertoire. Plus de détails sur les dossiers et les répertoires dans cet article Wikipedia.

6.5. Créer et supprimer

echo

Écrit sur la sortie standard (stdout), c’est-à-dire affiche à l’écran. Sert en quelque sorte à créer du texte.

~ $ echo bonjour
bonjour
~ $ echo bonjour tout le monde
bonjour tout le monde
~ $ 

Pensez à utiliser la touche TAB. Pour tester cette fonctionnalité, taper uniquement les trois lettres ech puis appuyer sur la touche TAB. Vous devriez voir affiché echo.

Vous pouvez essayer avec moins de lettres : ec. S’il y a ambiguité, on vous proposera les commandes possibles.

ls

Liste le répertoire courant.

~ $ ls
~ $ 

Apparemment, le répertoire courant est vide.

touch

Si le fichier n’existe pas, crée le fichier (entre autres fonctionnalités).

~ $ ls
~ $ touch test.txt
~ $ ls
test.txt
~ $ 

Passer l’option -l à la commande ls permet d’obtenir des détails sur ce que l’on trouve dans un répertoire.

~ $ ls -l
total 0
-rw-------  1 shelltest  users    0 Oct 21 12:40 test.txt
~ $ 

Si vous utilisez Cygwin, vous pouvez retrouver le fichier créé dans C:\cygwin\home\votre_nom. Dans tous les cas, si vous vous demandez « Mais où suis-je ? », ou plutôt « Mais quel est donc le répertoire courant ? », vous pouvez taper la commande pwd, pour print working directory.

~ $ pwd
/home/votre_nom
~ $ 

Vous êtes déçus. Ce chemin ne correspond pas à un chemin Windows. Avec Cygwin, comme dans tout système de type UNIX, tout part de /, la racine. Elle correspond peut-être au dossier où est installé Cygwin. Retrouvez donc votre fichier à partir du dossier où est installé Cygwin. Plus d’explications sur la racine dans un exercice plus loin.

Comme ~ est votre répertoire personnel, il contient des fichiers de configuration, qui sont cachés. Pour voir les fichiers cachés, ajouter l’option -a à la commande ls :

~ $ ls -a
. .. .bashrc .bash_history
~ $ 

Nous allons expliquer . et .. plus loin.

cat

Affiche le contenu du fichier (encore une création de texte).

~ $ cat test.txt
~ $ 

Bon, là, le fichier est vide.

>> et >

Sert à rediriger un flux, ici du texte créé par la commande echo. Plus de détails sur l’article Wikipedia.

Pensez à utiliser la flêche du haut pour rappeler les instructions tapées précédemment, par exemple cat test.txt !

~ $ echo bonjour > test.txt
~ $ cat test.txt
bonjour
~ $ echo tout le monde >> test.txt
~ $ cat test.txt
bonjour
tout le monde
~ $ echo salut > test.txt
~ $ cat test.txt
salut
~ $ 

> écrase le fichier alors que >> ajoute à la suite. Ces symboles permettent de créer directement des fichiers (sans touch).

Exercice : Créer un fichier contenant la liste des fichiers du répertoire courant. À quoi cela peut servir ?

mv et rm

mv déplace ou renomme (move en anglais) et rm supprime (remove en anglais).

~ $ mv test.txt test.html
~ $ ls
test.html
~ $ rm test.html
~ $ ls
~ $ 

Les déplacements sont illustrés plus loin.

Attention : À moins que l’on ne passe des options à rm, il n’y a pas de confirmation et pas de corbeille quand on supprime un fichier.

mkdir

Si le répertoire n’existe pas, crée le répertoire.

~ $ mkdir test
~ $ ls
test
~ $ ls -l
total 2
drwx------  2 shelltest  users  512 Oct 21 12:40 test
~ $ 

C’est le moment d’illustrer les déplacement avec mv.

~ $ ls test
~ $ touch test/test.txt
~ $ ls test
test.txt
~ $ ls -l test
total 0
-rw-------  1 shelltest  users  0 Oct 21 13:33 test.txt
~ $ mv test/test.txt test.txt
~ $ ls test
~ $ ls
test            test.txt
~ $ ls -l
total 2
drwx------  2 shelltest  users  512 Oct 21 13:35 test
-rw-------  1 shelltest  users    0 Oct 21 13:33 test.txt
~ $ mv test.txt test
test/     test.txt
~ $ mv test.txt test/
~ $ ls
test
~ $ ls test
test.txt
~ $ 

On appelle chemin la chaîne de caractère constituée de la suite des répertoires (s’il y en a) menant au fichier (ou répertoire) qui nous intéresse. Dans les systèmes de type UNIX, le séparateur de fichier est / (slash) et non \\ (backslash).

mv permet aussi de renommer et déplacer les répertoires.

~ $ mv test rep_test
~ $ ls
rep_test
~ $ 

rmdir

Supprimer un répertoire (directory en anglais) est plus dangereux que supprimer un fichier. C’est pourquoi les commandes sont différentes.

~ $ rmdir rep_test/
~ $ ls 
~ $ 

6.6. Se déplacer

cd

~ $ pwd
/users/home/shelltest
~ $ mkdir test
~ $ cd test
~/test $ pwd
/users/home/shelltest/test
~/test $ 

. (point) .. (point point) et - (tiret)

., .. et - sont respectivement des abbréviations pour :

~/test $ cd .
~/test $ cd ..
~ $ cd -
/users/home/shelltest/test
~/test $ 

Exercices :

  1. Enchaîner les cd ... Que se passe-t-il au bout d’un moment ?
  2. Comment remonter de deux répertoires en une seule commande ?
  3. À quel chemin Windows correspond le chemin / ?

Pour la culture, il existe différents moyens de remonter de façon performante :

Aussi, dans un système UNIX, on ne peut pas remonter au-dessus de la racine. Il est possible d’aller dans un autre lecteur en utilisant le préfixe cygdrive.

6.7. Automatiser

seq, $() et for

Nous allons maintenant voir comment les quelques outils précédents peuvent travailler ensemble.

~ $ seq 1 10
1
2
3
4
5
6
7
8
9
10
~ $ for i in $(seq 1 10); do echo ligne $i; done;
ligne 1
ligne 2
ligne 3
ligne 4
ligne 5
ligne 6
ligne 7
ligne 8
ligne 9
ligne 10
~ $ 

Plus intéressant :

~ $ for fichier in $(seq 1 10); do touch test$fichier.txt; done;
~ $ ls
test1.txt       test2.txt       test4.txt       test6.txt       test8.txt
test10.txt      test3.txt       test5.txt       test7.txt       test9.txt
~ $ for fichier in $(seq 1 10); do touch test$fichier.html; done;
~ $ ls
test1.html      test2.html      test4.html      test6.html      test8.html
test1.txt       test2.txt       test4.txt       test6.txt       test8.txt
test10.html     test3.html      test5.html      test7.html      test9.html
test10.txt      test3.txt       test5.txt       test7.txt       test9.txt
~ $ 

La liste est mal triée, des options pour ls permettent de pallier ce genre de problème.

~ $ ls -v
test1.txt  test3.txt  test5.txt  test7.txt  test9.txt
test2.txt  test4.txt  test6.txt  test8.txt  test10.txt
~ $ 

Encore plus intéressant :

~ $ for i in $(seq 1 10); do mkdir rep$i; mv test$i.txt rep$i; done;
~ $ ls -v
rep1  rep4  rep7  rep10       test3.html  test6.html  test9.html
rep2  rep5  rep8  test1.html  test4.html  test7.html  test10.html
rep3  rep6  rep9  test2.html  test5.html  test8.html
~ $ for i in $(seq 1 10); do ls rep$i; done;
test1.txt
test2.txt
test3.txt
test4.txt
test5.txt
test6.txt
test7.txt
test8.txt
test9.txt
test10.txt
~ $ 

L’astérisque

L’astérisque sert de joker dans les chemins. La partie du chemin que le joker remplace ne contient pas de séparateur (/ sous UNIX).

~ $ ls *.html
test10.html  test2.html  test4.html  test6.html  test8.html
test1.html   test3.html  test5.html  test7.html  test9.html
~ $ ls *.txt
zsh: no matches found: *.txt
~ $ ls */*.txt
rep10/test10.txt  rep2/test2.txt  rep4/test4.txt  rep6/test6.txt  rep8/test8.txt
rep1/test1.txt    rep3/test3.txt  rep5/test5.txt  rep7/test7.txt  rep9/test9.txt
~ $ mv */*.txt .
~ $ ls *.txt
test10.txt  test2.txt  test4.txt  test6.txt  test8.txt
test1.txt   test3.txt  test5.txt  test7.txt  test9.txt
~ $ ls -v
rep1  rep5  rep9        test2.html  test4.html  test6.html  test8.html  test10.html
rep2  rep6  rep10       test2.txt   test4.txt   test6.txt   test8.txt   test10.txt
rep3  rep7  test1.html  test3.html  test5.html  test7.html  test9.html
rep4  rep8  test1.txt   test3.txt   test5.txt   test7.txt   test9.txt
~ $ rmdir rep*
~ $ ls -v
 test1.html  test2.txt   test4.html  test5.txt   test7.html  test8.txt   test10.html
 test1.txt   test3.html  test4.txt   test6.html  test7.txt   test9.html  test10.txt
 test2.html  test3.txt   test5.html  test6.txt   test8.html  test9.txt
~ $ 

Pour encore plus de magie, consulter ces pages :

pipe

Inventé par Douglas McIlroy, le pipe, tapé | avec Alt Gr et 6, permet d’envoyer la sortie d’une commande dans l’entrée d’une autre. Plus de détails peuvent être obtenus sur l’article Wikipedia correspondant, mais retenez deux choses :

  1. C’est un moyen de faire collaborer des outils simples, pour former des commandes très puissantes.
  2. L’utilisation du | est possible grâce à l’utilisation de protocoles textuels, un peu comme l’utilisateur d’UNIX communique avec son système.
    • Si un programme est capable de produire du texte, dans un format simple à analyser, un autre programme pourra utiliser cette production.
    • Si un programme effectue un certain travail sur un texte qu’on lui envoie, un autre programme pourra lui envoyer sa production.

Voyons maintenant quelques commandes

grep

Filtre les lignes et ne laisse passer que celles contenant l’argument passé à grep. Ici on ne garde que les lignes contenant « 2 ».

~ $ ls | grep 2
rep2
test2.html
test2.txt
~ $ 

sed

Transforme le flux d’entrée grâce à une expression rationnelle.

~ $ echo blabla | sed s/a/i/
blibla
~ $ echo blabla | sed s/a/i/g
blibli
~ $ echo fichier.ext | sed "s/.*\.//"
ext
~ $ echo mon.fichier.ext | sed "s/.*\.//"
ext
~ $ 

Il n’est pas utile pour le moment de bien comprendre comment la dernière commande sed fonctionne (s/.*\.//). Retenez juste que l’on est capable de donner l’extension d’un fichier dont on nous passe le nom.

~ $ for fichier in $(ls); do ext=$(echo $fichier | sed "s/.*\.//"); mkdir -p $ext; mv $fichier $ext; done;
~ $ ls
html  txt
~ $ ls -v html 
test1.html  test3.html  test5.html  test7.html  test9.html
test2.html  test4.html  test6.html  test8.html  test10.html
~ $ ls -v txt 
test1.txt  test3.txt  test5.txt  test7.txt  test9.txt
test2.txt  test4.txt  test6.txt  test8.txt  test10.txt
~ $ 

Tout est maintenant bien rangé !

Pour revenir à l’étape précédente en ressortant les fichiers de leur dossier et supprimer ces dossiers :

~ $ mv */* .
~ $ rmdir *
~ $ 

sort

Trie les lignes en entrée.

sh

Pour finir en beauté, sh invoque le shell lui-même pour exécuter les commandes dans le fichier fourni en argument.

~ $ echo 'for f in $(ls); do ext=$(echo $f | sed "s/.*\.//"); mkdir -p $ext; mv $f $ext; done;' > ranger.sh
~ $ cat ranger.sh
for f in $(ls); do ext=$(echo $f | sed "s/.*\.//"); mkdir -p $ext; mv $f $ext; done;
~ $ sh ranger.sh
~ $ ls
html  sh  txt
~ $

6.8. Utilitaires rigolos

diff

Le travail avec les fichiers plat prend une autre dimension.

fdupes

Permet de détecter les fichiers au contenu identique.

rsync

Synchronise des répertoires (utile pour les archives et pour mettre ce site à jour par exemple).

6.9. Pour aller plus loin




Christophe Gragnic, page dédiée à Alex A., le 24/07/2015, 16h32'20".






Page générée le 04/12/2016, 10h08'07" (source).
historique de la page
historique global

 TogetherJS