Aller au contenu

Système - Fiche de révision CC1⚓︎

Cours

Langage compilé / interprété⚓︎

Type Fonctionnement
Compilé génère un exe
Interprété lis les instructions, les traduit à la volée et les exécute (bcp moins efficace qu'un langage compilé)

Cas particulier : Java

Compile en bytecode pour la VM qui sert d'interpréteur pour le micro-processeur de la machine.

TP1⚓︎

Filtres

Commandes capables de lire des données sur l'entrée standard et de produire des résultats sur la sortie standard.

grep -E "\w+[eu]t\w+" txt # (1)!

grep -E "[[:alpha:]]+[eu]t[[:alpha:]]+" nom_du_fichier # (2)!

grep -E "[^ ][eu]t[^ ]" txt # (3)!

find /usr/local -name "s*" -type d # (4)!

find tp1 -type f -perm -u=rw,g=r -exec chmod g-r {} \; # (5)!

find tp1 -type f -name "*.c" -exec grep -E "(^|[ =(])[xX][ =)>;]" {} \; # (6)!
  1. \w inclut les lettres et les chiffres, ce qui est parfait pour définir l'intérieur d'un "mot" en informatique.
  2. [[:alpha:]] remplace [a-zA-Z] et prend nativement en compte les caractères accentués (comme é, è, à, ç).
  3. [^ ]+ : signifie "au moins un caractère, à condition que ce ne soit pas un espace".

  4. Mettre le name entre GUILLEMETS.

    • -type d : directories
    • -type f : files

  5. -perm permet de préciser les permissions sur les fichiers trouvés.

    Ne pas oublier de laisser un espace puis \; pour le -exec.

  6. Mettre -E dès qu'on fait une regex avec des conditions ou des trucs compliqués (mode étendu).

    Là on a (^|[ =(]) : soit c'est le début, soit c'est parmi espace, égal, parenthèse. Le reste se lit normalement, plus de condition, c'est la suite.

TP2⚓︎

Sorties et entrées⚓︎

Flux Descripteur
stdin 0
stdout 1
stderr 2

Redirection de message⚓︎

Redirection Syntaxe Variante en concaténation
de l'entrée standard sur fichier commande < fic
de la sortie standard sur fichier commande > fic >> (pour ne pas écraser le contenu du fichier "log")
de la sortie erreur sur fichier commande 2> fic 2>>
de la sortie standard ET erreur commande >& fic >>&

Tube⚓︎

Entrée standard ≠ arguments !!

Le tube (pipe |) permet de rediriger la sortie standard d'une commande sur l'entrée standard d'une autre commande (il n'y a donc aucun sens à l'utiliser sur des commandes qui ne travaillent pas sur les E/S standards !).

Ex : chmod prend par exemple un nom de fichier/répertoire en argument (chmod u+x /test) MAIS rien en entrée standard, faire chmod u+x seul plante, contrairement à wc -l qui demande une saisie sur l'entrée standard.

Code de retour⚓︎

echo $? : permet d'afficher si la dernière commande a réussi (0) ou échoué (1).

Substitution de commande⚓︎

La substitution de commande (par le backquote) permet l'utilisation du résultat d'une commande dans une affectation ou en paramètre d'une autre commande. Ex :

echo `ls | wc -l`

Il devient donc possible de faire :

chmod u+x `pwd` # (1)!
  1. La substitution de commande `pwd` est évaluée en premier par le shell : elle capture la sortie standard de pwd et remplace l'expression par ce résultat sur la ligne de commande. Ce résultat est donc transmis à chmod comme argument (paramètre), ce qu'attendait la commande.

basename⚓︎

Terminal
evan:tp2 $ basename /usr/local/bin
bin
evan:tp2 $ basename /usr/local/bin.test
bin.test
evan:tp2 $ basename /usr/local/bin.test .test
bin
evan:tp2 $ basename /usr/local/bin.test est
bin.t
  • basename /usr/local/bin : garde le chemin vers le fichier
  • basename /usr/local/bin.test : garde le nom de fichier
  • basename /usr/local/bin.test .test : garde le nom de fichier sans l'extension précisée

TP3⚓︎

Variables spéciales⚓︎

Variable Signification
$0 nom du script
$# nombre de paramètres donnés à la fonction
$n (n > 0) c'est le n-ième paramètre (de 1 à n)
$* liste de tous les paramètres (pratique pour boucler dessus)
read var permet de lire sur l'entrée standard (clavier) et place la valeur dans la variable qui suit

Scripts⚓︎

Utilisateurs connectés à un terminal 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#! /bin/bash
if [ "$#" -eq 1  ] # vérifie qu'il n'y qu'un seul paramètre
then
        if [ -c "/dev/${1}" ] # vérifie que le fichier spécial de type caractère existe bien dans /dev
        then
                echo "Recherche en cours"
                term=$1
                nbConnected=`who | grep -E "^[a-zA-Z]+ +${term}" | wc -l`    # compter le nombre de ligne du who où un utilisateur est bien connecté au terminal donné en arg

                if [ $nbConnected -gt 0  ]   # tester si ce nombre est supérieur à 0 pour savoir s'il y a des gens connectés ou non
                then
                        suffix=""
                        if [ $nbConnected -gt 1 ]; then suffix="s"; fi   # vérifie s'il y a plusieurs personnes connectées pour afficher correctement les mots au pluriel
                        echo "${nbConnected} utilisateur${suffix} connecté${suffix} au terminal ${term}"
                else
                        echo "Aucun utilisateur connecté au terminal ${term}"
                fi
        else
                echo "Ce terminal n'existe pas abruti."
                exit 1  # signaler l'erreur
        fi
else
        echo "Apprends à compter connard, on a dit 1 paramètre : nom du terminal"
        exit 1  # signaler l'erreur
fi
Trouver l'exécutable d'une commande dans le PATH 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#! /bin/bash
if [ "$#" -eq 1  ] # vérifie qu'il n'y qu'un seul paramètre
then
        id=$1
        repertoires=`echo $PATH | tr ':' ' '`
        resDir=""

        for path in $repertoires
        do
                # -f vérifie que c'est bien un fichier (et pas un dossier)
                # -x vérifie qu'il est exécutable
                if [ -f "${path}/$id" -a  -x "${path}/$id" ]
                then
                        resDir=$path/$id
                        break # sortir de la boucle dès qu'on trouve le premier exécutable
                fi
        done

        if [ -n "$resDir" ] # -n vérifie que la chaîne de caractères n'est pas vide
        then
                echo $resDir
                exit 0
        else
                echo "Aucun exécutable pour la commande ${1} fournie."
                exit 1
        fi

else
        echo "La commande attend un seul paramètre : un identifiant de commande."
        exit 1
fi

expr⚓︎

expr

La commande expr permet d'évaluer une expression (qui peut mettre en jeu des variables) et écrit le résultat sur la sortie standard.

Exemple
$ i=12
$ expr $i + 30
42

Nombre aléatoire⚓︎

echo $((RANDOM % 101)) # (1)!
  1. Permet de récupérer un nombre aléatoire de 0 à 100 (0 à n-1).
Jeu du plus ou moins 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#! /bin/bash
target=$((RANDOM % 101))
guess=-1

while [ ! $guess -eq $target  ] # tant que la proposition n'est pas égale à la cible
do
        echo "Propose un nombre entre 0 et 100 : "; read guess; # demande une saisie

        if [ ! "`echo "$guess" | grep -E "^[0-9]+$"`" ] # si ce n'est pas un chiffre/nombre
        then
                echo "Renseigne un nombre stp"
                guess=-1 # toujours faux pour le test qui suit après le continue
                continue # recommence la boucle
        fi

        if [ $guess -gt $target ] # si la proposition est plus grande
        then
                echo "Trop grand."
        elif [ $guess -lt $target ] # si la proposition est trop petite. Pas de else car à ce stade on peut aussi avoir trouvé la bonne valeur
        then
                echo "Trop petit."
        fi

        # ici la valeur est trouvée, donc au prochain test du while, on sort
done

echo "Bravo tu as réussi un jeu pour enfant !"