Comment appeler un script shell à partir d'un autre script shell?

J'ai deux scripts shell, a.shet b.sh.

Comment puis-je appeler à b.shpartir du script shell a.sh?

Il existe plusieurs façons de procéder:

1. Rendez l'autre script exécutable, ajoutez la #!/bin/bashligne en haut et le chemin d'accès du fichier à la variable d'environnement $ PATH. Ensuite, vous pouvez l'appeler comme une commande normale;

2. Ou appelez-le avec la sourcecommande (alias is .) comme ceci source /path/to/script:;

3. Ou utilisez la bashcommande pour l' exécuter: /bin/bash /path/to/script;

Les première et troisième méthodes exécutent le script comme un autre processus, les variables et fonctions de l'autre script ne seront donc pas accessibles.
La deuxième méthode exécute le script dans le processus du premier script et extrait les variables et les fonctions de l'autre script afin qu'elles soient utilisables à partir du script appelant.

Dans la deuxième méthode, si vous utilisez exitdans le deuxième script, il quittera également le premier script. Ce qui ne se produira pas dans les première et troisième méthodes.

Regarde ça.

#!/bin/bash
echo "This script is about to run another script."
sh ./script.sh
echo "This script has just run another script."

Il existe plusieurs façons de procéder. Terminal pour exécuter le script:

#!/bin/bash
SCRIPT_PATH="/path/to/script.sh"

# Here you execute your script
"$SCRIPT_PATH"

# or
. "$SCRIPT_PATH"

# or
source "$SCRIPT_PATH"

# or
bash "$SCRIPT_PATH"

# or
eval '"$SCRIPT_PATH"'

# or
OUTPUT=$("$SCRIPT_PATH")
echo $OUTPUT

# or
OUTPUT=`"$SCRIPT_PATH"`
echo $OUTPUT

# or
("$SCRIPT_PATH")

# or
(exec "$SCRIPT_PATH")

Tout cela est correct pour le chemin avec des espaces !!!

La réponse que je cherchais:

( exec "path/to/script" )

Comme mentionné, execremplace le shell sans créer de nouveau processus. toutefois , nous pouvons le mettre dans un sous-shell, ce qui se fait en utilisant les parenthèses.

EDIT: En fait, ( "path/to/script" )c'est suffisant.

Dépend de. En bref ... Si vous voulez charger des variables sur la console actuelle et les exécuter, vous pouvez les utiliser source myshellfile.shsur votre code. Exemple:

!#/bin/bash
set -x
echo "This is an example of run another INTO this session."
source my_lib_of_variables_and_functions.sh
echo "The function internal_function() is defined into my lib."
returned_value=internal_function()
echo $this_is_an_internal_variable

set +x

Si vous voulez simplement exécuter un fichier et que la seule chose qui vous intéresse est le résultat, vous pouvez faire:

!#/bin/bash
set -x
./executing_only.sh
sh i_can_execute_this_way_too.sh
bash or_this_way.sh
set +x

J'espère que cela vous aide. Merci.

Vous pouvez utiliser /bin/shpour appeler ou exécuter un autre script (via votre script réel):

 # cat showdate.sh
 #!/bin/bash
 echo "Date is: `date`"

 # cat mainscript.sh
 #!/bin/bash
 echo "You are login as: `whoami`"
 echo "`/bin/sh ./showdate.sh`" # exact path for the script file

La sortie serait:

 # ./mainscript.sh
 You are login as: root
 Date is: Thu Oct 17 02:56:36 EDT 2013

Ajoutez simplement dans une ligne ce que vous auriez tapé dans un terminal pour exécuter le script!
par exemple:

#!bin/bash
./myscript.sh &

si le script à exécuter ne se trouve pas dans le même répertoire, utilisez simplement le chemin complet du script.
par exemple: `/ home / user / script-directory /./ myscript.sh &

Vous devez d'abord inclure le fichier que vous appelez:

#!/bin/bash
. includes/included_file.sh

alors vous appelez votre fonction comme ceci:

#!/bin/bash
my_called_function

Une source simple vous aidera. Pour Ex.

#!/bin/bash
echo "My shell_1"
source my_script1.sh
echo "Back in shell_1"

Si vous avez un autre fichier dans le même répertoire, vous pouvez soit:

bash another_script.sh

ou

source another_script.sh

ou

. another_script.sh

Lorsque vous utilisez bashau lieu de source, le script ne peut pas modifier l'environnement du script parent. La .commande est la norme POSIX tandis que la sourcecommande est un synonyme bash plus lisible pour .(je préfère sourceplus .). Si votre script réside ailleurs, indiquez simplement le chemin d'accès à ce script. Le chemin relatif et le chemin complet devraient fonctionner.

La première réponse suggère d'ajouter une #!/bin/bashligne à la première ligne du sous-script appelé. Mais même si vous ajoutez le shebang, il est beaucoup plus rapide ^* d'exécuter un script dans un sous-shell et de capturer la sortie:

$(source SCRIPT_NAME)

Cela fonctionne lorsque vous souhaitez continuer à exécuter le même interpréteur (par exemple de bash vers un autre script bash) et garantit que la ligne shebang du sous-script n'est pas exécutée.

Par exemple:

#!/bin/bash
SUB_SCRIPT=$(mktemp)
echo "#!/bin/bash" > $SUB_SCRIPT
echo 'echo $1' >> $SUB_SCRIPT
chmod +x $SUB_SCRIPT
if [[ $1 == "--source" ]]; then
  for X in $(seq 100); do
    MODE=$(source $SUB_SCRIPT "source on")
  done
else
  for X in $(seq 100); do
    MODE=$($SUB_SCRIPT "source off")
  done
fi
echo $MODE
rm $SUB_SCRIPT

Production:

~ ❯❯❯ time ./test.sh
source off
./test.sh  0.15s user 0.16s system 87% cpu 0.360 total

~ ❯❯❯ time ./test.sh --source
source on
./test.sh --source  0.05s user 0.06s system 95% cpu 0.114 total

^* Par exemple, lorsque des virus ou des outils de sécurité s'exécutent sur un appareil, cela peut prendre 100 ms supplémentaires pour exécuter un nouveau processus.

pathToShell="/home/praveen/"   
chmod a+x $pathToShell"myShell.sh"
sh $pathToShell"myShell.sh"

 #!/bin/bash

 # Here you define the absolute path of your script

 scriptPath="/home/user/pathScript/"

 # Name of your script

 scriptName="myscript.sh"

 # Here you execute your script

 $scriptPath/$scriptName

 # Result of script execution

 result=$?

Supposons que le nouveau fichier est "/ home / satya / app / app_specific_env" et que le contenu du fichier est le suivant

#!bin/bash

export FAV_NUMBER="2211"

Ajoutez cette référence de fichier au fichier ~ / .bashrc

source /home/satya/app/app_specific_env

Chaque fois que vous redémarrez la machine ou vous reconnectez, essayez echo $FAV_NUMBERdans le terminal. Il affichera la valeur.

Au cas où vous voudriez voir l'effet immédiatement, source ~/.bashrcdans la ligne de commande.

chmod a+x /path/to/file-to-be-executed

C'était la seule chose dont j'avais besoin. Une fois que le script à exécuter est rendu exécutable comme ceci, vous (du moins dans mon cas) n'avez besoin d'aucune autre opération supplémentaire comme shou ./pendant que vous appelez le script.

Merci au commentaire de @Nathan Lilienthal

Il y a quelques problèmes pour importer des fonctions à partir d'un autre fichier.
Premièrement : vous n'avez pas besoin de faire ce fichier exécutable. Mieux vaut ne pas le faire! Ajoutez simplement

. file

pour importer toutes les fonctions. Et tous seront comme s'ils étaient définis dans votre fichier.
Deuxièmement : vous pouvez définir la fonction avec le même nom. Il sera écrasé. C'est mauvais. Vous pouvez déclarer comme ça

declare -f new_function_name=old_function_name 

et seulement après cela, importez. Vous pouvez donc appeler l'ancienne fonction par un nouveau nom.
Troisièmement : vous ne pouvez importer que la liste complète des fonctions définies dans le fichier. Si certains ne sont pas nécessaires, vous pouvez les désactiver. Mais si vous réécrivez vos fonctions après leur désactivation, elles seront perdues. Mais si vous lui définissez une référence comme décrit ci-dessus, vous pouvez restaurer après unset avec le même nom.
finalementDans la procédure courante d'importation, il est dangereux et pas si simple. Faites attention! Vous pouvez écrire un script pour le faire plus facilement et en toute sécurité. Si vous n'utilisez qu'une partie des fonctions (pas toutes), mieux vaut les diviser en différents fichiers. Malheureusement cette technique n'a pas bien fonctionné en bash. En python par exemple et dans d'autres langages de script, c'est simple et sûr. Possibilité de faire de l'importation partielle uniquement les fonctions nécessaires avec ses propres noms. Nous voulons tous que dans les prochaines versions de bush, la même fonctionnalité soit exécutée. Mais maintenant, nous devons écrire beaucoup de morue supplémentaire pour faire ce que vous voulez.

Utilisez des backticks.

$ ./script-that-consumes-argument.sh `sh script-that-produces-argument.sh`

Récupérez ensuite la sortie du script producteur comme argument sur le script consommateur.