Exile on Keyboard St. - Blog sur Linux et Debian

Aller au contenu | Aller au menu | Aller à la recherche

vendredi 7 avril 2017

Bien utiliser les tableaux en bash

Le bash, Bourne Again Shell, offre une possibilité absente du Bourne Shell, à savoir la possibilité de déclarer facilement des tableaux.

On s'intéressera ici aux tableaux indexés uniquement.

Pour déclarer un tableau, rien de plus simple:

#!/bin/bash

colours=(black blue green white red yellow)

Maintenant pour afficher tous les éléments en une fois:

echo "colours_elements=${colours[@]}"

colours_elements=black blue green white red yellow

Pour afficher la troisième couleur, située à l'indice 2:

echo "green=${colours[2]}"
green=green

Le nombre d'élements du tableau:

echo "colours_count=${#colours[@]}"
colours_count=6

Pour boucler sur chaque valeur:

for colour in ${colours[@]}; do
    ...
done

Et pour afficher la troisième couleur en partant de la fin du tableau:

echo "${colours[-3]}"
white

Enfin bash permet aussi de lire un fichier dans un tableau avec la built-in mapfile.

dimanche 24 juillet 2016

Définir un valeur par défaut pour la builtin read de Bash

La builtin read de bash permet à l'utilisateur de saisir des informations depuis un script Shell.

Par exemple:

read value

On peut aussi afficher un prompt précisant ce que l'utilisateur doit entrer au clavier:

read -p "Enter the input file path: " file_path

Mais il est souvent également nécessaire de définir une valeur par défaut de telle sorte que si celle-ci convient à l'utilisateur il n'a qu'à appuyer sur Entrée:

read -p "Enter the folder path: " -e -i /tmp folder_path

qui affiche:

Enter the folder path: /tmp

Cela se fait avec le flag -i de la builtin read qui nécessite également le flag -e (pour utiliser l'interface readline).

La documentation complète des builtin de bash se trouve ici: https://www.gnu.org/software/bash/manual/html_node/Bash-Builtins.html.

On peut aussi consulter le Linux Documentation Project.

dimanche 20 décembre 2015

Quelle valeur pour vos codes retour en Shell ?

On a vu précédemment que les fonctions du Shell Linux ne permettent pas de retourner facilement une valeur non numérique.

Mais dans le cas le plus courant où une fonction Shell doit retourner une valeur booléenne, que doit-on retourner ? 1 pour true ou 0 ?

Imaginons la fonction suivante dont on a très souvent besoin en Shell:

is_root_v1() {
    if [ "$(id -u)" -eq "0" ]; then
        echo "$(id -u) is root"
        return 1
    fi

    echo "$(id -u) is not root"
    return 0
}

A priori cette fonction semble correcte. Pourtant, si on l’appelle comme suit depuis un utilisateur non root:

if is_root_v1; then
    echo "We are connected as root !"
else
    echo "We are not connected as root !"
fi

On obtient le résultat suivant:

1000 is not root
We are connected as root !

L'erreur n'est pas à chercher dans le code de la fonction elle même, si le résultat de id -u est 0, c'est bien qu'on est connecté en tant que root. Cela dit, le code retour retourné par la fonction is_root_v1 n'est pas le bon.

En effet, dans un if en Shell le bloc de code then est exécuté si la condition vaut 0 et non 1 contrairement à la première idée qu'on pourrait se faire !!!

Il faut donc inverser les codes retour de notre fonction comme suit:

is_root_v2() {
    if [ "$(id -u)" -eq "0" ]; then
        echo "$(id -u) is root"
        return 0
    fi

    echo "$(id -u) is not root"
    return 1
}

Maintenant, j'obtiens un résultat cohérent:

1000 is not root
We are not connected as root !

Conclusion: en Shell true vaut 0 et false vaut 1.

On peut le vérifier avec les commandes suivantes:

true; echo $?

qui affiche 0.

Et:

false; echo $?

qui affiche 1

dimanche 15 juin 2014

Vérifier vos scripts shell avec ShellCheck

Sous Linux, quand on veut automatiser quelque chose, le langage de prédilection reste encore bash, à condition de prendre le temps de lire la manpage, et de ne pas considérer que puisque c'est du Shell, peu importe que le code soit propre ou non !

Mais la syntaxe des scripts Shell est parfois obscure et la question de savoir si on doit mettre des doubles quotes dans tel cas ou échapper un caractère dans un autre se pose souvent.

C'est là que nous vient en aide le projet ShellCheck. ShellCheck est un utilitaire en ligne de commande qui vérifie vos scripts Shell un peu à la manière de lint pour le langage C ou des outils comme Sonar pour le Java.

Pour l'installer il faut télécharger la dernière archive sur GitHub: Version 0.3.3 et l'extraire dans un répertoire temporaire.

Après avoir installé cabal-install:

sudo apt-get install cabal-install

On va dans le répertoire des sources lancer les commandes suivantes (en tant qu'utilisateur):

cabal update
cabal --symlink-bindir=~/bin/ install

La commande shellcheck est alors installée dans ~/.cabal/bin/shellcheck avec un lien depuis ~/bin/

On peut aussi installer ShellCheck avec make mais dans ce cas il faut le compilateur Haskell plus une palanquée de dépendances de librairies Haskell, ce qui est assez pénible.

Maintenant vous pouvez vérifier vos scripts en lançant:

shellcheck ~/bin/myscript.sh

ShellCheck existe aussi en ligne à l'adresse ShellCheck.net.

Happy Scripting !

Mise à jour:

Depuis Debian Jessie, ShellCheck est dans le dépôt officiel.