• BASH > les variables, chaines, etc.

      VALEUR PAR DÉFAUT

      ${var:-défaut} Si var n’est pas initialisé, utilise défaut - Sert pour des arguments manquants. Cette association ne dure que le temps d’exécution de la commande.

      exemple: VAR=${1:-toto} si l’argument $1 est manquant, donne la valeur toto à VAR

       

      ${var:=défaut} Si var n’est pas initialisé, alors var est initialisé à la valeur par défaut

       

      ${var:+valeur} Si var est déclaré, utilise valeur, sinon utilise une chaîne vide.

       

      ${var:?"Message_erreur"} Si var n’est pas défini, affiche Message_erreur et interrompt le script. Il faut bien quotter "Message_erreur"

      Exemple :

      : ${1:?"Erreur: argument absent"}

      NOTE > Les : permettent à Bash d’exécuter la ligne sans erreur.

      POSITION D’UNE VARIABLE

      set arg1 arg2 arg3 …

       

      La numérotation commençant à 1, pour appeler $arg2 > echo $2

       

      exemple :

       

      set toto tata titi

      echo $2 → tata

      echo $3 → titi

       

      set -- rend la valeur des paramètres de position préalablement initialisés caduque

      DÉCALER LA POSITION D’UNE VARIABLE

      shift N décale N fois la position des paramètres. Par défaut, N = 1

       

      Une fois le décalage effectué, le paramètre # est mis à jour.

       

      set toto tata titi

      echo $1 → toto

      shift

      echo $1 → tata

       

      set toto tata titi

      echo $1 → toto

      shift 2

      echo $1 → titi

      $VAR - ${VAR} - "$VAR" - ${VAR}"

      Les parenthèses évitent les ambiguïtés du genre :

       

      var=foo

      echo $varbar → erreur car varbar n’existe pas

      echo ${var}bar → foobar

       

       

      Les doubles quotes permettent d’avoir une chaine unique :

       

      var="foo bar"
for i in "$var"; do
    echo $i
done

      renvoie →

      foo bar sur la même ligne, car traitée comme une seule variable

       

      Contrairement à :

       

      var="foo bar"
for i in $var; do
    echo $i
done

      renvoie →

      foo

      bar

      sur deux lignes car traitée comme deux variables séparées par un espace.

      SUITE DE CHIFFRES OU LETTRES

      Chiffres

      seq 1 6 → 1 2 3 4 5 6

      seq 0 5 25 → 0 5 10 15 20 25

       

      utilisation :

      for chiffre in `seq 1 5` ; echo ${chiffre} ; done → 1 2 3 4 5

      Lettres

      {a..z} → a b c d e f g h i j k l m n o p q r s t u v w x y z

      {A..z} → A B C … X Y Z [ ] ^ _ ` a b c … x y z

       

      utilisation :

      echo {a..z} → a b c … x y z

      for lettre in {a..z} ; do echo ${lettre} ; done → a b c … x y z

       

      MANIPULATIONS DES CHAINES

      Changer la casse

      VAR="TOto"

       

      Tout en minuscule : ${VAR,,} → toto

      Tout en majuscule : ${VAR^^} → TOTO

      Première lettre en minuscule : ${VAR,} → tOTO

      Première lettre en majuscule : ${VAR^} → Toto

      Longueur de la chaine

      VAR="http://site.com/chemin/vers/fichier"

      ${#VAR} →  35

      Couper une chaine

      ATTENTION : à chaque fois, le motif est inclus dans la suppression !

       

      VAR="http://site.com/chemin/vers/fichier"

       

      SUPPRIMER LA CHAINE LA PLUS LONGUE A GAUCHE : ${VAR##*MOTIF}
      > ${VAR##*/} → fichier (http://site.com/chemin/vers/fichier)

       

      SUPPRIMER LA CHAINE LA PLUS COURTE A GAUCHE : ${VAR#*MOTIF}
      > ${VAR#*/} → /site.com/chemin/vers/fichier (http://site.com/chemin/vers/fichier)

       

      SUPPRIMER LA CHAINE LA PLUS COURTE A DROITE : ${VAR%MOTIF*}
      > ${VAR%/*} → http://site.com/chemin/vers (http://site.com/chemin/vers/fichier)

       

      SUPPRIMER LA CHAINE LA PLUS LONGUE A DROITE : ${VAR%%MOTIF*}
      > ${VAR%%/*} → http: (http://site.com/chemin/vers/fichier)

      Extraire une sous-chaine

      ${VAR:ind} extrait à partir de l’indice ind (commence à 0)
      abcdefghij
      0123456789

       

      > ${abcdefghijk:3} → defghijk

       

      ${VAR:ind:nb} extrait nb caractères à partir de l’indice ind

       

      > ${abcdefghijk:8:2}→ ij

      Remplacer une occurrence

      ${VAR/MOTIF/REMP} Remplace la plus longue sous-chaîne de MOTIF par REMP. Seule la 1ère occurrence est remplacée.
      exemple > ${totito/to/lo} → lotito

       

      MOTIF peut être du genre REGEX :

       

      exemple > ${abcfefg/b*f/-} → a-g

      ici, deux sous-chaînes  satisfont le modèle b*f : abcfefg et abcfefg
      C’est la plus longue qui sera remplacée par -


      ${VAR//MOTIF/REMP} ici tous les MOTIF sont remplacés par REMP


      ${VAR//MOTIF/} Lorsque REMP est absent, la ou les occurrences sont supprimées
      ${123azer45ty//+([[:lower:]])/} → 12345
      L’expression +([[:lower:]]) désigne la plus longue suite non vide de minuscules.

       

      si l’on souhaite en début de chaîne ( #mod ) ou bien en fin de chaîne ( %mod )
      ${automoto/#o/i} → autimoto
      ${automoto/%o/i} → automoti

      Scinder une chaine

      echo "$VAR" | cut -d: -f3

      -d pour dire quel caractère sera utilisé pour scinder (ici :) - pour dire un point : \.

      -f pour dire quel indice on récupère (commence à 1)

      Voir les caractères invisibles

      tr -d
      cat -vt est encore plus robuste :
      ^@^A^B^C^D^E^F^G^H^I^K^L^M^N^O^P^Q^R^S^T^U^V^W^X^Y^Z^[^\^]^^^_ !"#$%&'()*+,-./
0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
^?M-^@M-^AM-^BM-^CM-^DM-^EM-^FM-^GM-^HM-^IM-
M-^KM-^LM-^MM-^NM-^OM-^PM-^QM-^RM-^SM-^TM-^UM-^VM-^WM-^XM-^YM-^ZM-^[M-^\M-^]M-^^M-
^_M- M-!M-"M-#M-$M-%M-&M-'M-(M-)M-*M-+M-,M--M-.M-/M-0M-1M-2M-3M-4M-5M-6M-7M-8M-9M-:M-;
M-<M-=M->M-?M-@M-AM-BM-CM-DM-EM-FM-GM-HM-IM-JM-KM-LM-MM-NM-OM-PM-QM-RM-SM-TM-UM-VM-WM-
XM-YM-ZM-[M-\M-]M-^M-_M-`M-aM-bM-cM-dM-eM-fM-gM-hM-iM-jM-kM-lM-mM-nM-oM-pM-qM-rM-sM-tM-
uM-vM-wM-xM-yM-zM-{M-|M-}M-~M-^?Prompt$

      CALCULS ARITHMÉTIQUES

      Généralités

      Les variables de type entier à 32 bits doivent être compris entre -2147483648 à 2147483647. Sinon résultat erroné. À partir de la version 2.05b, Bash dispose des entiers à 64 bits.

       

      Bash traite les nombres décimaux comme des chaînes de caractères. On utilise bc pour y remédier :

      x=$(echo "scale=3; $a*1.5" | bc)

      scale=3 veut dire 3 décimales.

       

      Double Parentheses

      var=$(( 20 + 5 ))         Integer arithmetic, with variable assignment

      (( var0 = var1<98?9:21 )) C-style ternary operation

      Syntaxe

      let "x = $a + $b"

      ou let "x = a + b"

      ou : $((x = $a + $b)) ( : nécessaire sinon Bash interprète $((n = $a + $b)) comme une commande )

      ou (( x = a + b ))

      ou x=$(($a + $b))

      ou : $[ x = $a + $b ] ( : nécessaire sinon Bash interprète $[ n = $a + $b ] comme une commande )
      # Fonctionne même si "a" a été initialisé comme une chaîne de caractères.

      ou x=$[ $a + $b ] A éviter car obsolète et non portable

       

       

      ADDITION : let "x = 8 + 3″ → 11

      SOUSTRACTION : let "x = 5 - 2″ → 3

      MULTIPLICATION : let "x = 4 * 2″ → 8

      DIVISION : let "x = 10 / 5″ → 2

      PUISSANCE : let "x = 5**3″ → 125
      MODULO : let "x = 5%3″ → 2 ( renvoie le reste de la division d’un entier : 5 / 3 = 1 avec un reste de 2 )

      Incrémentation

      let "var++" ou let "++var"
      ou (( var++ )) ou (( ++var ))
      ou : $(( var++ )) ou : $(( ++var ))
      ou : $[ var++ ] ou : $[ ++var ]]

       

      += incrémente une variable par une constante : let "var += 5″

      -= décrémente une variable par une constante : let "var -= 5″

      *= multiplie une variable par une constante : let "var *= 4″

      /= divise une variable par une constante : let "var /= 2″

      %= reste de la division de la variable par une constante : let "var %= 2″

       

      (( var=var+2 )) ou (( var+=2 ))

      let "var=var+2″ ou let "var+=2″

      Opérateur virgule

      , permet plusieurs opérations arithmétiques.

       

      Utile dans une boucle pour incrémenter plusieurs variables :

      for (( a=1, b=3 ; a <= 10 ; a++, b++ )) ; do
  echo -n "$a*$b "
done

      Plus grand diviseur commun

      Le PGDC de deux entiers est l’entier le plus important qui divisera les deux sans reste.

       

      #!/bin/bash
# Vérification des arguments
ARGS=2
if [ $# -ne "$ARGS" ] ; then
   echo "Usage: `basename $0` premier_nombre deuxieme_nombre"
   exit 65
fi
# ——————————————————
pgcd (){
   dividende=$1
   diviseur=$2
   reste=1
   until [ "$reste" -eq 0 ] ; do
      let "reste = $dividende % $diviseur"
      dividende=$diviseur
      diviseur=$reste
   done
}# Le dernier $dividende est le pgcd.
pgcd $1 $2
echo "PGCD de $1 et $2 = $dividende"
exit 0

      VARIABLES SPÉCIALES

      $$ PID du shell courant
      $! PID du dernier travail lancé en arrière plan
      $? code retour de la dernière commande
      $HOME chemin du répertoire personnel de l’utilisateur
      $OLDPWD chemin du répertoire précédent
      $PATH liste des chemins de recherche des commandes exécutables
      $PPID PID du processus père du shell
      $PS1 invite principale du shell
      $PS2 invite secondaire du shell
      $PS3 invite de la structure shell "select"
      $PS4 invite de l’option shell de débogage "xtrace"
      $PWD chemin du répertoire courant
      $RANDOM nombre entier aléatoire compris entre 0 et 32767
      $REPLY variable par défaut de la commande "read" et de la structure shell "select"
      $SECONDS nombre de secondes écoulées depuis le lancement du shell

       

      ———-

      Unusual Ways to Use Variables Inside Bash Script

      Using arrays

      name=("Linux Handbook" "It's FOSS")
echo "Hello ${name[1]}!"
Hello It's FOSS!

      Indirect references to variables

      ${!variable}

      This one is a bit more complex in how it functions, but makes sense after you see how it works:

      name="Linux Handbook"
variable="name"
echo "Hello ${!variable}!"
Hello Linux Handbook

      Let ! devanr la variable name causes the normal variable name to be substituted, but then uses the name of that string to find the relevant variable.

      Finding the length of a variable

      ${#variable}

      Using this method will print the length of the variable, but will act slightly different depending on if the variable is a string or an array.

      Using that syntax on a string will cause the variable to be substituted for the amount of characters in the string.

      variable="name"
echo "Length is ${#variable}."

      It will prnt 4. But on the otherhand, using it on an array will print the number of items inside the array, i.e. array size, which is 2 here.

      variable=("name" "word")
echo "Length is ${#variable}."

      Lowercasing and capitalizing strings

      Lastly, you can capitalize and lowercase a string using the ^ and , operators respectively.

      # Capitalizes
${variable^}
${variable^^}

# Lowercases
${variable,}
${variable,,}

      What’s the difference between providing one and two of the characters?

      Providing just one (i.e. ${variable^}) will cause only the first letter to be modified, while providing two (${variable^^}) will cause the entire string to be modified.

      The example below prints Name instead of name:

      variable="name"
echo "${variable^}"

      But this one prints NAME:

      variable="name"
echo "${variable^^}"

      Similarly, you can print variables in lowercases as well.

      The example below will print wIDEname:

      variable="WIDEname"
echo "${variable,}"

      And this one will print widename:

      variable="WIDEname"
echo "${variable,,}"

      Wrapping up

      variable=("name" "word")
echo "Length is ${#variable}."
4 # not the number of elements but the length of element 0

      To get the number of elements in the array, use:

      echo "${#variable[@]}"

       

      The upper and lower case expansions can also take a pattern:

      echo "${variable^^a}"
nAme

       

 

Aucun commentaire

 

Laissez un commentaire