informatique:linux:programmation_shell
Differences
This shows you the differences between two versions of the page.
Both sides previous revisionPrevious revisionNext revision | Previous revisionNext revisionBoth sides next revision | ||
informatique:linux:programmation_shell [2015/08/28 09:51] – [en vrac] pteu | informatique:linux:programmation_shell [2022/10/17 21:30] – [trim (suppression des espaces dans une chaîne)] pteu | ||
---|---|---|---|
Line 1: | Line 1: | ||
- | {{tag> | ||
- | ====== Programmation Shell ======= | + | ======Programmation Shell======= |
+ | {{ : | ||
+ | |||
+ | Les différents shells peuvent avoir des fonctions sensiblement différentes voir incompatibles. Ce n'est pas le cas pour la majorité d' | ||
+ | |||
+ | Pour afficher la liste des options de bash il faut saisir '' | ||
+ | |||
+ | Les mots d'une ligne suivants un ''#'' | ||
* '' | * '' | ||
- | * '' | + | * '' |
<code bash> | <code bash> | ||
$ touch toto | $ touch toto | ||
Line 14: | Line 20: | ||
- | =====Les variables===== | + | ======Les variables====== |
En bash, chaque variable est précédée de '' | En bash, chaque variable est précédée de '' | ||
- | < | + | < |
NOM=" | NOM=" | ||
echo " | echo " | ||
</ | </ | ||
+ | On peut les manipuler sans les déclarer proprement au préalable ; mais on peut être clean et les définir ('' | ||
- | * '' | + | Pour déclarer une variable non modifiable = en readonly (une constante) : |
- | * '' | + | <code bash> |
+ | readonly CONST=" | ||
+ | # ou | ||
+ | declare -r CONST=" | ||
+ | </ | ||
+ | |||
+ | Par défaut une variable est globale et est vue dans le script (y compris ses fonctions) ; dans une fonction on peut déclarer des variables locales afin d' | ||
+ | <code bash> | ||
+ | local VAR=" | ||
+ | </ | ||
+ | <WRAP center round important 60%> | ||
+ | Les variables déclarées dans une fonction ont toujours une portée locale (elles sont détruites à la fin de la fonction), à moins qu' | ||
+ | </ | ||
+ | |||
+ | |||
+ | Pour déclarer une constante locale à une fonction : | ||
+ | <code bash> | ||
+ | local -r CONST=" | ||
+ | |||
+ | # ou en 2 lignes | ||
+ | local CONST=" | ||
+ | readonly CONST | ||
+ | |||
+ | # marche aussi, puisque lorsque declare est invoqué dans une fonction, | ||
+ | # la variable qui suit est déclarée localement | ||
+ | function test() { | ||
+ | declare -r CONST=" | ||
+ | } | ||
+ | </ | ||
+ | C'est assez touffu je suis d' | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | ===== Tests de définition===== | ||
+ | |||
+ | Pour tester si une variable est non définie : '' | ||
+ | <code bash> | ||
+ | unset VAR | ||
+ | ${VAR?var non def} # -bash: VAR: variable non def (sur stderr) | ||
+ | declare VAR | ||
+ | ${VAR?var non def} # -bash: VAR: variable non def (sur stderr) | ||
+ | VAR= | ||
+ | ${VAR?var non def} # (rien car VAR est définie) | ||
+ | ${VAR:? | ||
+ | </ | ||
+ | |||
+ | Pour utiliser une valeur par défaut au cas ou la variable n'est pas définie : '' | ||
+ | <code bash> | ||
+ | declare VAR | ||
+ | echo ${VAR-defaut} | ||
+ | echo ${VAR: | ||
+ | |||
+ | unset VAR | ||
+ | echo ${VAR-defaut} | ||
+ | echo ${VAR: | ||
+ | </ | ||
+ | |||
+ | Cela ne définit ni n' | ||
+ | <code bash> | ||
+ | declare VAR | ||
+ | echo ${VAR=defaut} | ||
+ | echo ${VAR: | ||
+ | </ | ||
+ | |||
+ | =====Typage===== | ||
+ | |||
+ | Il n'y a pas de typage strict en bash, toutes les variables sont considérées comme des chaînes de caractères, | ||
+ | |||
+ | Pour " | ||
+ | <code bash> | ||
+ | is_ready=true | ||
+ | if [ " | ||
+ | then echo " | ||
+ | else echo " | ||
+ | fi | ||
+ | </ | ||
+ | |||
+ | Pour plus de détails sur le pseudo-typage en bash, voir la fonction [[informatique: | ||
+ | |||
+ | ===== Manipulation des variables===== | ||
+ | |||
+ | | ||
+ | * '' | ||
<code bash> | <code bash> | ||
scp user@server:/ | scp user@server:/ | ||
</ | </ | ||
- | Sans les '' | + | Sans les '' |
+ | * on peut tronquer une variable : '' | ||
+ | * '' | ||
+ | * Si on omet POS : '' | ||
+ | <code bash> | ||
+ | VAR=undeuxtroisquatre | ||
+ | echo ${VAR: | ||
+ | echo ${VAR: | ||
+ | echo ${VAR: | ||
+ | echo ${VAR:: | ||
+ | echo ${VAR:: | ||
+ | </ | ||
+ | |||
+ | On peut utiliser des motifs (qui en ont l' | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * On peut limiter le remplacement aux seuls préfixe '' | ||
+ | <code bash> | ||
+ | VAR=undeuxtroisquatre | ||
+ | echo ${VAR# | ||
+ | echo ${VAR## | ||
+ | echo ${VAR%u*e} | ||
+ | echo ${VAR/ | ||
+ | echo ${VAR// | ||
+ | echo ${VAR/# | ||
+ | echo ${VAR/ | ||
+ | </ | ||
+ | |||
+ | Exemple usuels : | ||
+ | * sélectionner l' | ||
+ | * sélectionner le nom d'un fichier sans son extension : '' | ||
+ | * supprimer le dernier caractère de la variable (trim) : '' | ||
+ | |||
+ | source : https:// | ||
- | ====Variables spécifiques==== | + | =====Variables spécifiques===== |
Ce sont des variables liées au contexte du script. | Ce sont des variables liées au contexte du script. | ||
- | * '' | + | * '' |
* '' | * '' | ||
* '' | * '' | ||
Line 41: | Line 166: | ||
* '' | * '' | ||
* '' | * '' | ||
+ | * '' | ||
* '' | * '' | ||
+ | * '' | ||
- | ====Les tableaux==== | ||
- | Les enregistrements commencent à l' | + | =====Les tableaux===== |
- | | + | Les enregistrements commencent à l' |
- | * '' | + | |
- | * '' | + | * '' |
- | * '' | + | |
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
+ | * '' | ||
Comme pour les variables classiques, on peut récupérer la longueur en le précèdent de ''#'' | Comme pour les variables classiques, on peut récupérer la longueur en le précèdent de ''#'' | ||
* longueur de la 3e case : '' | * longueur de la 3e case : '' | ||
- | * taille du tableau (nombre de case de celui-ci) : '' | + | * taille du tableau (nombre de case de celui-ci) : '' |
+ | Pour parcourir facilement un tableau dans une boucle : | ||
+ | <code bash> | ||
+ | ARRAY=( un deux trois ) | ||
+ | for i in " | ||
+ | un | ||
+ | deux | ||
+ | trois | ||
+ | </ | ||
- | =====Les fonctions===== | + | Exemple de découpage d'une chaîne dans un tableau, avec comme séparateur ";" |
+ | <code bash> | ||
+ | CHAINE='17;8 23; | ||
+ | IFS=";" | ||
+ | read -a TAB <<<" | ||
+ | echo " | ||
+ | 3 | ||
+ | printf ' | ||
+ | 17 | ||
+ | 8 23 | ||
+ | 9 | ||
+ | </ | ||
- | ==== read ==== | + | ====Tableau à 2 dimensions==== |
- | '' | + | Ça n'eût pas existé sous bash :). Mais on peut l'émuler en créant un tableau associatif (qui, à une clé fait correspondre un contenu), en codant la clé pour émuler 2 dimensions. Exemple : pour émuler un tableau de 2 x 3 cases : |
+ | <code bash> | ||
+ | # déclaration d'un tableau associatif T | ||
+ | declare -A T | ||
+ | # remplissage clé => valeur, par exemple la clé " | ||
+ | # c'est un tableau | ||
+ | T[0: | ||
+ | T[0: | ||
+ | T[1: | ||
+ | T[1: | ||
+ | T[2: | ||
+ | T[2: | ||
- | Pour afficher un texte avant la saisie | + | # calcul de l' |
- | <code> | + | T_SIZE=$((${# |
- | read -p "Quel est le nombre indique sur votre CB ? Et le cryptogramme visuel de derriere ?" | + | |
+ | # en forgeant | ||
+ | for ((i=0;i<=T_SIZE; | ||
+ | echo "ligne=$i ; case0=${T[$i: | ||
+ | done | ||
</ | </ | ||
+ | ====Tableau associatif==== | ||
- | ===== Expressions arithmétiques ===== | + | Créer et utiliser un vrai tableau associatif : |
+ | <code bash> | ||
+ | declare -A TA=([cle1]=valeur1 ["cle 2" | ||
+ | echo " | ||
+ | # valeur1 | ||
+ | |||
+ | # Parcourir le tableau | ||
+ | for cle in " | ||
+ | echo " | ||
+ | done | ||
+ | #cle=cle 2 ; val=valeur 2 | ||
+ | #cle=cle3 ; val=valeur3 | ||
+ | #cle=cle1 ; val=valeur1 | ||
+ | </ | ||
+ | |||
+ | Pour connaitre la taille de ce tableau : '' | ||
+ | =====getopts : analyse des arguments d'un script===== | ||
+ | |||
+ | Cette commande permet de récupérer facilement les options (paramètres) avec lesquels a été lancé un script. Une option est un caractère précédé d'un + ou d'un - (à la différence d'un argument qui est " | ||
+ | Exemple d' | ||
+ | <code bash> | ||
+ | while getopts " | ||
+ | do | ||
+ | echo " | ||
+ | case $opt in | ||
+ | a) | ||
+ | echo "-a trouvée !" | ||
+ | echo " | ||
+ | ;; | ||
+ | b) | ||
+ | echo "-b trouvée ! son paramètre est : $OPTARG" | ||
+ | echo " | ||
+ | ;; | ||
+ | esac | ||
+ | done | ||
+ | </ | ||
+ | * $opt est le nom (arbitraire) de la variable recevant la valeur de l' | ||
+ | * ":" | ||
+ | * OPTIND est la variable réservée qui contient l' | ||
+ | * OPTARG est la variable réservée qui contient l' | ||
+ | |||
+ | La même option peut apparaitre plusieurs fois sans générer d' | ||
+ | Une option non attendue génèrera une erreur (non bloquante) et prendra la valeur "?" | ||
+ | Une option nécessitant un argument non présent génèrera aussi une erreur non bloquante, mais prendra la valeur ":" | ||
+ | |||
+ | On peut choisir de traiter les erreurs dans le script en préfixant la liste des options par un ":" | ||
+ | * dans le cas d'une option non attendue : | ||
+ | * $opt prend la valeur "?" | ||
+ | * $OPTARG prendra le nom de l' | ||
+ | * dans le cas d'une option nécessitant un argument non présent : | ||
+ | * $opt prendra la valeur ":" | ||
+ | * $OPTARG prend la valeur de l' | ||
+ | |||
+ | Reprise de l' | ||
+ | <code bash> | ||
+ | echo "### Liste des arguments = $*" | ||
+ | while getopts ": | ||
+ | do | ||
+ | echo " | ||
+ | case $opt in | ||
+ | a) | ||
+ | echo "-a trouvée !" | ||
+ | echo " | ||
+ | ;; | ||
+ | b) | ||
+ | echo "-b trouvée ! son paramètre est : $OPTARG" | ||
+ | echo " | ||
+ | ;; | ||
+ | c) | ||
+ | echo "-c trouvée ! son paramètre est : $OPTARG" | ||
+ | echo " | ||
+ | ;; | ||
+ | \?) # on doit échapper "?" | ||
+ | echo " | ||
+ | ;; | ||
+ | :) # ceci n'est pas un smiley | ||
+ | echo " | ||
+ | ;; | ||
+ | esac | ||
+ | done | ||
+ | </ | ||
+ | |||
+ | Pour récupérer les éventuels arguments restants, on utilise la commande '' | ||
+ | <code bash> | ||
+ | shift $(($OPTIND-1)) # on supprime les options déjà traitées | ||
+ | |||
+ | echo "### Liste des arguments restants : $*" | ||
+ | while [ -n " | ||
+ | do | ||
+ | echo " | ||
+ | shift 1 | ||
+ | done | ||
+ | </ | ||
+ | |||
+ | |||
+ | ======Descripteurs de fichier====== | ||
+ | |||
+ | Il existe 3 descripteurs de fichier standards, utilisés par toutes les commandes : 0, 1 et 2 correspondants à STDIN, STDOUT et STDERR (input, output et erreur). 0 pointe par défaut sur le clavier, 1 et 2 sont affichés par défaut à l' | ||
+ | |||
+ | Pour lire depuis un fichier plutôt que depuis le clavier : | ||
+ | <code bash> | ||
+ | echo toto > / | ||
+ | read VAR < / | ||
+ | echo $VAR | ||
+ | | ||
+ | </ | ||
+ | |||
+ | ====Les redirecteurs==== | ||
+ | |||
+ | * ''>'' | ||
+ | * ''< | ||
+ | * ''&> | ||
+ | * ''<'' | ||
+ | |||
+ | Ces redirecteurs sont restaurés à leur valeur par défaut à chaque nouvelle ligne ; en revanche tous les processus fils héritent des descripteurs de leur processus père, à moins que celui-ci ne les ferme (voir plus bas). | ||
+ | |||
+ | '' | ||
+ | |||
+ | Pour rediriger le flux d' | ||
+ | <code bash> | ||
+ | ./prog 2>/ | ||
+ | </ | ||
+ | |||
+ | Pour rediriger le flux d' | ||
+ | <code bash> | ||
+ | ./prog 2>&1 | ./ | ||
+ | # équivaut à | ||
+ | ./prog |& ./prog2 | ||
+ | # (depuis bash4, " | ||
+ | </ | ||
+ | |||
+ | |||
+ | Par défaut ''>'' | ||
+ | <code bash> | ||
+ | ./prog 2>>/ | ||
+ | </ | ||
+ | Ainsi on conserve les erreurs de chaque exécution du programme. | ||
+ | |||
+ | ====Heredoc==== | ||
+ | |||
+ | Un document " | ||
+ | <code bash> | ||
+ | cat << EOF | ||
+ | Ce | ||
+ | sera affiché tel quel | ||
+ | EOF | ||
+ | |||
+ | </ | ||
+ | |||
+ | On peut utiliser la variante ''< | ||
+ | |||
+ | ====Herestring==== | ||
+ | |||
+ | Dans la même veine que le heredoc, la herestring permet d' | ||
+ | <code bash> | ||
+ | VAR=" | ||
+ | cat <<< | ||
+ | dad text | ||
+ | |||
+ | bc <<< | ||
+ | 4 | ||
+ | </ | ||
+ | ====Descripteurs de fichier additionnels==== | ||
+ | |||
+ | On peut utiliser les descripteurs 3 et plus également, en les initialisant pour ne pas générer d' | ||
+ | <code bash> | ||
+ | echo " | ||
+ | echo " | ||
+ | | ||
+ | </ | ||
+ | |||
+ | Pour fermer un descripteur de fichier (le 3 par ex) : '' | ||
+ | |||
+ | On peut faire pointer un descripteur vers un fichier du système : | ||
+ | <code bash> | ||
+ | exec 3<> / | ||
+ | echo toto >& | ||
+ | exec 3>& | ||
+ | </ | ||
+ | |||
+ | Exemple d' | ||
+ | <code bash> | ||
+ | # An application of this is writing at a specified place in a file. | ||
+ | echo 1234567890 > File # Write string to " | ||
+ | exec 3<> File # Open " | ||
+ | read -n 4 <& | ||
+ | echo -n . >& | ||
+ | exec 3>& | ||
+ | cat File # ==> 1234.67890 | ||
+ | </ | ||
+ | |||
+ | ======Les fonctions====== | ||
+ | |||
+ | =====function===== | ||
+ | |||
+ | Elles permettent de mutualiser le code afin qu'il soit appeler plusieurs fois sans avoir à le ré-écrire. | ||
+ | <code bash> | ||
+ | function mafonction() { | ||
+ | echo " | ||
+ | } | ||
+ | |||
+ | # appelle de la fonction, plus bas dans le code | ||
+ | mafonction | ||
+ | </ | ||
+ | A l' | ||
+ | |||
+ | La variable bash '' | ||
+ | |||
+ | =====pipe (" | ||
+ | |||
+ | Le pipe (tube) est une fonction qui permet de chainer la sortie d'une première commande sur l' | ||
+ | <code bash> | ||
+ | echo "toto et tata" | awk ' | ||
+ | | ||
+ | </ | ||
+ | |||
+ | Le soucis c'est qu'on ne récupère que le code de retour de la dernière commande du pipe ; et dans l' | ||
+ | * récupérer les codes de retour de chaque commande dans le tableau '' | ||
+ | <code bash> | ||
+ | false | true | ||
+ | echo " | ||
+ | 1 0 | ||
+ | </ | ||
+ | * utiliser la variable '' | ||
+ | <code bash> | ||
+ | $ false | true; echo $? | ||
+ | 0 | ||
+ | $ set -o pipefail | ||
+ | $ false | true; echo $? | ||
+ | 1 | ||
+ | </ | ||
+ | ===== read ===== | ||
+ | |||
+ | '' | ||
+ | |||
+ | Si aucune variable n'est précisée, la saisie sera enregistrée dans la variable $REPLY par défaut. | ||
+ | |||
+ | Pour afficher un texte avant la saisie on utilise '' | ||
+ | <code bash> | ||
+ | read -p "Quel est le numéro de ta CB ? Et le cryptogramme visuel de derrière ?" CARD_NUMBER CRYPTO | ||
+ | </ | ||
+ | |||
+ | Pour lire depuis un fichier : | ||
+ | <code bash> | ||
+ | read < fichier.txt | ||
+ | |||
+ | # c'est plutôt utilisé dans une boucle while, pour le lire ligne par ligne : | ||
+ | while read line; do | ||
+ | echo $line | ||
+ | done < fichier.txt | ||
+ | </ | ||
+ | |||
+ | Pour lire depuis une liste de fichiers : | ||
+ | <code bash> | ||
+ | while read line; do | ||
+ | echo $line | ||
+ | done < <(find . -name foo* -print0) | ||
+ | |||
+ | # équivalent à : | ||
+ | find . -name foo* -print0 | while read line; do | ||
+ | echo $line | ||
+ | done | ||
+ | </ | ||
+ | Le premier exemple utilise une [[https:// | ||
+ | |||
+ | * : en réalité bash utilise réellement un fichier temporaire, la preuve : | ||
+ | <code bash> | ||
+ | $ echo <(echo foo) | ||
+ | / | ||
+ | |||
+ | $ cat <(echo foo) | ||
+ | foo | ||
+ | |||
+ | $ xargs echo < <(echo foo) | ||
+ | foo | ||
+ | </ | ||
+ | |||
+ | Pour lire depuis une variable : | ||
+ | <code bash> | ||
+ | read <<< | ||
+ | </ | ||
+ | ====== Expressions arithmétiques | ||
Pour faire un calcul il faut l' | Pour faire un calcul il faut l' | ||
Line 80: | Line 531: | ||
Pour incrémenter une variable : plusieurs possibilités : | Pour incrémenter une variable : plusieurs possibilités : | ||
- | * '' | + | * '' |
- | * ''< | + | * ''< |
- | * ''< | + | |
* ''< | * ''< | ||
- | ===== Instructions conditionnelles | + | ======Conversions====== |
- | ====if==== | + | Convertir $VAR_HEXA de l' |
+ | <code bash> | ||
+ | VAR_DECIMAL=$((16# | ||
+ | # ou, avec la commande let | ||
+ | let VAR_DECIMAL=0x$VAR_HEXA | ||
+ | </ | ||
- | < | + | |
+ | ====== Instructions conditionnelles ====== | ||
+ | |||
+ | =====if===== | ||
+ | |||
+ | < | ||
test expr | test expr | ||
</ | </ | ||
ou | ou | ||
- | < | + | < |
if [ expr ] | if [ expr ] | ||
then | then | ||
Line 103: | Line 563: | ||
* Exemple sur une seule ligne (//-n// renvoie TRUE si la chaine n'est pas vide) : | * Exemple sur une seule ligne (//-n// renvoie TRUE si la chaine n'est pas vide) : | ||
- | < | + | < |
if [ -n "" | if [ -n "" | ||
0 | 0 | ||
</ | </ | ||
- | ===Conditions multiples=== | + | ====Conditions multiples==== |
Pour tester des conditions multiples, on doit encadrer les tests avec un double crochet : | Pour tester des conditions multiples, on doit encadrer les tests avec un double crochet : | ||
- | < | + | < |
if [[ TRUE && TRUE || FALSE ]] | if [[ TRUE && TRUE || FALSE ]] | ||
then | then | ||
Line 120: | Line 580: | ||
On peut également procéder ainsi : | On peut également procéder ainsi : | ||
- | < | + | < |
if [ TRUE ] && [ TRUE ] || [ FALSE ] | if [ TRUE ] && [ TRUE ] || [ FALSE ] | ||
</ | </ | ||
Line 127: | Line 587: | ||
* Structure avec " | * Structure avec " | ||
- | < | + | < |
if [ expr ] | if [ expr ] | ||
then | then | ||
Line 139: | Line 599: | ||
</ | </ | ||
- | === Expression sur les fichiers === | + | ====Expression sur les fichiers==== |
* '' | * '' | ||
Line 152: | Line 612: | ||
* '' | * '' | ||
- | === Chaînes de caractères === | + | * '' |
- | * '' | + | |
- | * '' | + | ====Chaînes de caractères==== |
+ | * '' | ||
+ | * '' | ||
+ | * ''" | ||
+ | <code bash> | ||
+ | [[ "la réponse est 42" =~ ^.*([0-9]{2}).*$ ]] && echo " | ||
+ | 42 est la réponse | ||
+ | </ | ||
* '' | * '' | ||
* '' | * '' | ||
- | === Nombres, comparaison === | + | ==== Nombres, comparaison |
* '' | * '' | ||
* '' | * '' | ||
Line 166: | Line 633: | ||
* '' | * '' | ||
- | === Opérateurs === | + | Comme il n'y a pas de typage en bash, pour tester si la valeur d'une variable est un nombre (entier) il faut réaliser le tester : |
+ | <code bash> | ||
+ | # Solution à base de REGEX | ||
+ | [[ $VAR =~ ^[0-9]+$ ]] || echo "VAR n'est pas un entier" | ||
+ | # NB : l' | ||
+ | # ou doit être enregistrée dans une variable sinon ça ne matche pas | ||
+ | |||
+ | # " | ||
+ | [ $VAR -eq $VAR ] 2>/ | ||
+ | </ | ||
+ | ==== Opérateurs | ||
* '' | * '' | ||
* '' | * '' | ||
Line 174: | Line 651: | ||
- | ==== case ==== | + | ===== case ===== |
Test plusieurs valeurs de < | Test plusieurs valeurs de < | ||
- | + | <code bash> | |
- | case < | + | case < |
- | | + | |
- | echo "motif 1" | + | echo "motif 1" |
- | echo " | + | echo " |
- | ;; | + | ;; |
- | | + | |
- | echo "motif 2 ou motif 3" | + | echo "motif 2 ou motif 3" |
- | ;; | + | ;; |
- | | + | |
- | echo "tous les autres motifs" | + | echo "tous les autres motifs" |
- | ;; | + | ;; |
- | | + | *) |
- | echo "Tout le reste" | + | echo "Tout le reste" |
- | ;; | + | ;; |
- | esac | + | esac |
+ | </ | ||
- | ==== for ==== | + | ===== for ===== |
Permet de créer une boucle déterministe : pour chaque valeur de i, on exécute la boucle. | Permet de créer une boucle déterministe : pour chaque valeur de i, on exécute la boucle. | ||
Exemples : | Exemples : | ||
- | < | + | < |
for (( i = 1; i <= 5; i++ )) | for (( i = 1; i <= 5; i++ )) | ||
do | do | ||
Line 208: | Line 686: | ||
Affichera : '' | Affichera : '' | ||
- | Cela équivaut à : '' | + | Cela équivaut à : '' |
+ | <code bash> | ||
+ | DEBUT=1 | ||
+ | FIN=5 | ||
+ | # ne fonctionne pas : for i in {$DEBUT..$FIN} | ||
+ | # fonctionne : | ||
+ | for (( i = $DEBUT; i <= $FIN; i++ )) | ||
+ | </ | ||
+ | |||
+ | On peut spécifier l' | ||
On peut aussi lui fournir une liste de mots : | On peut aussi lui fournir une liste de mots : | ||
- | < | + | < |
for i in serveur1 serveur2 serveur3 | for i in serveur1 serveur2 serveur3 | ||
do | do | ||
Line 219: | Line 706: | ||
On peut l' | On peut l' | ||
- | < | + | < |
for i in serveur1 serveur2 serveur3; do ssh $i " | for i in serveur1 serveur2 serveur3; do ssh $i " | ||
</ | </ | ||
- | ===break=== | + | ====break==== |
Pour sortir prématurément d'une boucle for, **while** ou **repeat**, on utilise le mot-clé **break** : | Pour sortir prématurément d'une boucle for, **while** ou **repeat**, on utilise le mot-clé **break** : | ||
- | < | + | < |
for i in {1..5} | for i in {1..5} | ||
do | do | ||
Line 238: | Line 725: | ||
Ce qui donne : | Ce qui donne : | ||
- | < | + | < |
1 | 1 | ||
2 | 2 | ||
Line 244: | Line 731: | ||
</ | </ | ||
- | ===continue=== | + | ====continue==== |
Pour sortir de l' | Pour sortir de l' | ||
- | < | + | < |
for i in {1..5} | for i in {1..5} | ||
do | do | ||
Line 259: | Line 746: | ||
Ce qui donne : | Ce qui donne : | ||
- | < | + | < |
1 | 1 | ||
2 | 2 | ||
Line 267: | Line 754: | ||
</ | </ | ||
- | ====while==== | + | =====while===== |
Exécute la boucle tant que la condition suivant l' | Exécute la boucle tant que la condition suivant l' | ||
- | exemple : lire un fichier ligne par ligne | + | exemple |
- | < | + | <code bash> |
+ | cpt=1 | ||
+ | while [ $cpt -le 5 ]; do | ||
+ | echo $cpt | ||
+ | (( cpt++ )) | ||
+ | done | ||
+ | </ | ||
+ | |||
+ | exemple2 | ||
+ | < | ||
while read line | while read line | ||
do | do | ||
echo $line | echo $line | ||
done < fic.txt | done < fic.txt | ||
+ | </ | ||
+ | |||
+ | La même mais avec la sortie d'une commande : | ||
+ | <code bash> | ||
+ | cat fic.txt | while read line | ||
+ | do | ||
+ | echo $line | ||
+ | done | ||
</ | </ | ||
ou sur une seule ligne : | ou sur une seule ligne : | ||
- | < | + | < |
- | ====until==== | + | =====until===== |
Exécute la boucle jusqu' | Exécute la boucle jusqu' | ||
- | < | + | < |
until < | until < | ||
do | do | ||
Line 292: | Line 796: | ||
</ | </ | ||
- | ====select==== | + | =====select===== |
Permet de créer un menu interactif, c'est à dire une saisie utilisateur ; | Permet de créer un menu interactif, c'est à dire une saisie utilisateur ; | ||
Line 298: | Line 802: | ||
* $REPLY contient l' | * $REPLY contient l' | ||
- | < | + | < |
PS3=" | PS3=" | ||
select i in {2..5} | select i in {2..5} | ||
Line 312: | Line 816: | ||
- | =====Divers===== | + | ======Divers====== |
+ | |||
+ | =====debug===== | ||
+ | Pour débugger un script, on insère en début de script la commande '' | ||
====en vrac==== | ====en vrac==== | ||
Line 332: | Line 839: | ||
</ | </ | ||
- | ==== Substitution de chaine ==== | + | ===== Substitution de chaine |
Pour n' | Pour n' | ||
Line 356: | Line 863: | ||
chanceux | chanceux | ||
</ | </ | ||
- | ==== Remplacement de chaine ==== | + | |
+ | ===== Remplacement de chaine | ||
Syntaxe : '' | Syntaxe : '' | ||
Line 383: | Line 891: | ||
</ | </ | ||
- | ====Modifier la casse==== | + | =====Modifier la casse===== |
Pour modifier la casse, on utilise la syntaxe : | Pour modifier la casse, on utilise la syntaxe : | ||
Line 417: | Line 925: | ||
</ | </ | ||
- | ====Préfixes et suffixes==== | + | =====Préfixes et suffixes===== |
Syntaxe : '' | Syntaxe : '' | ||
Line 435: | Line 943: | ||
/ | / | ||
</ | </ | ||
- | ===== Liens ===== | + | |
+ | =====trim (suppression des espaces dans une chaîne)===== | ||
+ | |||
+ | bash ne possède pas de fonction prédéfinie pour " | ||
+ | |||
+ | Pour faire cette office il existe plusieurs possibilités d' | ||
+ | <code bash> | ||
+ | arr=(' | ||
+ | ' test@domain.com ' ' | ||
+ | </ | ||
+ | |||
+ | * en utilisant la substitution de caractère dans les variables, en activant le //globbing étendu// (des motifs d' | ||
+ | <code bash> | ||
+ | shopt -s extglob | ||
+ | # (pour reconnaître [[:blank:]] qui définit l' | ||
+ | arr=( " | ||
+ | arr=( " | ||
+ | </ | ||
+ | |||
+ | * avec '' | ||
+ | <code bash> | ||
+ | function trim() { | ||
+ | mapfile -t t_input<<<" | ||
+ | [[ ${# | ||
+ | set -- ${t_input[@]} | ||
+ | printf ' | ||
+ | } | ||
+ | trim " | ||
+ | </ | ||
+ | ====== Ressources ====== | ||
* http:// | * http:// | ||
* http:// | * http:// | ||
* [[http:// | * [[http:// | ||
+ | * https:// | ||
+ | * [[https:// | ||
+ | * [[https:// | ||
+ | * [[https:// | ||
+ | * [[https:// |
informatique/linux/programmation_shell.txt · Last modified: 2023/10/02 13:35 by pteu