Ah le Bash ! Ce vrai et beau langage qui continue son exécution même après qu'une erreur s'est produite.

Dans leur grande sagesse, les développeurs ont eu la bonne idée d'y associer un mode de débuggage, qui permet d'afficher la valeur des variables.

Quand on en a marre de débugger un script à coup de echo toutes les deux lignes, cela s'avère pratique.

Pour l'activer :

1) On peut lancer tout le script en mode débug :

bash -x monScript.sh

2) On peut également intégrer l'option directement au niveau du shebang :

#!/usr/bin/env bash -x

3) On peut enfin ne placer qu'une partie du script en mode débug. Il suffit d'activer le mode avant le code suspect, et de le désactiver ensuite :

#!/usr/bin/env

# Le code qui ne pose pas de problème
...
# Activation du mode debug
set -x
# Le code foireux
...
# Désactivation du mode debug
set +x
# Code exécuté après

Il y a quelques autres options, mais en gros c'est l'idée.

Pour cela, il suffit de rediriger un flux vers grep de cette façon :

cat monfichier | grep -E --color 'PATT3RN|$'

Ainsi, l'ensemble du texte d'origine est affiché. Et si le pattern apparaît, celui-ci apparaît en couleur.
Par exemple, dans le cas où l'on souhaite afficher l'arbre des dépendances d'un module maven, et qu'on cherche quelles dépendances dépendent de slf4j :

mvn dependency:tree | grep -E --color 'slf4j|$'

Note : Sans le |$, seules les lignes contenant le pattern sont affichées.

Petite astuce bash pour supprimer le contenu d'un répertoire :

find $REPERTOIRE -mindepth 1 -delete

-mindepth 1 permet de ne lister que les fichiers (et répertoires) situés au moins au niveau 1 de profondeur. Donc en pratique, tout ce qui se trouve dans le répertoire $REPERTOIRE.

-delete supprime tous les fichiers (et répertoires) listés.

Note : les fichiers cachés (commençant par un '.') sont également supprimés.

Pour chercher une chaine de caractères dans un répertoire de façon récursive :

grep -rl "string" "$PATH"

• -r permet de faire la recherche récursive dans les fichiers situés dans "$PATH";
• -l permet de n'afficher que les noms des fichiers contenant le texte recherché. Sans cette option, la commande grep affichera les lignes contenant le texte recherché.

Pour tester si une page existe sans la télécharger :

#!/bin/bash

# Renvoie "true" si la page passée en argument existe.
# @param $1 : l'URL de la page dont on veut tester l'existence.
# @return true si la page existe, false sinon.
is_URL_real()
{
    local page_exists
    page_exists="false"

    if [[ `wget --server-response --spider "$1"  2>&1 | grep 'HTTP/1.1 200 OK'` ]]; then
        page_exists="true"
    fi

    echo "$page_exists"
}

is_URL_real "$1"

Ce qui donne à l'exécution :

./test_URL.sh "https://www.qwant.com"
true

Un moyen de créer des répertoires plus rapidement.

Je veux créer des répertoires ayant un nom basé sur le même modèle. Par exemple REPERTOIRE.ABC.08.

Pour créer tous les répertoires de 08 à 14, je peux utiliser une boucle for dans laquelle un compteur s'incrémente dans une string, laquelle est passée à mkdir.

Ou alors je peux utiliser une capacité de la commande mkdir :

mkdir REPERTOIRE.ABC.{08..14}
# Ce qui me donne :
ls -a
REPERTOIRE.ABC.08
REPERTOIRE.ABC.09
REPERTOIRE.ABC.10
REPERTOIRE.ABC.11
REPERTOIRE.ABC.12
REPERTOIRE.ABC.13
REPERTOIRE.ABC.14

Je peux utiliser une suite de lettres :

mkdir REPERTOIRE.{a..f}
# Ce qui me donne :
ls -a
REPERTOIRE.a
REPERTOIRE.b
REPERTOIRE.c
REPERTOIRE.d
REPERTOIRE.e
REPERTOIRE.f

Je peux utiliser plusieurs "suites" dans le même motif. Attention toutefois, car toutes les combinaisons seront créees :

mkdir REPERTOIRE.{a..c}_{0..3}
# Ce qui me donne :
ls -a
REPERTOIRE.a_0
REPERTOIRE.a_1
REPERTOIRE.a_2
REPERTOIRE.a_3
REPERTOIRE.b_0
...
REPERTOIRE.c_3

Le bonus de fin : je peux parcourir une suite de nombres avec un pas supérieur à 1 :

# Pour un pas de 2
mkdir REPERTOIRE.{1..7..2}
# Ce qui me donne :
ls -a
REPERTOIRE.1
REPERTOIRE.3
REPERTOIRE.5
REPERTOIRE.7

Edit : si au lieu d'une suite de caractères je veut utiliser une liste de valeurs prédéfinies je peux utiliser la virgule :

mkdir dossier_{toto,1,007,AZ}
# Ce qui me donne
ls -a
dossier_toto
dossier_1
dossier_007
dossier_AZ

Pour une arborescence, j'utilise aussi l'option -p :

mkdir -p parent{1..4}/enfant{bill,bob,ben}
# Ce qui me donne
tree
.
├── parent1
│   ├── enfantben
│   ├── enfantbill
│   └── enfantbob
├── parent2
│   ├── enfantben
│   ├── enfantbill
│   └── enfantbob
├── parent3
│   ├── enfantben
│   ├── enfantbill
│   └── enfantbob
└── parent4
    ├── enfantben
    ├── enfantbill
    └── enfantbob

Pour mémoire.
Comment extraire la n-ème ligne d'une fichier en bash?

Soit le fichier suivant :

Ligne 01
Ligne 02
Ligne 03
Ligne 04
Ligne 05
Ligne 06
Ligne 07

Avec l'outil sed :

# J'extrais la 4eme ligne du fichier
cat mon_fichier | sed "4q;d"

# Ce qui donne
Ligne 04

# J'extrais la 67eme ligne (avec une variable)
var="67"
cat mon_fichier | sed "${var}q;d"

Afin d'éviter de créer des scripts troués, une bonne pratique est d'utiliser le double-tiret -- pour marquer la fin des options d'une commande bash.

En effet, supposons que je veuille lister les fichiers d'un répertoires. Rien n'empêche qu'un répertoire s'appelle -o et active donc l'option associée. Pour signifier à la commande ls d'ignorer ce qui suit mes options je procède ainsi :

# Mon répertoire s'appelle "-o -a"
var="-o -a"
# J'ajoute un double-tiret pour signifier la fin des options
ls -l -- "$var"
# Une fois la variable évaluée, la commande ressemblera à ceci
ls -l -- -o -a
# Et seule l'option -l sera prise en compte

Cette convention est reprise par toutes les commandes built-in de bash (+ d'autres shells comme csh et sh) sauf une poignée (true, false, echo et eval).

J'avais fais quelques tests il y a quelques mois, pour voir ce qu'on pouvait faire en "hackant" les options des commandes. Pour ls c'est ennuyeux. Mais il suffit d'imaginer les conséquences avec rm par exemple ...

Note à moi-même : il faudra que j'essaie getopt pour créer un parseur d'options en bash.

Cette fois c'est une capacité de l'outil awk qui m'intéresse.

Comment afficher ce qui se trouve entre deux motifs ? Le point fort est que cette méthode fonctionne même si les motifs ne sont pas sur la même ligne :

# J'affiche ce qui se trouve entre le motifs MOTIF_01 et MOTIF_02
cat mon_fichier | awk "/MOTIF_01/,/MOTIF_02/"

Dans ce cas, les motifs sont affichés avec ce qui les sépare. Le résultat peut ressembler à quelque chose comme ça :

bla bla bla MOTIF_01 toc
//Plein de trucs se trouvant entre les motifs
paf pouf MOTIF_02 plouf plouf

Pour connaître le path d'un script à l'intérieur de ce même script, il faut utiliser :

PATH=${BASH_SOURCE[0]}

Au lieu de :

PATH=$0

En effet, la première méthode retourne le path du script courant même s'il est sourcé (ie lancé comme ceci : ./script.sh).