9 exemples de scripts Bash pour démarrer sur Linux

Si vous débutez avec les scripts Bash sous Linux, une solide compréhension des bases vous sera très utile. Ils sont la base d’une connaissance plus approfondie et de compétences de script plus élevées.

N’oubliez pas, rendez vos scripts exécutables

Pour que le shell exécute un script, le script doit avoir le jeu d’autorisations de fichier exécutable. Sans cela, votre script n’est qu’un fichier texte. Avec lui, c’est toujours un fichier texte, mais le shell sait qu’il contient des instructions et essaiera de les exécuter au lancement du script.

L’intérêt d’écrire des scripts est qu’ils s’exécutent, donc la première étape de base est de savoir comment faire savoir à Linux que votre script doit être considéré comme exécutable.

La chmod La commande nous permet de définir les autorisations de fichiers. L’autorisation d’exécution peut être définie avec le drapeau +x.

chmod +x script1.sh

Vous devrez le faire pour chacun de vos scripts. Remplacez « script1.sh » par le nom de votre script.

1. Qu’est-ce que cette étrange première ligne ?

La première ligne d’un script indique au shell quel interpréteur doit être appelé pour exécuter ce script. La première ligne doit commencer par un shebang, « #! », également connu sous le nom de hashbang. La « #! » indique au shell que cette ligne contient le chemin et le nom de l’interpréteur pour lequel le script a été écrit.

Ceci est important car si vous avez écrit un script à exécuter dans Bash, vous ne voulez pas qu’il soit interprété par un shell différent. Il y a probablement des incompatibilités. Bash, comme la plupart des shells, a ses propres bizarreries de syntaxe et de fonctionnalités que les autres shells n’auront pas ou auront implémentées différemment.

Lorsque vous exécutez un script, le shell actuel ouvre le script et détermine quel shell ou interpréteur doit être utilisé pour exécuter ce script. Il lance ensuite ce shell et lui transmet le script.

#!/bin/bash

echo Running in $SHELL

La première ligne de ce script peut être lue comme suit : « Utilisez l’interpréteur situé dans /bin/bash pour exécuter ce script ».

La seule ligne du script écrit la valeur contenue dans le $SHELL variable d’environnement à l’écran du terminal. Cela confirme que Bash a été utilisé pour exécuter le script.

./script1.sh

Comme un petit tour de passe-passe, nous pouvons démontrer que le script est passé à n’importe quel interpréteur que nous sélectionnons.

#!/bin/cat
All the lines of text are passed to the cat command
and are printed in the terminal window. That includes
the shebang line.

script2.sh

Ce script est lancé par le shell courant et passé au cat commande. La cat La commande « exécute » le script.

Écrire vos shebangs comme ceci suppose que vous savez où se trouve le shell ou un autre interpréteur sur la machine cible. Et 99% du temps, ça va. Mais certaines personnes aiment couvrir leurs paris et écrire leurs shebangs comme ceci :

#!/usr/bin/env bash

echo Running in $SHELL

script3.sh

Lorsque le script est lancé, le shell recherches pour l’emplacement du shell nommé. Si le shell se trouve dans un emplacement non standard, ce type d’approche peut éviter les erreurs de « mauvais interprète ».

N’écoutez pas, il ment !

Sous Linux, il y a toujours plus d’une façon d’écorcher un chat ou de prouver qu’un auteur a tort. Pour être tout à fait factuel, il existe un moyen d’exécuter des scripts sans faire de bruit et sans les rendre exécutables.

Si vous lancez le shell pour lequel vous souhaitez exécuter le script et que vous transmettez le script en tant que paramètre de ligne de commande, le shell lancera et exécutera le script, qu’il soit exécutable ou non. Parce que vous choisissez le shell sur la ligne de commande, il n’y a pas besoin d’un shebang.

Voici le script complet :

echo "I've been executed by" $SHELL

Nous utiliserons ls pour voir que le script n’est vraiment pas exécutable et lancez Bash avec le nom du script :

ls

bash script4.sh

Il existe également un moyen de faire exécuter un script par le courant shell, pas un shell lancé spécifiquement pour exécuter le script. Si vous utilisez le source commande, qui peut être abrégée en un seul point « .« , votre script est exécuté par votre shell actuel.

Ainsi, pour exécuter un script sans shebang, sans l’autorisation du fichier exécutable et sans lancer un autre shell, vous pouvez utiliser l’une de ces commandes :

source script4.sh

. script4.sh

Bien que cela soit possible, cela n’est pas recommandé comme solution générale. Il y a des inconvénients.

Si un script ne contient pas de shebang, vous ne pouvez pas dire pour quel shell il a été écrit. Allez-vous vous en souvenir dans un an ? Et sans que l’autorisation exécutable ne soit définie sur le script, le ls La commande ne l’identifiera pas comme un fichier exécutable et n’utilisera pas non plus de couleur pour distinguer le script des fichiers en texte brut.

2. Impression de texte

L’écriture de texte sur le terminal est une exigence courante. Un peu de rétroaction visuelle va un long chemin.

Pour les messages simples, le echo commande suffira. Il permet une certaine mise en forme du texte et vous permet également de travailler avec des variables.

#!/bin/bash

echo This is a simple string.
echo "This is a string containing 'single quotes' so it's wrapped in double quotes."
echo "This prints the user name:" $USER
echo -e "The -e option lets us usenformatting directivesnto split the string."

./script5.sh

La printf La commande nous donne plus de flexibilité et de meilleures capacités de formatage, y compris la conversion de nombres.

Ce script imprime le même nombre en utilisant trois bases numériques différentes. La version hexadécimale est également formatée pour s’imprimer en majuscules, avec des zéros non significatifs et une largeur de trois chiffres.

#!/bin/bash

printf "Decimal: %d, Octal: %o, Hexadecimal: %03Xn" 32 32 32

./script6.sh

Notez que contrairement à echotu dois dire printf pour commencer une nouvelle ligne avec le « n » jeton.

3. Créer et utiliser des variables

Les variables vous permettent de stocker des valeurs dans votre programme et de les manipuler et de les utiliser. Vous pouvez créer vos propres variables ou utiliser des variables d’environnement pour les valeurs système.

#!/bin/bash

millennium_text="Years since the millennium:"

current_time=$( date '+%H:%M:%S' )
todays_date=$( date '+%F' )
year=$( date '+%Y' )

echo "Current time:" $current_time
echo "Today's date:" $todays_date

years_since_Y2K=$(( year - 2000 ))

echo $millennium_text $years_since_Y2K

Ce script crée une variable de chaîne appelée millennium_text. Il contient une ligne de texte.

Il crée ensuite trois variables numériques.

• La current_time La variable est initialisée au moment où le script est exécuté.
• La todays_date La variable est définie sur la date à laquelle le script est exécuté.
• La year variable contient l’année en cours.

Pour accéder au évaluer stocké dans une variable, faites précéder son nom du signe dollar « $ ».

./script7.sh

Le script imprime l’heure et la date, puis calcule le nombre d’années qui se sont écoulées depuis le millénaire et les stocke dans le years_since_Y2K variable.

Enfin, il imprime la chaîne contenue dans le millennium_text variable et la valeur numérique stockée dans la years_since_Y2K.

4. Gestion des entrées de l’utilisateur

Pour permettre à un utilisateur d’entrer une valeur que le script utilisera, vous devez être en mesure de capturer la saisie au clavier de l’utilisateur. La fête read commande permet de faire exactement cela. Voici un exemple simple.

#!/bin/bash

echo "Enter a number and hit "Enter""
read user_number1;
echo "Enter another number and hit "Enter""
read user_number2;

printf "You entered: %d and %dn" $user_number1 $user_number2
printf "Added together they make: %dn" $(( user_number1 + user_number2))

Le script demande deux nombres. Elles sont lues au clavier et stockées dans deux variables, user_number1 et user_number2 .

Le script imprime les nombres dans la fenêtre du terminal, les additionne et imprime le total.

./script8.sh

Nous pouvons combiner les invites dans le read commandes à l’aide de la -p (invite).

#!/bin/bash

read -p "Enter a number and hit "Enter" " user_number1;
read -p "Enter another number and hit "Enter" " user_number2;

printf "You entered: %d and %dn" $user_number1 $user_number2
printf "Added together they make: %dn" $(( user_number1 + user_number2))

Cela rend les choses plus claires et plus faciles à lire. Les scripts faciles à lire sont également plus faciles à déboguer.

./script9.sh

Le script se comporte légèrement différemment maintenant. L’entrée utilisateur se trouve sur la même ligne que l’invite.

Pour capturer l’entrée du clavier sans qu’elle soit répercutée dans la fenêtre du terminal, utilisez la commande -s option (silencieuse).

#!/bin/bash

read -s -p "Enter your secret PIN and hit "Enter" " secret_PIN;

printf "nShhh ... it is %dn" $secret_PIN

./script10.sh

La valeur d’entrée est capturée et stockée dans une variable appelée secret_PIN mais il n’est pas renvoyé à l’écran lorsque l’utilisateur le tape. Ce que vous en faites ensuite dépend de vous.

5. Accepter les paramètres

Parfois, il est plus pratique d’accepter l’entrée de l’utilisateur en tant que paramètres de ligne de commande que d’avoir un script en attente d’entrée. Passer des valeurs à un script est facile. Elles peuvent être référencées dans le script comme s’il s’agissait de n’importe quelle autre variable.

Le premier paramètre devient variable $1le deuxième paramètre devient variable $2, etc. Variable $0 contient toujours le nom du script et la variable $# contient le nombre de paramètres fournis sur la ligne de commande. Variable $@ est une chaîne qui contient tous les paramètres de la ligne de commande.

#!/bin/bash

printf "This script is called: %sn" $0
printf "You used %d command line parametersn" $#

# loop through the variables
for param in "$@"; do
  echo "$param"
done

echo "Parameter 2 was:" $2

Ce script utilise $0 et $# pour imprimer certaines informations. puis utilise ?@ pour parcourir tous les paramètres de la ligne de commande. Il utilise $2 pour montrer comment accéder à une seule valeur de paramètre particulière.

./script11.sh

Envelopper plusieurs mots entre guillemets «  » » les combine en un seul paramètre.

6. Lecture de données à partir de fichiers

Savoir lire les données d’un fichier est une grande compétence à avoir. Nous pouvons le faire dans Bash avec une boucle while.

#!/bin/bash

LineCount=0

while IFS='' read -r LinefromFile || [[ -n "${LinefromFile}" ]]; do

  ((LineCount++))
  echo "Reading line $LineCount: ${LinefromFile}"

done < "$1"

Nous transmettons le nom du fichier que nous voulons que le script traite en tant que paramètre de ligne de commande. Ce sera le seul paramètre, donc à l’intérieur du script $1 contiendra le nom du fichier. Nous redirigeons ce fichier vers le while boucle.

La while boucle définit le séparateur de champ interne sur une chaîne vide, à l’aide de la IFS='' mission. Cela empêche le read commande de diviser les lignes au niveau des espaces. Seul le retour chariot en fin de ligne est considéré comme la vraie fin de ligne.

La [[ -n "${LinefromFile}" ]] La clause couvre la possibilité que la dernière ligne du fichier ne se termine pas par un retour chariot. Même si ce n’est pas le cas, cette dernière ligne sera gérée correctement et traitée comme une ligne normale conforme à POSIX.

./script12.sh twinkle.txt

7. Utiliser des tests conditionnels

Si vous souhaitez que votre script exécute différentes actions pour différentes conditions, vous devez effectuer des tests conditionnels. La syntaxe de test à double crochet offre un nombre écrasant d’options.

#!/bin/bash

price=$1

if [[ price -ge 15 ]];
then
  echo "Too expensive."
else
  echo "Buy it!"
fi

Bash fournit un ensemble complet d’opérateurs de comparaison qui vous permettent de déterminer, par exemple, si un fichier existe, si vous pouvez le lire, si vous pouvez y écrire et si un répertoire existe.

Il a également des tests numériques pour les égaux -qeplus grand que -gtinférieur ou égal -leet ainsi de suite, bien que vous puissiez également utiliser le familier == , >= , <= notation.

./script13.sh 13

./script13.sh 14

./script13.sh 15

./script13.sh 16

8. La puissance des boucles for

Il est préférable de répéter des actions encore et encore en utilisant des boucles. UN for loop vous permet d’exécuter une boucle plusieurs fois. Cela peut aller jusqu’à un certain nombre, ou jusqu’à ce que la boucle ait parcouru une liste d’éléments.

#!/bin/bash

for (( i=0; i<=$1; i++ ))
do
  echo "C-style for loop:" $i
done

for i in {1..4}
do
  echo "For loop with a range:" $i
done

for i in "zero" "one" "two" "three"
do
  echo "For loop with a list of words:" $i
done

website="How To Geek"

for i in $website
do
  echo "For loop with a collection of words:" $i
done

Toutes ces boucles sont for boucles, mais ils travaillent avec différents types d’instructions de boucle et de données.

./script14.sh 3

La première boucle est un style C classique for boucle. Le compteur de boucle i est initialisé à zéro, et incrémenté à chaque cycle de la boucle. Alors que la valeur de i est inférieur ou égal à la valeur détenue dans $1la boucle continuera à s’exécuter.

La deuxième boucle parcourt la plage de nombres de 1 à 4. La troisième boucle parcourt une liste de mots. Tant qu’il y a plus de mots à traiter, la boucle continue de se répéter.

La dernière boucle parcourt la liste de mots dans une variable de chaîne.

9. Fonctions

Les fonctions vous permettent d’encapsuler des sections de code dans des routines nommées qui peuvent être appelées de n’importe où dans votre script.

Supposons que nous voulions que notre script qui lit les lignes d’un fichier effectue une sorte de traitement sur chaque ligne. Il serait pratique d’avoir ce code contenu dans une fonction.

#!/bin/bash

LineCount=0

function count_words() {
  printf "%d words in line %dn" $(echo $1 | wc -w) $2
}

while IFS='' read -r LinefromFile || [[ -n "${LinefromFile}" ]]; do

  ((LineCount++))
  count_words "$LinefromFile" $LineCount

done < "$1"

count_words "This isn't in the loop" 99

Nous avons modifié notre programme de lecture de fichiers en ajoutant une fonction appelée count_words. Il est défini avant de nous devons l’utiliser.

La définition de la fonction commence par le mot function. Ceci est suivi d’un nom unique pour notre fonction suivi de parenthèses « ().” Le corps de la fonction est contenu entre accolades « {} ».

La définition de la fonction ne provoque l’exécution d’aucun code. Rien dans la fonction n’est exécuté tant que la fonction n’est pas appelée.

La count_words fonction imprime le nombre de mots dans une ligne de texte et le numéro de ligne. Ces deux paramètres sont passés dans la fonction tout comme les paramètres sont passés dans un script. Le premier paramètre devient fonction variable $1et le deuxième paramètre devient la variable de fonction $2etc.

La while boucle lit chaque ligne du fichier et la transmet au count_words fonction, ainsi que le numéro de ligne. Et juste pour montrer que nous pouvons appeler la fonction à partir de différents endroits dans le script, nous l’appelons une fois de plus en dehors du while boucle.

./script15.sh twinkle.txt

Ne craignez pas la courbe d’apprentissage

La rédaction de scripts est gratifiante et utile, mais difficile à comprendre. Une fois que vous aurez acquis des techniques réutilisables, vous pourrez écrire des scripts intéressants assez facilement. Ensuite, vous pouvez vous pencher sur des fonctionnalités plus avancées.

Marchez avant de pouvoir courir et prenez le temps de profiter du voyage.