L’objectif principal de cet article est de comprendre clairement ce qui se passe lorsque vous exécutez le script vs source le script dans bash. Tout d’abord, nous comprendrons clairement comment le programme est soumis lorsque vous appelez le script de différentes manières.

REMARQUE: la création du script avec une extension n’a pas d’importance. Le script fonctionnera bien même sans extensions.

Fondamentalement, chaque script commence par une ligne appelée case(#!). Le Hacher le symbole en bash sera interprété comme un commentaire mais case a une signification particulière. Il dit à bash de soumettre le programme dans n’importe quel interprète que vous avez mentionné dans case.

Vous trouverez ci-dessous un exemple de programme et je spécifie bash comme interprète.

$ cat >> Hello_World.sh
#!/usr/bin/env bash
echo "Hello world"

$ chmod +x Hello_world.sh

Maintenant, pour exécuter le script, vous pouvez le faire de deux manières.

• Utilisez un chemin relatif pour appeler le script. Déplacer vers le répertoire où le script est présent et exécuter ./Hello_world.sh.
• Utilisez le chemin absolu pour appeler le script. De n’importe où dans le système de fichiers, saisissez le chemin d’accès complet au script.

$ ./Hello_world.sh
$ pwd
$ /home/karthick/Hello_world

Voyons maintenant ce qui se passe lorsque vous essayez de soumettre votre programme sans case. En l’absence de case, le programme sera soumis à n’importe quel shell actuel avec lequel vous utilisez, dans mon cas, c’est Frapper (/ bin / bash).

Laissez-moi vous montrer un exemple. Je crée un script python sans case et quand j’appelle le programme, frapper ne sait pas qu’il devrait soumettre ce programme à l’interpréteur python à la place, il exécutera le programme dans le shell actuel.

$ cat > run-py.py
echo $SHELL
print("Hello world")

$ chmod +x run-py.py
$ ./run-py.py

Dans ce cas, vous pouvez appeler le programme en mentionnant sur quel interprète il doit être soumis ou simplement ajouter le case ligne qui est toujours recommandée.

# which python3
$(which python3) /home/karthick/run_py.py

Maintenant que vous savez comment appeler le script, l’étape suivante consiste à comprendre ce qui se passe lorsque nous appelons le script. Lorsque vous appelez le script comme indiqué dans les exemples ci-dessus, il créera un processus enfant (fourche) et le script sera soumis au processus enfant. J’ai exécuté un exemple de script qui exécutera simplement la commande suivante et montre que le script est soumis à un processus enfant.

$ ps -ef --forest | grep -i bash

Il peut y avoir plusieurs processus enfants dans le cadre du script et cela dépend de notre code. Il est à noter que les variables d’environnement créées par l’indice seront supprimées une fois terminé. Un processus enfant peut accéder aux variables créées par le processus parent en les exportant. Mais le processus parent ne peut pas accéder aux variables créées par le processus enfant.

Jetez un œil aux articles ci-dessous pour en savoir plus sur le fonctionnement des variables et comment exporter les variables.

Recherche du script

« La source»Est une commande intégrée au shell qui lit le fichier qui lui est passé comme argument et exécute le code dans l’environnement shell actuel. Un cas d’utilisation approprié que vous utilisez principalement est la modification de votre configuration dans .bashrc ou .bash_profile et recharger les modifications à l’aide du commande source.

$ type -a source

Il existe deux manières syntaxiques d’exécuter le commande source. Vous pouvez choisir n’importe qui parmi deux syntaxes et c’est un choix personnel.

$ source FILE_NAME [ARGUMENTS]
$ . FILE_NAME [ARGUMENTS]

Laissez-moi vous montrer comment la source fonctionne réellement. Je vais créer deux scripts shell. Le premier script (Module.sh) va contenir certaines variables et fonctions. Le deuxième script (Main.sh) va imprimer la variable et appeler la fonction.

Déposer Module.sh.

#!/usr/bin/env bash

VAR1=$(echo "Welcome to $1")

function f1(){
  echo “Function f1 is called”
}

Déposer Main.sh.

#!/usr/bin/env bash

echo $VAR1
f1

Définissez l’autorisation d’exécution du script et appelez le script principal « Main.sh ». Maintenant, ce script essaiera de trouver la fonction f1 et variable VAR1 dans l’environnement shell actuel et échouera avec la commande introuvable.

$ bash main.sh

Maintenant, exécutons la commande source à l’intérieur du script qui chargera la variable et les fonctions dans l’environnement shell actuel et qui sera accessible par « Main.sh ».

Déposer Module.sh.

#!/usr/bin/env bash

VAR1=$(echo "Welcome to $1")

function f1(){
  echo "Function f1 is called"
}

Déposer Main.sh.

#!/usr/bin/env bash

source module.sh Tecmint
echo $VAR1
f1

Maintenant, exécutez à nouveau le script et voyez.

$ bash main.sh

Le la source est très utile dans frapper suivre l’approche de programmation modulaire en créer nos scripts shell. Nous pouvons diviser notre code en modules plus petits et peut être utilisé dans de nombreux programmes. De cette manière, nous pouvons suivre le SÉCHER (Ne vous répétez pas) principe.

Voilà pour cet article. Nous avons brièvement discuté de la différence entre l’approvisionnement et le forking dans bash. Parcourez l’article et partagez vos précieux commentaires avec nous.

Si vous appréciez ce que nous faisons ici sur TecMint, vous devriez considérer:

TecMint est le site communautaire à la croissance la plus rapide et le plus fiable pour tout type d’articles, de guides et de livres Linux sur le Web. Des millions de personnes visitent TecMint! pour rechercher ou parcourir les milliers d’articles publiés disponibles GRATUITEMENT à tous.

Si vous aimez ce que vous lisez, pensez à nous acheter un café (ou 2) en guise de remerciement.

Nous sommes reconnaissants de votre soutien sans fin.