name: inverse layout: true class: center, middle, inverse --- # INFORMATIQUE 3 - CM8 ## Inès de Courchelle ## 2023-2024
--- layout: false # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. .underG[Les variables prédéfinies du shell] 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Prompt ## Définition - Invite de commande - Variable d'environnement PS1 ## Syntaxe de base L'invite par défaut contient donc \u@\h:\w\$ .pull-left[ | syntaxe | description | | --- | --- | | \u | nom de l'utilisateur | | \h | nom de la machine | | \w | le chemin de travail… où vous êtes | ] .pull-right[
]
## Où ? Dans ton .... .bashrc --- # Bashrc ## C'est quoi ? - Le fichier qui permet de lancer la configuration lors du lancement du terminal - Créer des alias - ... ## C'est où ? - Dans le home directory - C'est un fichier caché - On peut l'ouvrir sous emacs de la manière suivante : ```bash sudo emacs ~/.bashrc ``` ## Comment le recharger ? Si on a apporté des modifications au fichier on peut le recharger sans avoir à fermer le terminal .pull-left[ ```bash source ~/.bashrc ``` ] --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. .underG[Les processus] 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Les processus ## Définition - Ensemble d'instructions à exécuter - Hierarchisation des processus dans les commandes UNIX - Différents types - .under[Interactifs :] la plupart des processus s'exécutent en utilisant des E/S avec un utilisateur - .under[Non Interactifs :] certains processus gèrent en arrière plan des choses sans interaction (démons ## Cycle de vie
--- # Représentation ## Lire un processus dans le terminal
.pull-left[ | nom de la colonne | explication | | ---- | --- | | uid | Propriétaire du processus | | pid | Numéro du processus | | ppid | Père du processus | | C | Utilisation CPU | | stime | Temps où le processus à commencer | | tty | Terminal associé au processus | | time | Total de CPU utilisé | | cmd | Nom du processus | ] .pull-right[
] --- # Les processus ## Les commandes d'affichage #### Processus du prompt en cours ```bash ps ``` #### Processus du système en utilisant la syntaxe traditionnelle ```bash ps -ef ``` #### Processus du système en utilisant la syntaxe BSD ```bash ps -ax ``` --- # Les processus ## Les commandes d'affichage #### Arborescence des processus ```bash ps -ejH ``` #### Processus apartement à l'utilisateur ```bash ps -aux ps -x -u
``` --- # Rechercher un processus ## Comment ? - avec un pipe - avec la commande grep ## C-à-d #### La commande ```bash ps -ef | grep nomduprocessus ``` #### Exemple ```bash ps -ef | grep teams ``` --- # Tuer un processus ## Pourquoi ? .pull-left[ - Par exemple firefox plante impossible de le fermer ou de le redémarrer - Parce que ... ] .pull-right[
] ## Comment ? #### solution 1 ```bash kill
``` #### solution 2 ```bash killall
``` --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. .underG[Les modes d'exécution des processus] 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Mode d'exécution ## 2 types d'exécution - foreground - background ## Foreground - processus qui bloque l'invite de commande - on doit attendre que le processus soit fini pour en démarrer un autre ## Background - processus qui ne bloque PAS l'invite de commande - on peut lancer d'autre processus en paralléle
--- # Mais comment ? ## Exemple
.underR[Le mieux c'est de le tester soit même]
--- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. .underG[Langages scripts] 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Langages scripts ## Définition - Langage de programmation interprété (pas besoin de compiler) - Exemple : Script Shell (sh,bash, ksh ...), JavasCript, VBA, PowerShell ... ## Script Shell - Enchaîner des commandes Unix - Automatiser une série d'opérations - Interprêter des commandes --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. .underG[Différence entre bash et shell] 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Différence entre bash et shell .pull-left[ ## sh - Bourne Shell (SHell) - le plus simple ] .pull-right[ ## Bash - Bourne Again Shell - Amélioration du bourne Shell disponible par défaut sous linux et Mac OX ]
- Tout ce que je peux faire en Sh je peux le faire en bash - Bash a plus de fonctionnalités --- # L'exécution ## monScript.sh #### Solution 1 ```bash ./monScript.sh ``` .underR[Attention : ] il faut rajouter les droits d'exécution au fichier (chmod +x monScript.sh) #### Solution 2 ```bash sh monSript.sh ``` #### Solution 3 ```bash bash monSript.sh ``` --- # Mon premier script ## Le fichier
## Le contenu ```bash # C'est un super commentaire echo "coucou" # ici j'affiche la chaîne de caractère coucou ``` .underR[Attention : ] - Il n'y a pas de ; - Il faut respecter les tabulations (comme en python) --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. .underG[Les variables] 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Les variables ## Stocker une chaine ```bash maChaine="coucou" ``` ## Stocker un entier ```bash monEntier="coucou" ``` ## Stocker le résultat d'une commande ```bash maCommande=`ls -l` ``` .underR[Attention] Pour utiliser une variable il faut utiliser le $ --- # Les variables ## Exemple .pull-left[ ```bash maChaine="coucou" echo $maChaine monEntier=4 echo $monEntier maCommande=`ls -l` echo $maCommande ``` ] .pull-right[
]
--- # Les variables ## Additionner des entiers ```bash a=4 b=5 echo "solution1 : " $(($a+$b)) let "c=$a+$b" echo "solution 2 : " $c ``` .underR[Attention] : pour utiliser **let**, il faut obligatoirement utiliser la compilation *./script.sh* .pull-left[
] .pull-right[ Les différentes opérations : - addition : + - soustraction : - - multiplication : * - division euclidienne : / - reste : % - puissance : ** ] --- # Les variables ## Lire une entrée utilisateur au clavier .pull-left[ ```bash read x echo "l'utilisateur a rentré $x" ```
] .pull-right[
] --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. .underG[Les chaînes de caractères] 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Les chaînes de caractères .pull-left[ ```bash ls -l ``` ```bash ls -l | wc -l ``` ```bash echo "ls -l | wc -l" ``` ```bash echo 'ls -l | wc -l' ``` ```bash echo `ls -l | wc -l` ``` ] .pull-right[
] - doubles quotes : Appelées aussi quote-quote - simples quotes : Appelées aussi quote - back quotes : combinaisons touches : altGr + 7 .underR[Attention] - Notez bien la différence qui existe entre les quotes - Utile pour mixer des commandes dans d'autres --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. .underG[Les commandes] 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Les commandes ## Les mêmes - La base .arrow[] ls cat ls du cp mv mkdir rm rmdir chmod touch pwd - Les sorties .arrow[] echo head tail wc source pipe - Les fichiers .arrow[] grep find --exec sort cut ssh scp who - Jobs .arrow[] bg fg jobs
--- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. .underG[Structures de contrôle] 10. Les tableaux 11. Les arguments 12. Les tests ] .pull-right[
] --- # Structures de contrôle ## Avec des SI ... #### La classique ```bash if condition then ... fi ``` #### La complète ```bash if condition then ... else ... fi ``` --- # Structures de contrôle ## Avec des SI ... #### La surprise du chef ```bash if condition1 then ... elif condition2 then ... else ... fi ``` .underR[Attention :] il faut bien utiliser les tabulations à l'intérieur des si
--- # Structures de contrôle ## Les conditions #### Pour les entiers | ecriture | signification | équivalence en C | |---------------|---------------------------|------------------| | [ $x -eq $y ] | $x equal to $y | x==y | | [ $x -ne $y ] | $x not equal $y | x!=y | | [ $x -lt $y ] | $x lower than $y | x
y | | [ $x -ge $y ] | $x greater or equal to $y | x>=y | .underR[Attention] - ne pas oublier les crochets - mettre un espace avant et après les crochets --- # Structures de contrôle ## Exemple .pull-left[ ```bash read x echo "l'utilisateur a rentré $x" read y echo "l'utilisateur a rentré $y" if [ $x -lt $y ] then echo "$x est plus petit que $y" else echo "$x est plus grand que $y" fi ``` ] .pull-right[
] --- # Structures de contrôle ## Les boucles #### La While Do Done ```bash i=0 while [ $i -lt 5 ] # tant que i lower than 5 (i<5) do echo "coucou" # pour afficher coucou let "i++" # pour incrémenter i done ``` #### Until Do done ```bash j=0 until [ $j -eq 5 ] # jusqu'à que j equal to 5 (i==5) do echo "coucou" let "j++" done ``` --- # Structures de contrôle ## Les boucles #### Pour afficher successivement le nom de fichier présent dans le répertoire courant .pull-left[ ```bash for fic in * do echo $fic done ``` ] .pull-right[
]
#### Pour i dans un intervalle .pull-left[ ```bash for i in {1..10} do echo $i done ``` ] .pull-right[
] --- # Structures de contrôle ## Case ```bash var="hello" case $var in h) echo "1" ;; # traitement si var=a ell|lo) echo "2" ;; # traitement si var = "b" ou "c" h*) echo "3" ;;# traitement si $var commence par "d";; *) echo "null" ;; # traitement par défaut;; esac ```
.underR[Attention] - ne pas oublier les doubles ;; à la fin d'un cas - on peut enchaîner plusieurs commandes dans chaque cas --- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. .underG[Les tableaux] 11. Les arguments 12. Les tests ] .pull-right[
] --- # Les tableaux ## Définition
## Manipulation #### Création ```bash montab=( "case1" "case2" "case3" ) ``` #### Affichage ```bash for case in ${montab[*]} do ... done ``` --- # Les tableaux ## Définition
## Manipulation #### Modification ```bash montab[0]="nouvelle valeur" ```
--- # Les tableaux ## Exemple ```bash montab=( "led" 666 "pj" 42 ) for case in ${montab[*]} do echo "case : $case" done echo " montab : ${montab[*]}" echo " case 0 : ${montab[0]} montab[0]="zep" echo " case 0 : ${montab[0]}" ```
--- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. .underG[Les arguments] 12. Les tests ] .pull-right[
] --- # Les arguments ## Définition - Envoyer des paramètres à l'appel du programme - Utiliser pour ne pas avoir à entrer des valeurs dûr dans le programme ## Exemple **Vous l'avez déjà fait** #### Compter le nombre de ligne d'un fichier ```bash wc -l monFichier.csv ``` .underG[wc -l c'est la commande et monFichier.csv est le paramètre] #### Afficher le contenu d'un fichier ```bash cat monFichier.csv ``` .underG[cat c'est la commande et monFichier.csv est le paramètre] --- # Les arguments ## Exemple ```bash for i in $(seq 0 $#) do echo "le parametre numero $i est ${!i}" done ``` ## Résultat
--- # Variables prédéfinies ## Nota Bene - $0 .arrow[] contient le nom du programme en cours - $1..$9 .arrow[] contiennent les différentes valeurs des arguments/paramètres - $# .arrow[] contient le nombre de paramètres/arguments - $* .arrow[] contient une liste de l’ensemble des paramètres/arguments - $? .arrow[] contient l’état de sortie de la dernière commande. Si la commande s’est bien passée, alors elle renvoie 0, sinon une valeur différente de zéro. - $$ .arrow[] contient le numéro du processus en cours
--- # Les Jobs et Les scripts ## Plan .pull-left[ 1. Les variables prédéfinies du shell 2. Les processus 3. Les modes d'exécution des processus 4. Langages scripts 5. Différence entre bash et shell 6. Les variables 7. Les chaînes de caractères 8. Les commandes 9. Structures de contrôle 10. Les tableaux 11. Les arguments 12. .underG[Les tests] ] .pull-right[
] --- # Les tests ## Exemples #### Vérifier si c'est un exécutable ```bash maVar="algo.c" if [ -x $maVar ] then echo "$maVar est un executable" else echo "$maVar n'est pas un executable" fi ```
.underR[Attention : ] - Un exécutable est un fichier ayant les droits x pour tout les types d'utilisateurs - Pour ajouter l'exécutabilité d'un fichier, il faut lancer la commande .underB[] --- # Les tests ## Exemples #### Vérifier si c'est un répertoire ```bash maVar="monDossier" if [ ! -d $maVar ] then echo "$maVar n'est pas un dossier" else echo "$maVar est un dossier" fi ```
--- # Les tests ## Exemples #### Arrêter le programme ```bash maVar="monDossier" if [ ! -d $maVar ] then echo "$maVar n'est pas un dossier je pars" exit 1 fi echo "Moi je reste et je continue" echo "... traitement divers ..." exit 0 ```
--- # Les tests ## Exemples #### Le exit et etat de sortie En tapant dans le terminal .underB[echo $?] on peut vérifier l'état de sortie du programme - 0 si tout c'est bien passé - Valeur différente de zéro si un problème ```bash maVar="monDossier" if [ ! -d $maVar ] then echo "$maVar n'est pas un dossier je pars" exit 666 fi echo "Moi je reste et je continue" echo "... traitement divers ..." exit 0 ``` --- # Les tests ## Exemples #### Le exit et etat de sortie ```bash maVar="monDossier" if [ ! -d $maVar ] then echo "$maVar n'est pas un dossier je pars" exit 666 fi echo "Moi je reste et je continue" echo "... traitement divers ..." exit 0 ```