1 Jour 1 : cours UNIX/Linux :

1
Jour 1 : cours UNIX/Linux :
Les systèmes d’exploitation SE (Operating System : OS) comme linux, macosX ou windows permettent la
gestion du matériel (communication via des appels système avec le processeur, la mémoire, les périphériques,
d’entrée/sortie) et la gestion des ressources (système multi-utilisateurs et multi-tâches, système de fichiers).
Le système UNIX est un système multi-utilisateurs et multi-tâches créé en 1969. Il a donné naissance à
différents systèmes de type UNIX comme macosX ou linux pour PC et pour des stations de travail IRIX pour
Silicon Graphics, Solaris pour SUN, etc. . . Pour les PC sous windows, il existe également un émulateur UNIX,
cygwin, qui permet d’avoir un UNIX sans avoir à partitionner le disque ni redémarrer la machine pour passer
de Windows à UNIX.
Différentes distribution Linux sont disponibles (Ubuntu, Mandriva, Suse. . .) gratuitement (GNU/Linux) ou
pas. Ces distribution ont toutes le noyau linux (kernel) écrit en C + des logiciels configurés autour de ce système
(outils GNU, système de fenêtrage, environnements graphiques Gnome, KDE. . .).
Le shell est un interpréteur de commande en mode texte qui est chargé de faire l’intermédiaire entre l’utilisateur et le SE. Il peut s’utiliser en mode interactif (jour 1 et 2) ou pour exécuter des commandes écrites dans
le langage de programmation du shell (sh, csh, bash, jour 3 et 4). L’interpréteur de commande est un processus
lancé lorsqu’on lance un terminal. Il interprète la signification de la ligne tapée par l’utilisateur, effectue des
requêtes au système et retourne le résultat. Il en existe plusieurs : sh (Bourne shell), bash (Bourne Again shell),
csh (C shell), tsch (Telnex C shell, , amélioration de csh avec notamment la complétion et l’édition de ligne
de commande ). . .Tous les shell ne sont pas forcément installés par défaut quand on installe une distribution
linux (case à cocher pour installer tcsh éventuellement). Il y a un shell par défaut pour les utilisateurs qui peut
être modifié (édition du fichier /etc/passwd ou préférences de l’application Terminal de macosX ou commande
chsh). On peut également changer de shell en tapant le nom du shell souhaité dans le terminal (exit pour quitter
ce shell). Nous allons travailler avec bash.
1.1
Les utilisateurs
Chaque utilisateur d’un système UNIX a besoin pour travailler d’un compte sur la machine. Chaque compte
est identifié par un nom d’accès ou login. A chaque login est associé un mot de passe qui sécurise l’accès au
système, un numéro d’utilisateur (UID), un emplacement sur le disque dur où l’utilisateur pourra stocker ses
fichiers (home directory) et un groupe d’utilisateurs. Il faut être administrateur sur la machine pour pouvoir
créer de nouveaux utilisateurs. Les utilisateurs sont soit définis localement (/etc/passwd) soit via un annuaire
partagé en réseau (NIS par exemple). Chaque fichier et chaque processus appartiennent à un utilisateur et un
groupe. Il existe un utilisateur particulier (root) qui correspond à un super-utilisateur qui possède tous les droits.
1.2
Les fichiers
Sous UNIX, tout est fichier. Tout ce qui permet de manipuler des données (flots d’octets) est fichier sous
UNIX : les fichiers ordinaires, les répertoires et les fichiers spéciaux (périphériques, les liens).
L’ensemble des fichiers d’un système UNIX est rangé dans un arbre. La racine de cet arbre est constituée d’un
répertoire nommé ’/’. Ce répertoire contient plusieurs répertoires, qui sont les branches maîtresses de l’arbre,
et quelques fichiers. Chacun de ces répertoires contient éventuellement d’autres répertoires et des fichiers, et
ainsi de suite. Parmi les répertoires présents dans la racine (/), certains sont retrouvés dans presque tous les
systèmes UNIX et contiennent à peu près toujours la même chose : etc contient des fichiers de paramètres
du système, var contient des informations sur le fonctionnement du système, bin contient les programmes de
base du système, usr contient une grosse partie du système, home contient les répertoires alloués a chaque
utilisateur, le répertoire local généralement situé dans le répertoire usr contient l’ensemble des programmes
spécifiques à une machine, etc.
UNIX est un système multi-utilisateur. Afin que les données de chacun soient à l’abri des autres utilisateurs,
chaque fichier appartient à un utilisateur précis (en général son créateur) et à un groupe d’utilisateurs. De plus,
à chaque fichier est attribué un ensemble de droits d’accès qui concernent :
– le propriétaire du fichier,
– le groupe à qui appartient le fichier,
– l’ensemble des utilisateurs de la machine.
Pour chacune de ces trois catégories correspond un droit de lecture, d’écriture et d’exécution.
– Le droit de lecture donne le droit de lire le fichier.
– Le droit d’écriture de le modifier, ou de l’effacer.
– Le droit d’exécution permet d’exécuter le fichier si celui-ci contient un programme. Le droit d’exécution
donné à un répertoire indique que l’on a le droit de le parcourir.
Ainsi, le plus souvent le propriétaire du fichier a les droits de lecture et d’écriture, voire au besoin d’exécution,
alors que le groupe à juste un droit de lecture et éventuellement d’exécution, ce qui permet de partager son
travail au sein d’une équipe. Enfin le reste des utilisateurs a soit des droits similaires au groupe soit aucun droit.
Ces droits peuvent être modifiés par le propriétaire du fichier grâce à la commande chmod.
Le nom + la localisation dans l’arborescence (path, chemin) d’un fichier permettent d’identifier un fichier.
Ainsi, deux fichiers peuvent porter le même nom et correspondre à deux fichiers différents si ils se situent bien
à des endroits différents dans l’arborescence. Pour le nom, le seul caractère interdit est ’/’ mais mieux vaut se
limiter aux lettres de l’alphabet (minuscules et majuscules), aux chiffres et _. En UNIX les majuscules et les
minuscules sont des caractères différents à part entière, aussi les noms TOTO, toto, Toto et ToTo sont tous
différents. Les noms de fichiers commençant par le signe ’.’ sont des fichiers cachés et correspondent le plus
souvent à des fichiers de configuration.
La dénomination d’un fichier peut contenir les indications sur la localisation de celui-ci dans l’arborescence.
Dans ce cas, le nom du fichier est précédé du chemin qui mène à lui. Chaque étape du chemin est séparée par
le signe ’/’. exemple : /etc/passwd indique le fichier passwd localisé dans le répertoire etc
– si le chemin commence, par un signe ’/’ :
– le chemin est dit absolu et le premier élément de celui-ci se trouve dans le répertoire racine. Dans l’exemple
ci-dessus, le répertoire etc est effectivement placé dans le répertoire racine.
– si le chemin ne commence pas par le signe ’/’ :
– Le chemin est dit relatif et le premier élément du chemin se trouve dans le répertoire courant (répertoire
d’où est lancée la commande qui utilise le nom de fichier).
– si le chemin commence par le signe ’∼’ :
– Le chemin est relatif à la maison de la personne exécutant la commande ou à la maison de l’utilisateur dont
le login figure juste après le ∼. Par exemple, l’utilisateur grincheu, a sa maison en /home/people/stage/grincheu,
pour cet utilisateur le fichier ∼/toto/tutu fera référence au fichier tutu localisé dans le répertoire
/home/people/stage/grincheu/toto. Un autre utilisateur pourra faire référence à ce même fichier en
tapant ∼grincheu/toto/tutu.
– le signe ’.’ dans le chemin indique le répertoire courant.
– le signe ’..’ dans le chemin indique le répertoire au-dessus.
1.3
Les processus (commande, application)
On peut définir rapidement un processus comme étant un ensemble de commandes travaillant sur un ensemble
de données. Chaque fois que vous lancez l’exécution d’un programme, un processus est créé avec l’ensemble des
instructions du programmes et une zone mémoire servant au stockage des données utiles au programme. Si
vous ou un autre utilisateur lance le même programme (ou un autre) un nouveau processus est créé et les deux
processus s’exécuteront indépendamment l’un de l’autre, en parallèle. A la fin de l’exécution du programme, le
processus est détruit et la place occupée en mémoire par celui-ci est libérée. Certains programmes peuvent provoquer lors de leur exécution la création de plusieurs processus afin d’effectuer plusieurs tâches simultanément.
Chaque processus est identifié par un numéro unique le PID. Toute action sur un processus se fait grâce à
l’indication de ce numéro.
Comme un fichiers, un processus a un utilisateur et un groupe propriétaires (UID, GID). Ils sont définis lors
du lancement du programme et correspondent généralement à la personne ayant lancé exécution du programme.
Ces valeurs déterminent les droits à un processus d’accéder à telle ou telle ressource de la machine et
particulièrement aux fichiers. Ainsi, un processus créé par un utilisateur n’aura le droit d’accéder au fichier que
suivant les droits correspondants à cet utilisateur.
De plus, le propriétaire d’un processus a le droit d’en arrêter l’exécution (root aussi).
Lors de l’exécution d’une commande, un processus est créé. Celui-ci va alors ouvrir trois flux :
– stdin, appelé entrée standard, dans lequel le processus va lire les données d’entrée. Par défaut, stdin
correspond au clavier ;
– stdout, appelé sortie standard, dans lequel le processus va écrire les données de sortie (le résultat de la
commande).
Par défaut, stdout correspond à l’écran ; stderr, appelé erreur standard, dans lequel le processus va écrire
les messages d’erreur. Par défaut, stderr correspond à l’écran.
Par défaut, lorsque l’on exécute une commande, les données sont donc lues à partir du clavier et sa sortie
et ses erreurs s’affichent sur l’écran, mais il est possible de lire les données à partir d’un fichier et d’envoyer la
sortie sur un fichier ou vers une autre commande, ... grâce aux redirections.
1.4
Les commandes UNIX de base
Syntaxe générale : commande [-options] [arguments]
pwd, ls [-sFla], cd, mkdir, cp [-r], mv, rm [-i], rmdir, cat, more, less, man, touch, echo,
ps, kill.
La commande man.
1.5
Redirection des entrées-sortie :
1.5.1
Redirections
bash
effet de la redirection
<
l’entrée standard est lu à partir d’un fichier
> ou 1>
La sortie standard est redirigée dans un fichier (RAZ du fichier)
>> ou 1 >>
La sortie standard est redirigée dans un fichier (concaténation à la
fin du fichier si il existe)
La sortie standard et les erreurs sont redirigées dans un fichier (RAZ
du fichier)
2>
Les erreurs sont redirigées dans un fichier (RAZ du fichier)
La sortie standard et les erreurs sont redirigées dans un fichier(concaténation)
Les erreurs sont redirigées dans un fichier(concaténation)
2 >>
1.5.2
Les pipes
proc1 |
équivaut
proc1 >
proc2 <
1.6
proc2
à
fichier
fichier
Les variables du shell et les variables d’environnement
On écrit en général les variables locales au shell courant en minuscules. Elles sont définies par var=<value>
en bash, et par la commande set var=<value> en csh ou tcsh. Les variables d’environnement héritées par les
shell et les processus fils sont écrites en majuscules et définies avec setenv en csh et export en bash .
Le contenu d’une variable est $var. Pour afficher le contenu d’une variable, il faut faire : echo $var
bash
contenu de la variable d’environnement
PWD
le chemin du répertoire courant
USER
login de l’utilisteur
TERM
type de terminal (fenêtre du shell)
HOME
le home directory
PATH
chemins de recherche pour l’exécution des commandes
SHELL
indique le shell courant
PS1
contenu du prompt
HISTSIZE
nombre de commandes gardées en mémoire et restituées par la commande history
TMOUT
temps de déconnexion automatique d’un shell (en seconde en bash,
en minutes en tcsh)
Affiche la liste des choix lorsque la complétion échoue (toujours le cas
dans bash)
1.7
*, @
1, 2, . . .
#
les arguments de la ligne de commande
(numérotées à partir de 1)
le nombre d’arguments
?
statut de la dernière commande exécutée (0 si elle s’est bien exécutée)
Communication :
ftp, ssh, scp : notion de client/serveur
1.8
Autres commandes UNIX
who, (e)grep [-v], wc [-lcw], head [-number],
tail [+ ou – number], tr s1 s2 [-d], tr -d
n < res,
tr ’
n’ ’ ’ < res, sort [-nr], ln [-s], tee pour écrire dans un fichier et sur la sortie standard, history, rappel
de la commande précédente avec !!, !n, !debut-de-mot, file (ascii (text), pictures, compressed data, etc), df,
du, gzip, tar.
1.9
Métacaractères UNIX
(’*’,’ ?’,’[a-z]’) : différences avec les expressions régulières (ces méta-caractères ne spécifient que les noms de
fichiers existants). Neutralisation des méta-caractères ou des espaces (les quotes simples ’ ou l’antislash \).
Génération des noms de fichiers :
* n’importe quelle chaîne de caractères
? n’importe quel caractère
[ ... ] l’intervalle décrit entre les crochets
1.10
TP :
11h-17 h :
Commandes de base : pwd, ls, cd, cat, mkdir, cp, mv, rm, man, touch, echo. Les options (ls -sFl, rm -i).
Les métacaractères du shell ls t*, ls t?to, ls [tp]*, tester avec ls la neutralisation des métacaractères
(cf. section 1.9).
ls -l voir les permissions, les changer (chmod, test de modification d’un dossier système protégé). Examen de la hiérarchie, création/délétion de répertoires et de fichiers. Utilisation de la complétion (sous tcsh
set autolist).
Le login
bash :
Lors d’un login interactif (c’est-à-dire qu’on entre des commandes, pas dans un script écrit), les fichiers
d’initialisation lus sont :
/etc/profile
~/.bash_profile, ~/.bash_login ou ~/.profile (le premier des trois lisibles est lu/exécuté)
~/.bash_logout lors du logout.
Lu lors de l’invocation de shell non interactifs (par exemple, scripts) ou lors du lancement d’un nouveau
shell :
$\sim$/.bashrc
Editeur de texte : nedit (différence avec traitement de texte). Lancer ou non en tâche de fond (processus
père, fils). Notions de processus : ps (voir les fils), ps -A (voir tous les process, en fait, à vérifier sur votre
machine, car le ps peut avoir un comportement différent au niveau option selon le système).
Edition du .profile. Création d’un alias : alias ll="ls -l".
Compression de fichier : compress, uncompress. (uncompress GMG.pep.Z), gzip (.gz)
1.10.1
Récupérer un fichier de séquences
1. Réseau : ftp sur ftp.pasteur.fr (nom : ftp ou anonymous, passwd : <votre email>). Aller dans pub/ regarder
les donnnées. Se mettre en binary (différence avec ASCII). Ramener un fichier de séquences si possible
(yeast) (sortie de ftp avec bye). Lien complet sur les dossiers de séquence des chromosomes de la levure :
ftp://ftp.pasteur.fr/pub/databases/yeast/archive/sequences/
Sinon, se connecter sur le ncbi via le web, et ramener un génome de bactérie (mycoplasma pneumoniae,
par exemple).
2. sur le net, sur http ://abiens.snv.jussieu.fr/OBI/OBI1/TP, récupérer le fichier GMG.pep
1.10.2
Utilisation de grep, egrep.
Sortir les titres du fichier de séquence (si fasta, egrep ">" fichier.fst). word Count (wc). Compter les
séquences. (egrep ">" fichier.fst | wc -l). Trier en ordre inverse (egrep ">" fichier.fst | sort -r).
Redirection : création d’un fichier des titres : (egrep ">" fichier.fst > fichier.names).
1.10.3
find
find, un outil puissant
/ -name bin -print find
/ -type f -name bin -print find
/ -type d -name bin -print
nestor$touch reste1 reste2 reste3 reste4
nestor$ ls reste*
reste1 reste2 reste3 reste4
nestor$ find . -name reste* -print
find: reste2: unknown option
nestor$ find . -name reste\* -print
./reste1
./reste2
./reste3
./reste3
nestor$ find . -name "reste*" -print
...
nestor$ find . -name ’reste*’ -print
...
nestor$ find / -name "reste*" -exec rm {} \; -print
1.10.4
Installation de wget
Aller chercher les sources du programme sur : http://ftp.gnu.org/gnu/wget/, (prendre latest ou la dernière version).
Extraire par tar xzvf wget-latest.tar.gz (explication du tar et de ses options)
Lire le README et le INSTALL,
Ensuite :
./configure --prefix=\$HOME
./make
./make install
Aller chercher le fichier nucleolar-IPI-719.txt sur le site http://abiens.snv.jussieu.fr/OBI/OBI1/TP.
Il contient des identifiants de la banque IPI (IPI International Protein Index)
http://www.ebi.ac.uk/cgi-bin/dbfetch?db=IPI&id=IPI00000001&format=fasta
Vu que la séquence contient des "scories" html, il faudra filtrer ce qui est séquence FASTA de ce qui est
html avec egrep.
2
Jour 2 - Programmation système Unix (sous csh, tcsh, quelques
différences avec le sh ou bash) :
Différence entre programmes compilés (s’adresse directement au processeur dans sa "langue", ex :cc), et
interprétés (interprété par le shell ou interpréteur (awk,perl) puis executé).
variables (alphanumériques, numériques), tableaux.
Programmation de scripts C-shell
L’exécution d’un script en shell (bash et tcsh)
bash nom_fichier
ou rendre le fichier exécutable (chmod u+x nom_fichier) puis taper le nom du fichier
Pour forcer l’exécution du fichier en C Shell, le fichier doit commencer par # !/bin/bash
bash -n nom_fichier
interprète les commandes sans les exécuter
bash -v nom_fichier
imprime les lignes comme elles sont lues
bash -x nom_fichier
imprime les lignes comme elles sont interprétées
désactive la génération de nom de fichiers en utilisant les métacaractères
bash -f nom_fichier
on peut mettre les options dans le shell courant avec set :
set -f set -o noglob empêche la génération de nom de fichiers en utilisant les métacaractères (dans ce
cas, rm * retirera un fichier * et pas tout ce qui se trouve dans le dossier courant).
set -v set -o verbose Prints shell input lines as they are read.
set -x set -o xtrace Print command traces before executing command.
echo $- permet de voir les options avec lequel le shell a été lancé.
Les variables
Un nom de variable ne peut commencer par un symbole numérique.
bash
tcsh
action
variable=valeur
set variable valeur
affectation (BASH : ATTENTION :PAS DE BLANCS)
$variable
$variable
valeur de la variable
${variable}
${variable}
valeur de la variable
$ ?variable
Renvoie 0 si la variable n’est pas initialisée, 1 sinon
Les opérateurs arithmétiques
En bash : ((EXPRESSION)) effectue une opération arithmétique.
La commande (( ))} évalue une expression arithmétique et donne un statut de sortie à 1 si l’expressi
permet également d’exécuter une ou plusieurs expressions arithmétiques. Elle est généralement utilisé pour assigner des valeurs aux variables de calcul.
Exemple :
a=$((1+2)) met la valeur 3 dans a
c=$((b=7+2)) met la valeur 9 dans b et le résultat dans c
La commande : let x=2 y=2**3 z=y*3;echo $? $x $y $z
donne le résultat suivant : 0 2 8 24
Si un nombre commence par 0x il sera traité comme un hexadécimal.
En tcsh, @var = exp assigne une valeur à une variable numérique
On peut aussi utiliser la syntaxe $[[EXPRESSION]] pour faire des tests plus naturel sur les chaînes de
caractères et les noms de fichier, et on peut combiner les tests, par exemple :
[[ ( -d "$HOME" ) && ( -w "$HOME" ) ]] && echo "home is a writable directory"
opérateurs
() , + , - , * , /
opérations arithmétiques classiques
%
reste
ˆ
ou exclusif bit à bit
˜
complément unaire
**
opérateur d’exponentiation
VAR++
post incrémentation
++VAR
pré incrémentation
VAR--
post décrémentation
--VAR
pré décrémentation
Les opérateurs booléens
==
comparaison
!=
diffèrent de
!
> ,<
,<=
>>
,>=
négation
comparaison
décalage à droite Exemple : @ a = ( $b >> 1 )
<<
décalage à gauche Exemple : @ a = ( $b << 1 )
&
Et bit à bit
|
Ou bit à bit
&&
Et logique
||
Ou logique
Les opérateurs d’affectation
=
affectation
+=
-=
x+=y équivaut à x = x + y
*=
x*=y équivaut à x = x * y
/=
x/=y équivaut à x = x / y
%=
x%=y équivaut à x = x % y
ˆ=
xˆ=y équivaut à x = x ˆ y
++
--
x++ équivaut à x = x + 1
x-=y équivaut à x = x - y
x-- équivaut à x = x - 1
Attention, les opération suivantes ne marchent pas : &=, |=,<<=,>>=
Arguments des scripts.
fonction exit (retourne le "status").
valeur de retour de la dernière commande :
bash : variable $ ? csh : variable "status"
export (bash) : pour transmettre une variable à un shell bash fils
export mavariable
(en csh : setenv permet de mettre une variable d’environnement qui sera héritée par les processus fils)
récupération des paramètres dans la ligne de commande
bash
tcsh
résultat
$#
$#
$n
ou
$argv[n]
indique le nombre d’arguments donnés au script
$n
équivaut à $argv[n] mais ne sortira jamais d’erreur out of range
$*
$*
$?
$?
liste des paramètres (en tcsh : équivaut à $argv)
a pour valeur le code de retour de la dernière commande exécutée dans le
shell
Quelques variables spéciales
bash
tcsh
read var
set var=$<
$$
$$
remplacé par la prochaine entrée courante (pour écrire des scripts
interactifs)
le numéro de processus du shell courant
Les caractères spéciaux
\
banalise le caractère suivant
"..."
banalise les caractères sauf \ , $ et `
’...’
banalise tous les caractères
`commande`
substitution de commande (bash : on peut utiliser $(commande)
préfixe pour les numéro de job (le numéro de job est indiqué lors du lancement d’une commande en background) Pour visualiser la liste des jobs : jobs
% num
echo a{b,c,d}e imprime à l’écran : abe ace ade
Les deux ordres suivant permettent d’imprimer le contenu de la variable a à l’écran :
echo $a
printf "$a\n"
2.0.5
variables alphanumériques (string) :
a="/usr/people/toto.txt"
echo ${a%.*} donne /usr/people/toto (sans extension)
la dernière occurence dans la variable $a du caractère qui suit le % donne le premier caractère de la suite
qui sera omise
echo ${a%o*} donne /usr/people/tot (et non pas /usr/people/t )
echo ${a#*/} remplace le préfixe le plus petit finissant par ’/’ par rien, donc donne usr/people/toto.txt
(note : echo ${a#/} aurait donné la même chose)
echo ${a##*/} remplace le préfixe le plus long finissant par ’/’ par rien donc donne toto.txt
(note : echo ${a#/usr/people/} aurait donné la même chose)
la dernière occurence dans la variable $a du caractère qui suit le % donne le premier caractère de la suite
qui sera omise
echo ${a:offset:length} donne la chaîne a de la position offset sur la longueur length (note : les string
commencent à zéro)
echo ${a:5} donne people/toto.txt (les string commencent à zéro)
echo ${a:5:6} donne people
echo ${a/toto/titi} donne /usr/people/titi.txt
echo ${a/t/v} donne /usr/people/viti.txt (remplacement 1ère occurrence)
echo ${a//t/v} donne /usr/people/vivi.txt (remplacement partout)
Mettre le résultat à l’écran d’une commande dans une variable (quotes d’exécution `` : `<commande>`) :
donne un ensemble (liste). Attention à la limitation du nombre d’éléments dans une liste (256 ?).
tableaux (listes), indices :
a = ( a b c d ) # on met une liste d’éléments dans la variable a
echo ${a[*]} donne tous les éléments du tableau a
En bash, echo ${a[0]} donne le 1er élément du tableau a
echo ${a[1]} donne le 2eme élément du tableau a
En bash, ${#a} donne le nombre de caractères d’une variable chaîne de caractère a
Le résultat d’une commande lancée par les quotes inverses donne une telle liste :
a=‘ls‘
echo $a[0];
2.0.6
Tests et boucles :
if : if TEST-COMMANDS; then COMMANDS; elif AUTRES-COMMANDES; else ENCORE-COMMANDES; fi
Tests :
D’abord : test expr} et [expr ] sont équivalents.
[ -a monfichier ] Vrai si monfichier existe
[ ! EXPR ] Vrai if EXPR est faux
[ EXPR1 -a EXPR2 ] a pour valeur EXPR1 et EXPR2
[ EXPR1 -o EXPR2 ] a pour valeur EXPR1 ou EXPR2
On peut comparer des valeurs arithmétiques en utilisant un des opérateurs suivants : -eq,-ne,-lt,-le,-gt, -ge,
ce qui signifie égal, différent, inférieur, inférieur ou égal, supérieur à, supérieur ou égal, respectivement.
On peut comparer des chaînes de caractères quand à leur égalité, inégalité, ou leur ordre alphabétique en
utilisant les opérateurs =, ! =, <, > respectivement. L’opérateur unaire -z}teste si une chaîne est vide,
tandis que -n}ou pas d’opérateur renvoie vrai si la chaîne n’est pas vide.
ıRemarque : attention les opérateurs <}et >}sont également utilisés par le shell pour la redirection, vous
devez donc leur enlever leur qualité de métacaractère par \< ou \>.
-d
-e
est un répertoire
-f
est un fichier régulier
-h
-p
est un lien symbolique (-L marche aussi)
-r
est lisible par vous
-w
est modifiable par vous
-s
est non vide
-S
est un socket
-N
a été modifié depuis la dernière lecture
existe (également-a)
est un pipe nommé
En plus des essais unaires ci-dessus, vous pouvez comparer deux fichiers avec les opérateurs binaires indiquées
ci-dessous
Test de paires de fichiers
-ot
Vrai si
Teste si fichier1 est plus récent que le fichier 2. La date
de modification est utilisé pour cela et la comparaison
suivante.
Teste si fichier1 est plus ancien que le fichier 2.
-ef
Teste si fichier1 est un lien dur vers fichier2.
-nt
boucles :
bash
csh
for i in <liste> ; do EXPRESSION ;done
foreach i (<ensemble ou tableau>) . . . end
while (<test>) . . . end,
goto label. . . "label :".
2.1
2.1.1
TP :
Les instructions
if, while, for, case...
if
if test-commandes ; then
suite_de_commandes1
else
suite_de_commandes2
fi
while
while read line; do echo -e "$line\n"; done < file.txt
La variable line contient la ligne courante, et c’est le fichier file.txt qui est pris comme entrée standard.
for : c’est un for in liste ou un for sur les arguments du script
for sur une liste :
- - - - - - - - - - - - - - - - for a in toto tata tutu
do
echo $a
done
- - - - - - - - - - - - - - - - for en utilisant la commande interne set
- - - - - - - - fichier essai_for_set - - - - - - - - #!/bin/bash
set $(date)
for i
do
echo $i
done
- - - - - - - - - - - - - - - - $ essai_for_set
dimanche
17
décembre
2006,
11:22:10
(UTC+0100)
$
set indique les arguments du script courant
break : arrête la boucle
continue : arrête l’itération courante de la boucle et commence la prochaine itération
case
for filename in $*; do
case $filename in
*.c )
objname=${filename%.c}.o
ccom $filename $objname ;;
*.s )
objname=${filename%.s}.o
as $filename $objname ;;
*.o ) ;;
*
)
print "error: $filename is not a source or object file."
return 1 ;;
esac
done
les tests
-e fichier
vrai si le fichier existe
-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
-d fichier
vrai si le fichier existe et est un répertoire
-z fichier
vrai si le fichier existe et a une taille non nulle
-o fichier
vrai si le fichier existe et nous appartient
divers
#
commentaire
(cmde)
exécute la commande dans un sous-shell
{cmde}
permet de savoir si une commande s’est bien passée (1) ou non (0)
cmd1 && cmd2
source script
séparateur conditionnel (cmd2 sera exécuté si cmd1 s’est exécuté correctement)
séparateur conditionnel (cmd2 sera exécuté si cmd1 ne s’est pas exécuté correctement)
exécution du script dans le shell courant
rehash
reconstruit la hash table de localisation des commandes
repeat n cmd
répète la commande n fois
cmd1 || cmd2
setenv/unsetenv positionne une variable d’environnement
time cmde
détermine le temps d’exécution de la commande
TP :
Utilisation de wget (ou curl, déjà installé sur Mac OSX) pour chercher des séquences IPI.
Sur le site TP d’OBI1, récupérer le fichier nucleolar-IPI-719.txt
#!/bin/bash
# proxy du cicrp
setenv http\_proxy 134.157.15.24:3128
# mieux que touch, car il faut écraser le fichier si il y a quelquechose dedans
echo -n "" > IPI.fst
while read line; do
echo $line;
curl "http://www.ebi.ac.uk/cgi-bin/dbfetch?db=IPI&id=$line&format=fasta&style=raw" | \
egrep ’(^>|^[A-Z])’ >> IPI.fst
done
Exercices suivants (utilisation de sort / uniq / join si possible) :
- Division d’un fichier fasta en un fichier par séquence
Utilisation de grep + wc dans un fichier fasta pour avoir le nombre de séquences
grep "^>" fichier_fasta.fst | wc -l
Idem mais pour avoir le nb de séquences uniques
grep "^>" fichier_fasta.fst | sort | uniq | wc -l
Chercher les entrées multiples dans un fichier fasta :
Lancer un blast avec chaque séquence d’un fasta multiple
Autres exercices possibles : Faire une récupération automatique d’un ensemble de d’image avec curl ou wget
Réduction de la taille de toutes les images trouvé par find dans un répertoire et ses sous dossiers Copier tous
les fichiers jpg d’une arborescence ailleurs en conservant l’arborescence Modifier les droits de plusieurs fichiers
dans une arborescence.