diff --git a/.markdownlint.json b/.markdownlint.json
index 8f2b9a1..fa671d5 100644
--- a/.markdownlint.json
+++ b/.markdownlint.json
@@ -4,6 +4,7 @@
"MD013": false,
"MD014": false,
"MD024": false,
+ "MD025": false,
"MD028": false,
"MD033": false
}
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..3e1ddaa
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,14 @@
+OUTPUT_DIR = output
+
+.PHONY: site
+site:
+ mkdir -p $(OUTPUT_DIR)
+ find . -name '*.md' -type f -print0 | xargs -0 -I {} sh -c \
+ 'mkdir -p $(OUTPUT_DIR)/$$(dirname $${1#./}); \
+ pandoc -s -f markdown -t html5 --template=template/template.html \
+ --toc --toc-depth=2 --css=style.css -o $(OUTPUT_DIR)/$${1%.md}.html {}' -- {}
+ cp -r images $(OUTPUT_DIR)
+ find $(OUTPUT_DIR) -type f -name '*.html' -print0 | xargs -0 -I {} \
+ sed -i -e 's/\.md/.html/g' {}
+ find $(OUTPUT_DIR) -type d -print0 | xargs -0 -I {} sh -c \
+ 'cp template/style.css {}' -- {}
diff --git a/README.md b/README.md
index 5e547f0..e2b4277 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,8 @@
-cours-unix-shell
-===============
+---
+title: Cours UNIX Shell
+---
+
+# cours-unix-shell
Reprise d'un [ancien cours UNIX/Shell](./UnixShell_cours2018/), dédié à des
formations internes pour
diff --git a/bases/tp.md b/bases/tp.md
index 976f947..4e2eea6 100644
--- a/bases/tp.md
+++ b/bases/tp.md
@@ -87,6 +87,7 @@
```
+
- avec un pipe pour enchaîner les deux commandes appropriées
Voir la solution
@@ -96,6 +97,7 @@
```
+
- Renommez le fichier historique.txt en monHistorique.txt
Voir la solution
diff --git a/images/Make.gif b/images/Make.gif
new file mode 100644
index 0000000..3f48c45
--- /dev/null
+++ b/images/Make.gif
Binary files differ
diff --git a/images/Shell.gif b/images/Shell.gif
new file mode 100644
index 0000000..a5669f0
--- /dev/null
+++ b/images/Shell.gif
Binary files differ
diff --git a/make/README.md b/make/README.md
index 1564859..35679dc 100644
--- a/make/README.md
+++ b/make/README.md
@@ -1,3 +1,7 @@
+---
+title: Make - UNIX
+---
+
# Make - UNIX
GNU Make est un héritier de `make`, mais sous Linux, c'est bien GNU Make qui est
@@ -8,11 +12,11 @@
Un shell fait tous les traitements qui y sont indiqués.
-
+
Un make ne fait que les traitements qui sont nécessaires.
-
+
## Syntaxe
diff --git a/output/README.html b/output/README.html
new file mode 100644
index 0000000..96ebdcf
--- /dev/null
+++ b/output/README.html
@@ -0,0 +1,45 @@
+
+
+
+
+ Cours UNIX Shell
+
+
+
+
+
+
Il dérive de versions plus anciennes, légèrement modifiées avec le temps, dont l'origine remonte à 2004. Leurs auteurs sont François Parmentier et Philippe Houdry.
+
Il aborde des principes généraux, des commandes de base et une initiation à la programmation en shell UNIX. Chaque partie comprend un cours et un TP.
+
+
UNIX: présentation des caractéristiques, de l'historique d'Unix et du cas particulier de Linux,
+
bases: redirections et commandes de base à connaître,
shell: initiation pour la programmation de scripts shell,
+
sed: substitution de textes via l'éditeur de chaînes de caractères non interactif.
+
make: outil qui fait gagner du temps en ne réitérant pas des calculs qui ne sont plus nécessaires.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/output/bases/README.html b/output/bases/README.html
new file mode 100644
index 0000000..4791ef3
--- /dev/null
+++ b/output/bases/README.html
@@ -0,0 +1,115 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Redirections et Pipes
+
Redirections
+
Accès en lecture par redirection de l'entrée
+
+ entrée et sortie standard d'une commande Unix
+
+
Entrées sorties standard
+
Toute commande Unix peut utiliser :
+
+
l'entrée standard (stdin)
+
la sortie standard (stdout)
+
+
Valeurs implicites (pour un poste de travail) :
+
+
stdin : le clavier
+
stdout : l'écran
+
+
Redirection de l'entrée standard vers un fichier
+
+ redirection de l'entrée standard d'une commande unix
+
+
Soit :
+
+
aUnixCommand = un programme Unix de type filtre
+
myFile = un fichier
+
+
La commande shell suivante : aUnixCommand < myFile
+
appliquera le programme aUnixCommand au fichier myFile et affichera le résultat sur l'écran.
+
Redirections et quelques commandes Unix
+
cat
+
Utilisée sans paramètres, recopie le fichier en entrée sur la sortie standard :
+
cat< Formation/TP1/exo.txt
+
recopie sur l'écran le fichier Formation/TP1/exo.txt.
+
cat - avec paramètres
+
La commande cat peut s'utiliser avec une liste de fichiers en paramètres.
+ Ainsi :
+
cat Formation/TP1/exo1.txt Formation/TP1/exo2.txt
+
"concatène" les fichiers sur stdout.
+
+
À NOTER : avec un seul fichier les commandes :
+
cat Formation/TP1/exo.txt
+
et
+
cat< Formation/TP1/exo.txt
+
peuvent être considérées comme équivalentes.
+
+
sort
+
Trie les lignes d'un fichier dans l'ordre lexicographique ASCII.
+
Exemple :
+
sort< Formation/TP1/table.txt
+
grep
+
Sélectionne les lignes qui contiennent une expression donnée en paramètre.
+ Syntaxe simplifiée :
+
grep expression < file
+
Exemple :
+
grep 152X < Formation/TP1/issn.txt
+
head
+
Syntaxe simplifiée :
+
head [ -number ] < file
+
+
sans paramètre, sélectionne les 10 premières lignes
+
avec paramètre, sélectionne le nombre de lignes désignées par le paramètre
+
+
Exemple :
+
head -5 < Formation/TP1/file.xml
+
Redirection de la sortie standard vers un fichier
+
La sortie standard peut à son tour être redirigée vers un fichier.
+ 2 possibilités :
+
commande> fichier
+
le résultat de la commande va servir à créer ou à remplacer (par écrasement) le contenu du fichier donné.
+
commande>> fichier
+
le résultat de la commande va servir à créer (la première fois) ou à rallonger le contenu du fichier donné (concaténation).
+
Combinaison simple des redirections
+
Entrée et sortie standard peuvent être rédirigées simultanément.
+ Ainsi :
+
cat< fA > fB
+
copie le contenu du fichier fA pour créer le fichier fB.
+
Combinaison de fitres en cascade - le pipe
+
(image manquante)pipe de deux commandes unix
+
Le mécanisme appelé pipe permet d'enchaîner des commandes en affectant la sortie de l'une à l'entrée de la suivante. Sa forme générale est :
+
c0< fA |c1|c2|...|cn> fB
+
Le fichier fA est lu et traité par la commande c0, le résultat est alors traité par c1, et ainsi de suite jusqu'à la commande cn pour laquelle le résultat est écrit dans le fichier fB.
L'objectif de cette première session de TP est de préparer votre environnement de travail en même temps que de réviser rapidement quelques notions de base.
+
Préparation de votre environnement de travail
+
+
Créez les répertoires Formation et Formation/UnixShell sous votre home directory (avec contrôle du contenu des répertoires à chaque étape avec ls ou ll qui est un alias).
+ Voir la solution
+
+
+
+
+
\ No newline at end of file
diff --git a/output/commandes/README.html b/output/commandes/README.html
new file mode 100644
index 0000000..a5aa274
--- /dev/null
+++ b/output/commandes/README.html
@@ -0,0 +1,179 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Autres commandes UNIX
+
Manuels en ligne
+
man
+
Cette commande permet d'obtenir le manuel unix en ligne de toute commande unix :
+
man [unixCommand]
+
Par exemple, on obtient l'aide en ligne (en anglais) sur la commande ls avec :
+
man ls
+
L'aide qui s'affiche se décompose en plusieurs parties, généralement (mais pas exclusivement) :
+
+
NAME : Rappel du nom de la commande et son libellé en clair
+
SYNOPSIS : Modèle générique de l'emploi de la commande
+
DESCRIPTION : Explication du fonctionnement de la commande
+
OPTIONS : Descriptions des différentes options supportées par la commande
+
USAGE : Particularités (par exemple, comportement vis-à-vis de gros fichiers)
+
EXAMPLES : Quelques exemples d'emploi, commentés
+
ENVIRONMENT VARIABLES : Listing des variables d'environnement unix ayant une action sur la commande et devant éventuellement être convenablement positionnées avant emploi de la commande (les variables d'environnement seront traitées dans la partie suivante sur les shells)
+
SEE ALSO : Renvois vers d'autres commandes unix ayant à voir avec la commande documentée
+
NOTES : Commentaires complémentaires
+
+
N'oubliez jamais de consulter le man quand vous voulez en connaître plus sur une commande, une fonction C, ou n'importe quoi d'autre (essayez man colors (obsolète)).
+
+
💡 Les mans ont évolué jusqu'à ne presque plus contenir d'exemples, les rendant beaucoup plus hermétiques.
+ Utilisez tldr pour avoir les exemples principaux pour une commande: https://tldr.sh/
+
+
Commandes sur les fichiers
+
find
+
Cette commande permet de rechercher un fichier ou un groupe de fichiers dans une arborescence unix. La recherche peut porter sur le nom du fichier, son propriétaire ou un groupe d'utilisateurs (ou bien d'autres critères, voir le man).
+
Pour retrouver un fichier par son nom ou par un masque (pattern) de celui-ci à partir du répertoire courant :
+
find . -name table*
+
Pour retrouver un (des) fichier(s) appartenant à un utilisateur particulier ou à un groupe particulier :
+
find . -user parmentf
+ find . -group dilib
+
Pour afficher la hiérarchie du répertoire courant :
+
find .
+
diff
+
Cette commande permet de comparer deux fichiers File1 et File2 et d'afficher leurs différences éventuelles, ligne à ligne.
+
diff File1 File2
+
La commande diff signale les différences qu'elle trouve à l'aide des codes suivants :
+
+
a : ligne en ajout dans File2 par rapport à File1
+
d : ligne en suppression dans File2 par rapport à File1
+
c : lignes changées entre File2 et File1
+
< : différence constatée dans File1
+
> : différence constatée dans File2
+
+
À titre d'illustration, soient les fichiers File1, File2 et File3 suivants :
+
+
+
+
File1
+
File2
+
File3
+
+
+
+
+
a
+
a
+
a
+
+
+
b
+
b
+
1
+
+
+
c
+
c
+
b
+
+
+
+
d
+
e
+
+
+
+
Les commandes diff qui suivent donneront pour rapports :
L'option -c de la commande diff permet d'avoir un rapport plus lisible, notamment dans le cas de comparaison de gros fichiers.
+
Commandes sur les contenus
+
cut
+
Cette commande permet de récupérer une ou plusieurs parties d'une chaîne de caractères, par exemple en précisant le délimiteur séparant les parties à extraire.
+
Pour récupérer le numéro de département d'un code postal :
+
$ echo 54500 |cut -c1-2
+ 54
+
Pour récupérer une partie d'une ligne avec un délimiteur, avec une variable ligne="auteur,titre,descripteurs,id" :
+
$ echo$ligne|cut -d, -f2,4
+ titre,id
+
À noter que si le délimiteur est un caractère spécial du shell, par exemple le pipe | ou le point-virgule, il faut le protéger entre guillemets.
+
$ echo$ligne|cut -d"|" -f2
+ titre
+
sed
+
Sed (pour Stream EDitor) est un éditeur non interactif de texte.
+ Il permet d'appliquer une certain nombre de commandes à un fichier puis d'en afficher le résultat (sans modifier le fichier de départ) sur la sortie standard.
+ Comme avec toute commande unix, il est possible de rediriger la sortie vers un fichier résultat.
+
+
+
+
+
\ No newline at end of file
diff --git a/output/commandes/compression.html b/output/commandes/compression.html
new file mode 100644
index 0000000..c16012b
--- /dev/null
+++ b/output/commandes/compression.html
@@ -0,0 +1,75 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Archives, compression, décompression
+
tar
+
Cette commande permet de créer un fichier archive (appelé tarfile) qui peut contenir des fichiers et répertoires.
+ Ce fichier tarfile n'est pas compressé.
+ Cette commande peut être utile pour archiver un répertoire et tout ce qu'il contient en un seul fichier.
+
tar -cvf Archives.tar Sauvegarde
+
La commande ci-dessus, avec les paramètres -cvf, permet de créer une archive du répertoire Sauvegarde dans le fichier nommé Archives.tar. Attention à l'ordre des deux derniers paramètres.
+
tar -xvf Archives.tar
+
La même commande tar avec les paramètres -xvf, permet de désarchiver le contenu du tarfile.
+ Attention au positionnement du désarchivage : il s'opère dans le répertoire courant.
+
Pour connaître le détail du contenu d'un tarfile, il faut utiliser les paramètres -tvf.
+
gzip
+
Cette commande permet de compresser un fichier afin d'en réduire la taille, pour stockage ou échange.
+ Le fichier résultat est renommé par ajout de l'extension .gz :
+
gzip corpus.xml
+
Par listing du contenu du répertoire où la compression a été réalisée, on peut voir que le fichier corpus.xml a disparu et a été remplacé par corpus.xml.gz.
+
Il est possible d'obtenir la taille d'un fichier non compressé à partir de son fichier compressé en gzip.
+
gzip -l corpus.xml.gz
+
Quatre informations sont alors affichées à l'écran :
+
+
la taille en octets du fichier compressé
+
la taille en octets du fichier non compressé
+
le ratio de compression
+
le nom du fichier initial, non compressé
+
+
compressed uncompr. ratio uncompressed_name
+ 77366 370713 79.1% corpus.xml
+
gunzip
+
Cette commande permet de décompresser un fichier compressé en .gz.
+ Sans paramètres, le fichier est décompressé sur disque et renommé sans l'extension .gz.
+ Attention, la place en octets prise correspond bien au fichier décompressé.
+ Cette commande est équivalente à gzip -d.
+
gunzip corpus.xml.gz
+
La commande ci-dessus restaure le fichier corpus.xml, qui remplace dans le répertoire courant l'ancien fichier corpus.xml.gz de plus petite taille.
+
S'il faut travailler avec un fichier compressé sans le décompresser sur disque, il faut alors qu'il soit seulement décompressé vers la sortie standard.
+ Ensuite, il suffira d'enchaîner les commandes requises avec des pipes.
+ Par exemple :
De nombreux éléments d'information sont visibles avec une commande de listing long. Ils sont au nombre de sept, avec dans l'ordre des colonnes :
+
+
la liste des droits sur 10 positions (ex.: drwxrwxrwx)
+
position 1 : le type d'entrée, fichier ou répertoire
+
positions 2-4 : les droits de l'utilisateur (user)
+
positions 5-7 : les droits du groupe de l'utilisateur
+
positions 8-10: les droits des autres groupes | | | | --- | :------------------------------------------- | | d | entrée répertoire | | - | entrée fichier | | r | lecture autorisée | | w | écriture autorisée (et écrasement) | | x | fichier exécutable ou répertoire parcourable |
+
la taille en blocs de l'entrée (peu utile pour nous)
+
le nom du propriétaire (user unix)
+
le groupe du propriétaire attaché à l'entrée
+
la taille de l'entrée en octets
+
les date et heure de la création ou de la dernière mise à jour
+
le nom du répertoire ou du fichier
+
+
+
💡 l'option -h vous donnera la taille de l'entrée dans un format plus... humain.
+
+
who, whoami, id
+
Un utilisateur unix est identifié par deux choses :
+
+
son code utilisateur (ex.: parmentf ou houdry)
+
son ou ses groupes (ex.: dps)
+
+
Différentes commandes permettent de retrouver ces informations.
+
Identification de l'utilisateur courant :
+
whoami
+
Identification des utilisateurs du système :
+
who
+
Affichage des code et groupe de l'utilisateur :
+
id
+
umask
+
Cette commande permet de paramétrer les droits rwx qui vont servir pour la création des nouveaux fichiers. Deux syntaxes sont possibles, celles qui suivent sont équivalentes et standard :
+
umask a=rx,ug+w
+ umask 002
+
Les droits des 3 entités propriétaire (u), groupe du propriétaire (g) et autres groupes (o) doivent être précisés :
+
+
a=rx pour mettre les droits r et x seulement pour tous les groupes (a=ugo, all)
+
ug+w pour ajouter le droit w aux groupes u et g seulement
+
002 est un masque en octal
+
002 est la négation de l'équivalent à a=rx,ug+w (=775) - voir tableau qui suit
+
+
chmod
+
Cette commande permet de modifier les droits d'un fichier ou d'un répertoire.
+ Pour pouvoir le faire, il faut en être propriétaire.
+ Là aussi, il y a deux façons d'utiliser cette commande : avec les groupes ugoa et les droits rwx ou bien avec un profil octal (directement, sans prendre sa négation comme avec umask).
+ Le tableau suivant résume les cas possibles :
+
+
+
+
lettres
+
binaire
+
octal
+
+
+
+
+
---
+
000
+
0
+
+
+
--x
+
001
+
1
+
+
+
-w-
+
010
+
2
+
+
+
-wx
+
011
+
3
+
+
+
r--
+
100
+
4
+
+
+
r-x
+
101
+
5
+
+
+
rw-
+
110
+
6
+
+
+
rwx
+
111
+
7
+
+
+
+
Par exemple, pour positionner les droits d'un fichier File à rwxr-xr-- :
+
chmod 754 [File]
+ chmod u=rwx,g=rx,o=r [File]
+
Pour modifier des droits positionnés à r--r----x en rwxrw-r--, on peut aussi écrire :
+
chmod ug+w,u+x,a+r,o-x [File]
+
chgrp
+
Cette commande permet de changer le groupe attaché à un fichier ou à un répertoire.
+ Par exemple, un fichier File est lié au groupe dps et il faut le changer pour le lier au groupe dilib (attention, il faut que le user appartienne aux deux groupes) :
+
chgrp veille [File]
+
newgrp
+
Cette commande permet de changer le groupe d'appartenance de l'utilisateur.
+ Cela peut être nécessaire pour accéder à des fichiers dont l'emploi est limité à certains groupes (par ex., dilib par rapport à dps).
+ Pour changer de groupe, il faut appartenir aux deux (l'ancien et le nouveau).
+
À partir du moment où cette commande est lancée, les fichiers et répertoires créés le seront sous ce nouveau groupe.
+
+
+
+
+
\ No newline at end of file
diff --git a/output/commandes/processus.html b/output/commandes/processus.html
new file mode 100644
index 0000000..9c1bcdf
--- /dev/null
+++ b/output/commandes/processus.html
@@ -0,0 +1,64 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Gestion des processus
+
ps
+
Cette commande permet de voir quels sont les processus actifs pour un terminal donné.
+ Les processus qui sont vus ici sont par exemple le shell actif ou tout programme en train de s'exécuter.
+
ps
+
L'appel de cette commande affiche la liste des processus actifs avec, en particulier, leurs numéros (dits PID).
Cette commande permet, en particulier, de détruire un processus qui ne s'est pas normalement terminé avec l'achèvement d'un traitement et qui continue d'être visible par un ps ou un top.
+ Pour faire cela, il faut utiliser le paramètre -9 de la commande suivi du numéro PID du processus à arrêter.
+
kill -9 10256
+
nice
+
Cette commande permet d'altérer délibérément la priorité d'une commande pour ne pas gêner l'exécution de tâches plus prioritaires.
+ Par exemple :
+
nice top
+
top
+
Cette commande affiche les processus les plus actifs (top CPU), avec réactualisation fréquente des informations (par défaut, toutes les 3 secondes).
+
top
+
Sont ainsi obtenus les noms des commandes et leur PID respectifs ainsi, entre autres, que le nom du propriétaire de chacun de ces processus, leur priorité ou leur charge CPU.
+ L'état affiché concerne l'ensemble des utilisateurs unix de la machine.
+
Il y a une ligne de saisie de commandes juste au-dessus de la liste des 15 processus, à la position du curseur. Plusieurs commandes peuvent être utilisées ici, dont par exemple :
+
+
h : affiche l'aide sur les commandes de top
+
k : avec l'option -9 termine un processus selon son PID (voir kill plus haut)
+
r : renice un processus, c'est-à-dire permet d'altérer volontairement la priorité d'un processus (celle-ci est un chiffre, par exemple 10) : renice [priorité] [PID]
En restant dans votre répertoire de travail (UnixShell), listez complètement le contenu de votre home directory.
+ Décrivez ce que vous y trouvez :
+
Voir la solution
+
UnixShell est à 2 nveaux sous votre home directory:
+
ll ../..
+
+
quels sont les fichiers et répertoires présents ?
+
Voir la solution
+
Des répertoires comme : ./ ../ Formation/
+ Des fichiers comme : .profile
+
+
lesquels sont cachés ?
+
Voir la solution
+
Tous ceux qui commencent par un point comme .profile
+
+
quels sont leurs propriétaires et groupes attachés ?
+
Voir la solution
+
Propriétaires : surtout vous, éventuellement l'utilisateur root
+ Groupes : le vôtre, éventuellement d'autres
+
+
quels sont les droits afférants ?
+
Voir la solution
+
Possiblement variable, mais dépendant surtout de votre umask (voir la suite)
+
+
Copiez dans votre répertoire UnixShell le fichier testUmask.txt (par un clic droit sur ce lien puis "Enregistrez la cible du lien sous" ou "Save link as").
+ Ses droits initiaux sont rwxrwxr-x.
+ Quel est votre umask ?
+
+
Voir la solution
+
Dépend de votre configuration, mais s'observe en faisant un ll pour afficher les droits pris par le fichier testUmask.txt lors de la copie sous votre compte.
+ En prenant pour exemple les droits présentés plus haut : rwxrwxr-x
+
txt user (u) : rwx, binaire 111 octal 7 group (g) : rwx, binaire 111 octal 7 other (o) : r-x, binaire 101 octal 5
+
Donc profil octal 775, d'où un umask de 002 (sa négation en octal).
+ On peut aussi lancer umask comme commande en ligne...
+
+
Modifiez les droits de ce fichier testUmask.txt de deux façons pour obtenir ceux qui suivent, en séquence pour les trois cas de proche en proche :
+
rwx------
+
rwxrwxrwx
+
rwxr-xr--
+
+
La première façon de procéder utilisera un profil octal, la seconde des lettres. Contrôlez vos actions à chaque étape.
Cherchez le chemin où se trouve votre fichier .profile, à partir de votre home directory, sans changer de répertoire.
+
+
Voir la solution
+
bash find ~ -name .profile
+
+
+
Copiez dans votre répertoire UnixShell le fichier testDiff1.txt (par un clic droit sur ce lien).
+ Ouvrez-le dans un éditeur et modifiez-le selon les consignes qui s'y trouvent.
+ Ensuite, sauvegardez-le comme testDiff2.txt.
+ Comparez les deux fichiers, analysez le rapport obtenu en fonction de vos actions.
+
+
Voir la solution
+
bash $ diff testDiff1.txt testDiff2.txt 3a4 > LIGNE AJOUTEE 6d6 < LIGNE A SUPPRIMER 9c9 < Modifiez-moi !!! --- > Modifiée
+
+
Archivage et compression
+
+
Archivez en un seul tarfile tout le contenu de votre répertoire UnixShell (placez-vous au-dessus).
+ Contrôlez le fichier .tar résultat.
+
+
Voir la solution
+
Le plus simple est d'abord de vous déplacer dans le répertoire parent de UnixShell pour l'archiver :
Créez le sous-répertoire tarzip (sous UnixShell où vous revenez) et déplacez-y votre tarfile.
+ Sans vous déplacer dans ce sous-répertoire, désarchivez le tarfile et contrôlez le résultat.
+
+
Voir la solution
+
bash $ cd UnixShell $ pwd / ... /Formation/UnixShell
+
bash $ mkdir tarzip $ mv ../Archives.tar tarzip
+
bash $ tar -xvf tarzip/Archives.tar UnixShell/ UnixShell/monHistorique.txt UnixShell/testDiff1.txt UnixShell/testDiff2.txt
Si vous avez travaillé comme cela, vous devez constater que le répertoire UnixShell s'est désarchivé sous lui-même...
+ C'est bien sûr un exemple se voulant surtout didactique.
+ Dans une situation plus concrète, le désarchivage doit s'opérer aux endroits les plus adéquats !
+
+
Toujours en restant sous UnixShell, compressez le tarfile en .gz.
+ Affichez ensuite les informations relatives aux tailles de fichiers et au ratio de compression.
Toujours en restant sous UnixShell, décompressez le tarfile.gz sur le disque.
+ Puis vérifiez le résultat en listing complet.
+ Recompressez le tarfile et contrôlez de nouveau.
GNU Make est un héritier de make, mais sous Linux, c'est bien GNU Make qui est installé.
+
Make permet de gagner du temps par rapport aux shells: on n'exécute que ce qui est nécessaire, en fonction des changements de source par rapport à leur cible.
+
Un shell fait tous les traitements qui y sont indiqués.
+
+ Un shell fait tous les traitements qui y sont indiqués
+
+
Un make ne fait que les traitements qui sont nécessaires.
+
+ Un make ne fait que les traitements qui sont nécessaires
+
+
Syntaxe
+
Le fichier Makefile contient les règles de dépendance.
+
Une règle est de la forme :
+
cible: [fichier de départ] ...
+ commande
+
+
⚠ La commande doit être précédée d'une tabulation!
La deuxième fois qu'on lance la cible compte.txt, la commande wc n'est pas exécutée, sauf si le fichier aCompter.txt a une date de modification plus récente que celle de compte.txt.
+
Une règle qui ne dépend d'aucun fichier de départ peut exister.
+ De plus, elle ne peut donner lieu à la création d'un fichier.
+ Une telle règle sera toujours exécutée (à condition que son nom ne soit pas celui d'un fichier).
Créer un fichier Makefile contenant une règle bonjour, qui affiche sur la sortie standard Bonjour, comment ca va?
+
Voir la solution
+
bonjour:
+ @echo "Bonjour, comment ca va?"
+
+
L'utilisation du @ devant echo rend la commande "silencieuse", elle n'apparaît pas sur la sortie standard.
+
+
+
+
Ajouter une règle bye qui affiche A bientot!.
+
Voir la solution
+
bye:
+ @echo "A bientot!"
+
+
+
Créer une règle qui crée un fichier modif.txt dont le contenu vient du fichier original.txt (que vous pouvez enregistrer grâce au bouton de droite) et qui remplace (grâce à sed) les apparitions de ILIB par DILIB.
+
Voir la solution
+
modif.txt: original.txt
+ sed -e 's/ILIB/DILIB/g' < original.txt > modif.txt
+
Le fichier modif.txt depend du contenu du fichier original.txt, c'est pourquoi ce dernier apparaît à droite de :.
+
+
+
Créer une règle qui crée un fichier modif2.txt à partir de original.txt et table.txt, en utilisant la table fournie pour modifier le fichier original.
Le fichier modif2.txt dépend des contenus des fichiers original.txt et table.txt (si l'un des deux est modifié, la commande sed sera exécutée).
+
+
+
Ajouter une ligne à table.txt pour remplacer CNRS par Centre National de la Recherche Scientifique.
+ Puis relancer make modif2.txt pour vérifier que la commande a bien été exécutée.
+
+
Ajouter une règle qui crée un fichier compte.txt contenant le nombre de lignes du fichier modif2.txt.
Le fichier compte.txt dépend du fichier modif2.txt (donc de sa règle, qui dépend de original.txt et de table.txt).
+ Donc si on modifie table.txt et qu'on tape make compte.txt, ou toute autre règle qui dépend directement ou indirectement de table.txt, cette règle sera exécutée.
+
+
+
Créer une règle clean qui supprime les fichiers dont le nom se termine par ~.
+
Voir la solution
+
clean:
+ rm -f *~
+
+
Si vous utilisez un lecteur Samba (probable à l'INIST), vous risquez une désynchronisation entre les fichiers enregistrés par le lecteur Samba et la date de lancement de make (il est arrivé que les fichiers aient une à deux minutes d'avance).
+ Pour limiter de tels problèmes, on peut utiliser la commande touch, qui remet un fichier à l'heure courante du shell, mais seulement sur les fichiers qui viennent d'être modifiés/créés!
+
+
+
+
Créer une règle all qui dépende de bonjour, compte.txt, clean, et bye, mais qui ne contient aucune commande (on peut quand même y mettre un echo -- Make all: exécuté --).
+
Remarques :
+
+
L'exécution d'une règle ne donne pas forcément lieu à l'exécution de sa commande.
+ Dans le cas de la production d'un fichier, quand le fichier cible est plus récent que le(s) fichier(s) dont il dépend, le fichier cible n'est pas recréé (donc, la commande de sa règle n'est pas exécutée).
+
Quand une règle dépend d'une autre règle qui dépend d'un autre fichier, et que ce fichier est modifié (par exemple grâce à la commande touch, qui change la date de modification du fichier qu'elle prend en paramètre), les commandes de chacune de ces règles sont exécutées (voir le comportement de make all après avoir tapé touch original.txt, ou après avoir ajouté du texte à original.txt).
+
+
+
+
+
\ No newline at end of file
diff --git a/output/sed/README.html b/output/sed/README.html
new file mode 100644
index 0000000..38669fd
--- /dev/null
+++ b/output/sed/README.html
@@ -0,0 +1,144 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
sed - UNIX
+
Sed (pour Stream EDitor) est un éditeur non interactif de texte.
+ Il permet d'appliquer une certain nombre de commandes à un fichier puis d'en afficher le résultat (sans modifier le fichier de départ) sur la sortie standard.
+ Comme avec toute commande unix, il est possible de rediriger la sortie vers un fichier résultat.
+
Substitution
+
La commande suivante lit un fichier file.txt et affiche ses lignes sur la sortie standard en remplaçant la chaîne « Dilib » par la chaîne « DILIB ».
+
sed's/Dilib/DILIB/' file.txt
+
Il est conseillé d'entourer les commandes par des apostrophes simples, pour éviter que le shell n'interprète les caractères spéciaux (.*[]^$\).
+
+
⚠ Cette commande ne remplace que la première occurrence de « Dilib » sur chaque ligne du fichier.
+ S'il y en a deux, la deuxième ne sera pas remplacée, à moins d'utiliser l'option g en fin de commande :
+
sed's/Dilib/DILIB/g' file.txt
+
+
Si on veut faire deux remplacements sur la même ligne de commandes, on peut utiliser :
+
sed -e 's/Dilib/DILIB/g' -e 's/Jacques Ducloy/Monsieur Dilib/g' file.txt
+
+
⚠ Le -e est obligatoire pour distinguer la deuxième commande d'un nom de fichier qui n'en est jamais précédé.
+
📗 Les commandes sont effectuées sur chaque ligne dans leur ordre d'apparition, ce qui veut dire que « Jacques Ducloy » sera transformé en « Monsieur Dilib » après la substitution de « Dilib » par « DILIB », il restera donc des « Dilib » sur la sortie standard.
+
+
Rappel sur les expressions régulières
+
+
+
+
+
+
+
+
^
+
début de ligne
+
+
+
$
+
fin de ligne
+
+
+
[]
+
classe de caractères (exemples : [A-Z] correspond à toutes les lettres majuscules)
+
+
+
[^...]
+
classe de caractères correspondant à n'importe quels caractères sauf ceux qui suivent le caractère ^
+
+
+
+
Exemple : [^:] correspond à tous les caractères sauf le :.
+
+
+
*
+
le caractère précédant * répété de 0 à n fois
+
+
+
+
+
le caractère précédant + répété de 1 à n fois
+
+
+
?
+
le caractère précédant ? présent de 0 à 1 fois
+
+
+
+
Expressions régulières
+
On peut utiliser des expressions régulières dans les chaînes à remplacer (donc, il faut banaliser les caractères spéciaux dans cette chaîne).
+
sed -e 's/Jacques D[uU][cC][lL][oO][yY]/Monsieur Dilib/g' fichier
+
+
📗 Le caractère * englobe autant de caractères qu'il peut, ce qui veut dire que
+
sed's/ré.*duction/réduction/g' fichier
+
transformera le fichier
+
do ré mi fa sol la si duction ah bon duction la suite
+
en
+
do réduction la suite
+
et non en
+
do réduction ah bon duction la suite
+
+
Récupération
+
Les opérateurs \( et \) sauvent leur contenu et permettent leur récupération par l'utilisation de \1, \2, etc.
+
sed -e 's/^\([A-Z][A-Za-z]*\), \([A-Z][A-Za-z]*\)/\2 \1/' fichier
+
Remplacera les « Nom, Prénom » en début de chaque ligne du fichier (quand il en trouve) par « Prénom Nom ».
+
Fichier de commandes
+
Si vous avez beaucoup de commandes, vous pouvez les rassembler dans un fichier comme celui-là :
+
# Fichier "exemple.sed"
+ # Il ne peut y avoir de commentaires que dans un bloc au début du
+ # fichier.
+ s/É/É/g
+ s/À/À/g
+ s/Ç/Ç/g
+
Pour appeler ce fichier, il faut utiliser l'option -f :
+
sed -f exemple.sed fichier
+
Une autre solution consiste à en faire un script exécutable (à la manière d'un script shell) :
+
#!/usr/bin/sed -f
+ # Table de transcodage de ISO-8859-1 vers HTML
+ # Fichier "exemple2.sed"
+ s/É/É/g
+ s/À/À/g
+ s/Ç/Ç/g
+
Mais il ne faut pas oublier de lui donner les droits en exécution, pour pouvoir l'appeler ainsi :
+
chmod u+x exemple2.sed
+ ./exemple2.sed fichier
+
+
⚠ Un fichier de commandes sed doit toujours se terminer par un passage à la ligne, sinon la dernière commande n'est pas prise en compte!
+
+
+
⚠ De la même manière, toutes les lignes à traiter doivent finir par un retour à la ligne (en particulier la dernière)!
Écrivez une commande sed transformant la chaîne « moins » en « plus ».
+ Appliquez-la à « Vous aurez moins de budget ».
+
Voir la solution
+
sed -e 's/moins/plus/g'
+
+
Utilisation d'un fichier de commandes
+
Écrivez un commande sed transformant toutes les lettres minuscules en leur suivante lexicographique (cas particulier : z se transforme en !).
+ Rappel : vous pouvez utiliser un fichier pour rassembler plusieurs commandes sed.
📗 Cette solution peut sembler étrange, car les substitutions ne se font pas dans l'ordre alphabétique mais dans l'ordre alphabétique inverse.
+ C'est nécessaire car sinon tous les a se transforment en b, puis tous les b (y compris ceux qui sont nouvellement transformés) en c, etc., pour finir par un texte intégralement composé de lettres a.
+
+
+
Substitution en début de ligne
+
Écrivez une commande sed qui affiche uniquement le début de chaque ligne du fichier /etc/passwd jusqu'au premier caractère :.
+
Voir la solution
+
sed -e 's/^\([^:]*\).*$/\1/' /etc/passwd
+
+
📗 On aurait pu aussi utiliser la commande cut.
+
+
+
Substitution dans toute la ligne
+
Écrivez une commande sed qui remplace les couples de guillemets anglais par un couple de guillemets français (Ceci est un "exemple" qui doit "fonctionner". doit donner Ceci est un <<exemple>> qui doit <<fonctionner>>.).
+
+
+
+
+
\ No newline at end of file
diff --git a/output/shell/README.html b/output/shell/README.html
new file mode 100644
index 0000000..7f6cf29
--- /dev/null
+++ b/output/shell/README.html
@@ -0,0 +1,89 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Variables d'environnement - Shell - UNIX
+
Le shell contient diverses variables d'environnement.
+ Si vous voulez les voir toutes, utilisez la commande set ou la commande env sans paramètre.
+
Certaines de ces variables peuvent nous intéresser plus particulièrement (pour visualiser leur contenu, utilisez la commande echo, par exemple echo $HOME pour afficher le contenu de la variable HOME) :
+
+
+
+
+
+
+
+
nom
+
contenu
+
+
+
+
+
HOME
+
chemin de votre home directory
+
+
+
PATH
+
liste des chemins parcourus par le shell pour trouver les commandes à exécuter (quand le chemin complet n'est pas précisé)
+
+
+
PS1
+
"Prompt" utilisé dans le shell (on peut modifier sa valeur)
+
+
+
SHELL
+
indique le shell qu'on utilise
+
+
+
USER
+
votre nom d'utilisateur
+
+
+
+
Pour modifier la valeur d'une variable (ou en créer une), il suffit d'utiliser la syntaxe :
+
VARIABLE=valeur
+
+
⚠ Il ne faut pas mettre d'espace autour du caractère =
+
+
Par convention, les noms de variable sont en majuscules.
+ Pour accéder à la valeur d'une variable, on utilise :
+
$VARIABLE
+
ou, pour éviter des ambiguités (si a="var", ${a}b renvoie varb alors que $ab est invalide) :
+
${VARIABLE}
+
On peut créer des variables utilisateurs de la même manière.
+
Une variable n'est disponible que dans le shell où on l'a initialisée.
+
Faire précéder l'affectation d'une variable du mot-clé export autorise son utilisation dans un shell différent.
+
+
+
+
+
\ No newline at end of file
diff --git a/output/shell/conditions.html b/output/shell/conditions.html
new file mode 100644
index 0000000..cceef5d
--- /dev/null
+++ b/output/shell/conditions.html
@@ -0,0 +1,144 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Conditions - Shell - UNIX
+
Les commandes if, while, et until testent le statut de la commande qu'ils ont en paramètre.
+
if
+
Syntaxe
+
ifcommande
+ then
+ liste_commandes
+ [elif commande
+ then
+ liste_commandes] ...
+ [else liste_commandes]
+ fi
+
Exemples
+
iftest -f $1
+ then
+ cat$1
+ else
+ echo"Le fichier \"$1\" n'existe pas"
+ fi
+
test
+
test est une commande qui renvoie une valeur vraie ou fausse (0 pour vrai, 1 pour fausse).
+ Elle a différentes options permettant de tester différentes conditions sur des fichiers, des valeurs (chaînes de caractères), etc.
+
Sa syntaxe est test expr ou [ expr ] (attention, il faut un espace après [ et avant ]).
+
+
+
+
+
+
+
+
expr
+
signification
+
+
+
+
+
-r fichier
+
vrai si le fichier existe et est accessible en lecture (r)
+
+
+
-w fichier
+
vrai si le fichier existe et est accessible en écriture (w)
+
+
+
-x fichier
+
vrai si le fichier existe et est exécutable (x)
+
+
+
-f fichier
+
vrai si le fichier existe et est un fichier "régulier" (file)
+
+
+
-d fichier
+
vrai si le fichier existe et est un répertoire (directory)
+
+
+
-s fichier
+
vrai si le fichier existe et a une taille non nulle (size)
+
+
+
c1 = c2
+
vrai si les deux expressions sont égales (des chaînes, en sh)
+
+
+
c1 != c2
+
vrai si les deux expressions sont différentes (des chaînes, en sh)
+
+
+
c1
+
vrai si c1 n'est pas la chaîne nulle (vide)
+
+
+
e1 -eq e2
+
vrai si les deux entiers e1 et e2 sont algébriquement égaux (equal)
+
+
+
e1 -ne e2
+
vrai si les deux entiers e1 et e2 sont algébriquement différents (not equal)
+
+
+
e1 -gt e2
+
vrai si l'entier e1 est plus grand que l'entier e2 (greater than)
+
+
+
e1 -lt e2
+
vrai si l'entier e1 est plus petit que e2 (lower than)
+
+
+
! expr
+
négation de l'expression booléenne expr
+
+
+
expr1 -a expr2
+
et logique entre les deux expressions booléennes expr1 et expr2 (and)
+
+
+
expr1 -o expr2
+
ou logique entre les deux expressions booléennes expr1 et expr2 (or)
+
+
+
+
Exemples
+
Quand script.sh est un fichier qui existe dans le répertoire courant.
+
$ test -f script.sh
+ $ echo$?
+ 0
+
Quand inexistant.sh est un fichier qui n'est pas dans le répertoire courant.
+
+
+
+
+
\ No newline at end of file
diff --git a/output/shell/controle.html b/output/shell/controle.html
new file mode 100644
index 0000000..303c837
--- /dev/null
+++ b/output/shell/controle.html
@@ -0,0 +1,89 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Structures de contrôle - Shell - UNIX
+
for
+
Syntaxe
+
forvar [in liste]
+ do
+ liste_commandes
+ done
+
La variable var prend successivement les valeurs de la liste.
+ Si la liste est omise, var prend alors les valeurs passées en paramètres du script ($*).
+
Exemples
+
fori
+ do
+ echo$i
+ done
+
fori in `ls`
+ do
+ cp$i /dir/$i
+ echo"$i copié"
+ done
+
Il ne faut pas oublier les apostrophes inversées (ou quotes inverses) ` qui forcent l'exécution du ls.
+
while
+
Syntaxe
+
whilecommande
+ do
+ liste_commandes
+ done
+
Exemple
+
whilereada
+ do
+ echo$a>> resultat.txt
+ echo Appuyez sur Ctrl-D pour arrêter.
+ done
+
until
+
Syntaxe
+
untilcommande
+ do
+ liste_commandes
+ done
+
Exemple
+
until ! reada
+ do
+ echo$a>> resultat.txt
+ echo Appuyez sur Ctrl-D pour arrêter.
+ done
+
case
+
Syntaxe
+
case para in
+ choix1[|choix2] ... )liste_commandes;;
+ esac
+
Exemple
+
case$1 in
+ bonjour )echo"Bonjour aussi.";;
+ A+|a+ ) echo"À bientôt.";;
+ * ) echo"Je n'ai pas bien compris le paramètre \"$1\".";;
+ esac
+
+
+
+
+
\ No newline at end of file
diff --git a/output/shell/parametres.html b/output/shell/parametres.html
new file mode 100644
index 0000000..df8124d
--- /dev/null
+++ b/output/shell/parametres.html
@@ -0,0 +1,111 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Paramètres - Shell - UNIX
+
Récupération des paramètres de la ligne de commande
+
+
+
+
$0
+
nom de la commande
+
+
+
$n
+
valeur du nième paramètre
+
+
+
$#
+
nombre de paramètres
+
+
+
$*
+
liste de tous les paramètres
+
+
+
+
Pour la ligne de commande sh test.sh a b c, $0 vaut test.sh, $# vaut 3, $* vaut a b c, et $2 vaut b (à l'intérieur du script).
+
La commande shift décale les paramètres (en perdant le premier) : le deuxième paramètre devient le premier, le troisième devient le deuxième, etc. (c'est utile quand on utilise une boucle pour traiter les paramètres).
+
Variables spéciales
+
+
+
+
$$
+
numéro de processus de la dernière commande
+
+
+
$?
+
statut de la dernière commande (0 = tout s'est bien passé)
+
+
+
+
Caractères spéciaux
+
Comme à chaque fois qu'on a un caractère spécial (par exemple $), on a des caractères d'échappement.
+
+
+
+
+
+
+
+
+
+
\
+
banalise le caractère suivant
+
echo \$0 $0
+
$0 /usr/bin/ksh
+
+
+
" ... "
+
banalise les caractères sauf \, $ et `
+
echo "\$0 $0"
+
$0 /usr/bin/ksh
+
+
+
' ... '
+
banalise tous les caractères
+
echo '\$0 $0'
+
\$0 $0
+
+
+
` ... `
+
substitution de commande
+
echo `date`
+
Mon May 5 16:54:14 MEST 2003
+
+
+
+
+
💡 En 2023, il est conseillé d'utiliser $(commande) pour la substitution de commande.
+ L'exemple devient ainsi echo $(date).
+
+
+
+
+
\ No newline at end of file
diff --git a/output/shell/scripts.html b/output/shell/scripts.html
new file mode 100644
index 0000000..ccc9126
--- /dev/null
+++ b/output/shell/scripts.html
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Scripts - Shell - UNIX
+
Un fichier script contenant des commandes shell (par exemple des initialisations de variables, une automatisation de tâches,...) peut être exécuté :
+
+
soit par sh nom_fichier_shell,
+
soit par . nom_fichier_shell (la différence avec la manière précédente est que c'est comme si on tapait le contenu du fichier dans le shell courant, et non comme si on lançait un autre shell, c'est important par exemple pour les définitions de variables),
+
soit en rendant le fichier exécutable (chmod u+x nom_fichier_shell), puis en tapant le nom du fichier.
+ Cela fonctionne uniquement quand le répertoire courant, ., est dans $PATH, sinon il faut dire au shell que c'est le fichier qui est dans le répertoire courant qu'on veut exécuter : ./nom_fichier_shell.
+
+
Pour être sûr du shell qui est en train de s'exécuter dans un fichier de script shell, il est plus prudent d'ajouter son nom en début de fichier la ligne (par exemple, ici sh) :
+
#!/bin/sh
+
Cette ligne a la forme d'un commentaire (elle commence par #), on l'appelle un shebang, et signale au shell appelant qu'il faut utiliser le shell /bin/sh pour exécuter le fichier.
+ Ce shebang, qui est un en-tête, doit se mettre sur la première ligne.
+
Une seconde ligne peut être intéressante car elle peut influer sur l'ordre de tri avec sort par exemple.
+ Pour garantir un ordre de tri lexicographique, on peut positionner la variable d'environnement suivante comme suit export LC_COLLATE=C.
⚠ Tous les shells qui seront créés par la suite devront avoir le droit d'exécution correctement positionné, au moins pour leur propriétaire.
+
+
Recherche d'information sur un utilisateur
+
+
Écrivez un script shell infouser.sh qui permette de chercher si un utilisateur d'un nom donné existe sur votre machine, en affichant sa référence complète (c'est-à-dire sans aucun filtrage).
+ Le nom recherché sera passé comme paramètre au shell.
+ La recherche portera dans le fichier /etc/passwd.
+
Voir la solution
+
+
⚠ Comme d'habitude quand on veut traiter un fichier, il vaut mieux visionner son contenu, avant de vouloir l'exploiter (more /etc/passwd).
+
+
#!/bin/sh
+ grep$1 /etc/passwd
+
+
Modifiez ce shell pour qu'il teste si un paramètre est bien passé en ligne.
+ En cas d'erreur (aucun paramètre ou plus d'un), un message sera affiché expliquant la bonne syntaxe à suivre.
+
Voir la solution
+
#!/bin/sh
+
+ iftest$# -ne 1
+ then
+ echo Mauvais nombre de parametres.
+ echo
+ echo Usage: $0 uid
+ exit 1
+ fi
+
+ grep$1 /etc/passwd
+
+
+
Quelques manipulations sur un corpus XML
+
Pour cette partie du TP, il vous faut d'abord récupérer le corpus suivant : francis.exodic.xml
+
Ce fichier contient 20 notices en XML Exodic, dans une forme indentée, son exploration préparatoire est conseillée.
+
+
Écrivez un script shell qui compte le nombre de notices, en passant le nom de fichier en paramètre.
+ L'élément racine se nomme exodic.
+
Voir la solution
+
#!/bin/sh
+
+ iftest$# -ne 1
+ then
+ echo Mauvais nombre de parametres.
+ echo
+ echo Usage: $0 fichier
+ exit 1
+ fi
+
+ NB_NOTICES=`cat$1|grep"<exodic "|wc -l`
+
+ echo Nombre de notices dans $1: ${NB_NOTICES}
+
+
Modifiez le shell précédent pour qu'il teste en plus l'existence du fichier demandé avant traitement, puis pour qu'il sorte les résultats dans un fichier nommé resultats.txt.
+
Voir la solution
+
#!/bin/sh
+
+ iftest$# -ne 1
+ then
+ echo Mauvais nombre de parametres.
+ echo
+ echo Usage: $0 fichier
+ exit 1
+ fi
+
+ iftest ! -f $1
+ then
+ echo$1"n'existe pas (ou n'est pas un fichier)."
+ exit 2
+ fi
+
+ NB_NOTICES=`cat$1|grep"<exodic "|wc -l`
+
+ echo Nombre de notices dans $1: ${NB_NOTICES}> resultats.txt
+
+
⚠ Cette fois, on a mis la chaîne contenant les apostrophes (caractère spécial) entre guillemets pour les banaliser.
+
+
+
Installer et parcourir des fichiers dublin core d'un arbre de répertoires pour afficher le type de document des notices qui y sont présentes.
+ Il faut d'abord récupérer le fichier data_dc.tar.gz.
+
Votre shell devra décompresser puis installer l'archive du fichier tar sous Formation/TP_dc.
+ Cela donnera un répertoire dc contenant 5 répertoires nommés de 1 à 5.
+ Ces sous-répertoires contiennent chacun un fichier dublin_core.xml avec une seule notice (qu'il est conseillé d'aller regarder).
+
Ces opérations réalisées, la suite du shell devra chercher le type de document de chaque notice, identifiable avec dcvalue element="type".
+ Cette information trouvée, les résultats seront écrits dans le fichier typesDC.txt.
+
Voir la solution
+
#!/bin/sh
+
+ # En etant dans le repertoire Formation/TP_dc
+ gunzip data_dc.tar.gz
+ tar -xvf data_dc.tar
+
+ forFILE in dc/*/*.xml
+ do
+ cat$FILE|grep'dcvalue element="type"'>> typesDC.txt
+ done
+
+
⚠ Cette fois, on a mis la chaîne contenant les guillemets (caractère spécial) entre apostrophes pour les banaliser.
+
+
+
⚠ On utilise une double redirection en sortie >> car il faut concaténer les différentes opérations d'écriture dans le fichier résultat.
+
+
Écrivez un script shell qui utilise un fichier de clés de sélection avec grep sur un fichier de DOI, pour récupérer chaque sélection dans un fichier résultat différent.
+ Les noms de ces fichiers résultats contiendront la valeur de la clé de sélection. Le fichier de clés est listeCles.txt.
+ Le fichier à filtrer est listeDOI.txt.gz.
⚠ Il est important de noter que, surtout pour le fichier des critères de sélection, le traitement se déroule sous Unix/Linux. Par conséquent, il faut prendre garde aux fins de ligne qui doivent être de type Unix (\n).
+ La présence de fins de ligne de type Windows (\r\n) perturbe les opérations de sélection comme avec grep (matching incorrect).
+
+
+
+
+
\ No newline at end of file
diff --git a/output/unix/linux.html b/output/unix/linux.html
new file mode 100644
index 0000000..84dac05
--- /dev/null
+++ b/output/unix/linux.html
@@ -0,0 +1,54 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Linux
+
Toutes les distributions de Linux, basé sur UNIX, utilisent le noyau Linux qui a été créé en 1991 par Linus Torvalds (essentiellement développé en langage C).
+ Voir pour plus de détails le Noyau Linux sur Wikipedia.
+
Ce qui change dans les distributions, c'est la facilité d'installation, les programmes fournis, la facilité de configuration, les architectures visées, ...
+
Voici une liste des distributions les plus célèbres :
+
+
Ubuntu
+
RedHat
+
Mandrake
+
SuSE
+
UnitedLinux (regroupement de SCO, SuSE, TurboLinux, Conectiva)
