Apprenez la différence entre l'approvisionnement et la fourniture de bash

L'objectif principal de cet article est de comprendre clairement ce qui se passe lorsque vous exécutez le script vs source Le script en bash. Premièrement, nous comprendrons clairement comment le programme est soumis lorsque vous appelez le script de différentes manières.

NOTE: Créer le 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 des commentaires mais case a une signification particulière. Il dit à Bash de soumettre le programme dans n'importe quel interprète que vous avez mentionné 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.shot 

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

• Utilisez un chemin relatif pour appeler le script. Passez au répertoire où le script est présent et exécutez ./Bonjour le monde.shot.
• Utilisez le chemin absolu pour appeler le script. De n'importe où dans le système de fichiers Tapez le chemin complet du script.

$ ./Bonjour le monde.sh $ pwd $ / home / karthick / hello_world 

Exécuter le script shell

Voyons maintenant ce qui se passe lorsque vous essayez de soumettre votre programme sans case. En absence de case, Le programme sera soumis à tout shell actuel avec lequel vous utilisez, dans mon cas, c'est Frapper (/ bac / bash).

Laissez-moi dé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ète Python, mais 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 

Mauvais interprète dans le script

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.

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

Script d'appel avec l'interprète

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

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

Farding

Il peut y avoir plusieurs processus d'enfants dans le cadre du script et cela dépend de notre code. Il convient de noter que les variables environnementales créées par l'indice seront supprimées une fois qu'il sera 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 de l'enfant.

Jetez un œil aux articles ci-dessous pour mieux comprendre le fonctionnement des variables et comment exporter les variables.

• Comprendre et écrire des «variables linux» dans les scripts shell
• Apprenez la différence entre $$ et $ Bashpid dans Bash

Sourcer le script

"Source"Est une commande intégrée de shell qui lit le fichier passé comme un argument et exécute le code dans l'environnement shell actuel. Un cas d'utilisation approprié que vous utilisez principalement est de modifier votre configuration dans .bashrc ou .bash_profile et recharger les modifications en utilisant le commande de source.

$ type -a source 

Commande de coquille intégrée

Il existe deux façons syntaxiques d'exécuter le commande de source. Vous pouvez choisir n'importe qui dans deux syntaxes et c'est de choix personnel.

$ Source File_name [Arguments] $ . File_name [arguments] 

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

Déposer Module.shot.

#!/ usr / bin / env-bash var1 = $ (echo "bienvenue à 1 $") Fonction f1 () echo "la fonction f1 est appelée" 

Déposer Principal.shot.

#!/ usr / bin / env bash echo $ var1 f1 

Exemples de codes de script

Définissez l'autorisation d'exécution pour le script et appelez le script principal "principal.sh ”. Maintenant, ce script essaiera de trouver la fonction F1 et variable Var1 dans l'environnement de coquille actuel et échouera avec la commande introuvable.

$ bash Main.shot 

Avant d'approvisionner le script

Exécutons maintenant la commande source à l'intérieur du script qui chargera la variable et les fonctions dans l'environnement de coquille actuel et qui sera accessible par "principal.sh ”.

Déposer Module.shot.

#!/ usr / bin / env-bash var1 = $ (echo "bienvenue à 1 $") Fonction f1 () echo "La fonction f1 est appelée" 

Déposer Principal.shot.

#!/ USR / BIN / ENV BASH SOURCE MODULE.sh tecmint echo $ var1 f1 

Exemples de codes de script avec source

Maintenant, exécutez le script et voyez.

$ bash Main.shot 

Après avoir approché le script

Le source est très utile dans frapper Pour suivre l'approche de programmation modulaire dans la création de nos scripts de coquille. Nous pouvons diviser notre code en modules plus petits et pouvons être utilisés dans de nombreux programmes. De cette manière, nous pouvons suivre le SEC (Ne te répétez pas) principe.

C'est tout pour cet article. Nous avons brièvement discuté de la différence entre l'approvisionnement et la fancement de Bash. Parcourez l'article et partagez vos précieux commentaires avec nous.