Come chiamare uno script di shell da un altro script di shell?

Ho due script di shell a.she b.sh.

Come posso chiamare b.shdall'interno dello script della shell a.sh?

Ci sono un paio di modi diversi per farlo:

1. Rendi eseguibile l'altro script, aggiungi la #!/bin/bashriga in alto e il percorso in cui il file si trova nella variabile di ambiente $ PATH. Quindi puoi chiamarlo come un normale comando;

2. Oppure chiamalo con il sourcecomando (alias is .) in questo modo source /path/to/script:;

3. Oppure utilizzare il bashcomando per eseguirlo: /bin/bash /path/to/script;

Il primo e il terzo metodo eseguono lo script come un altro processo, quindi le variabili e le funzioni nell'altro script non saranno accessibili.
Il secondo metodo esegue lo script nel processo del primo script e inserisce variabili e funzioni dall'altro script in modo che siano utilizzabili dallo script chiamante.

Nel secondo metodo, se si utilizza exitnel secondo script, uscirà anche il primo script. Che non accadrà con il primo e il terzo metodo.

Controllalo.

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

Ci sono un paio di modi per farlo. Terminale per eseguire lo 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")

Tutto questo è corretto per il percorso con spazi !!!

La risposta che stavo cercando:

( exec "path/to/script" )

Come accennato, execsostituisce la shell senza creare un nuovo processo. Tuttavia , possiamo metterlo in una subshell, che viene eseguita usando le parentesi.

EDIT: in realtà ( "path/to/script" )è abbastanza.

Dipende da. Brevemente ... Se vuoi caricare variabili sulla console corrente ed eseguire puoi usare source myshellfile.shil tuo codice. Esempio:

!#/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

Se vuoi solo eseguire un file e l'unica cosa interessante per te è il risultato, puoi fare:

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

Spero ti aiuti. Grazie.

Puoi usare /bin/shper chiamare o eseguire un altro script (tramite il tuo script reale):

 # 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

L'output sarebbe:

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

Basta aggiungere in una riga qualunque cosa tu abbia digitato in un terminale per eseguire lo script!
per esempio:

#!bin/bash
./myscript.sh &

se lo script da eseguire non si trova nella stessa directory, basta usare il percorso completo dello script.
ad esempio: `/ home / user / directory-script /./ myscript.sh &

Per prima cosa devi includere il file che chiami:

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

quindi chiamate la vostra funzione in questo modo:

#!/bin/bash
my_called_function

La fonte semplice ti aiuterà. Per es.

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

Se hai un altro file nella stessa directory, puoi fare:

bash another_script.sh

o

source another_script.sh

o

. another_script.sh

Quando si utilizza bashinvece di source, lo script non può modificare l'ambiente dello script principale. Il .comando è POSIX standard mentre sourcecommand è un sinonimo bash più leggibile per .(preferisco sourceover .). Se il tuo script risiede altrove, basta fornire il percorso a quello script. Sia il percorso relativo che quello completo dovrebbero funzionare.

La risposta in alto suggerisce di aggiungere una #!/bin/bashriga alla prima riga del sotto-script chiamato. Ma anche se aggiungi lo shebang, è molto più veloce ^* eseguire uno script in una sotto-shell e catturare l'output:

$(source SCRIPT_NAME)

Funziona quando si desidera continuare a eseguire lo stesso interprete (ad es. Da bash a un altro script bash) e garantisce che la riga shebang dello script secondario non venga eseguita.

Per esempio:

#!/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

Produzione:

~ ❯❯❯ 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

^* Ad esempio, quando un dispositivo antivirus o di sicurezza è in esecuzione su un dispositivo, potrebbero essere necessari altri 100 ms per eseguire un nuovo processo.

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=$?

Supponiamo che il nuovo file sia "/ home / satya / app / app_specific_env" e che il contenuto del file sia il seguente

#!bin/bash

export FAV_NUMBER="2211"

Aggiungi questo riferimento al file ~ / .bashrc

source /home/satya/app/app_specific_env

Ogni volta che riavvii la macchina o accedi nuovamente, prova echo $FAV_NUMBER nel terminale. Produrrà il valore.

Nel caso in cui si desideri vedere subito l'effetto, source ~/.bashrcnella riga di comando.

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

Questa era l'unica cosa di cui avevo bisogno. Una volta che lo script da eseguire è reso eseguibile in questo modo, tu (almeno nel mio caso) non hai bisogno di altre operazioni extra come sho ./mentre stai chiamando lo script.

Grazie al commento di @Nathan Lilienthal

Ci sono alcuni problemi per importare funzioni da altri file.
Primo : non è necessario eseguire questo file eseguibile. Meglio non farlo! basta aggiungere

. file

per importare tutte le funzioni. E tutti saranno come se fossero definiti nel tuo file.
Secondo : è possibile definire la funzione con lo stesso nome. Sarà sovrascritto. È cattivo. Puoi dichiarare così

declare -f new_function_name=old_function_name 

e solo dopo ciò importa. Quindi puoi chiamare la vecchia funzione con un nuovo nome.
Terzo : è possibile importare solo l'elenco completo delle funzioni definite nel file. Se alcuni non sono necessari, è possibile annullarli. Ma se riscrivi le tue funzioni dopo averle disattivate, andranno perse. Ma se si imposta il riferimento come descritto sopra, è possibile ripristinare dopo non impostato con lo stesso nome.
FinalmenteNella procedura comune di importazione è pericoloso e non così semplice. Stai attento! Puoi scrivere uno script per farlo in modo più semplice e sicuro. Se usi solo una parte delle funzioni (non tutte) meglio dividerle in file diversi. Purtroppo questa tecnica non ha funzionato bene in bash. In python per esempio e in alcuni altri linguaggi di script è facile e sicuro. È possibile effettuare l'importazione parziale solo delle funzioni necessarie con i propri nomi. Vogliamo tutti che nelle prossime versioni di Bush si ottenga la stessa funzionalità. Ma ora dobbiamo scrivere molti altri codici in modo da fare quello che vuoi.

Usa i backtick.

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

Quindi recupera l'output dello script del produttore come argomento sullo script del consumatore.