Como chamar um shell script de outro shell script?

Eu tenho dois scripts de shell a.she b.sh.

Como posso chamar b.shde dentro do script de shell a.sh?

Existem algumas maneiras diferentes de fazer isso:

1. Torne o outro script executável, adicione a #!/bin/bashlinha na parte superior e o caminho em que o arquivo está para a variável de ambiente $ PATH. Então você pode chamá-lo como um comando normal;

2. Ou chame-o com o sourcecomando (alias is .) assim source /path/to/script:;

3. Ou use o bashcomando para executá-lo: /bin/bash /path/to/script;

Os primeiro e terceiro métodos executam o script como outro processo, portanto, variáveis ​​e funções no outro script não estarão acessíveis.
O segundo método executa o script no processo do primeiro script e extrai variáveis ​​e funções do outro script para que possam ser utilizadas no script de chamada.

No segundo método, se você estiver usando exitno segundo script, ele sairá do primeiro script também. O que não acontecerá no primeiro e no terceiro método.

Veja isso.

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

Existem algumas maneiras de fazer isso. Terminal para executar o 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")

Tudo isso está correto para o caminho com espaços !!!

A resposta que eu estava procurando:

( exec "path/to/script" )

Como mencionado, execsubstitui o shell sem criar um novo processo. No entanto , podemos colocá-lo em um subshell, o que é feito usando os parênteses.

EDIT: Na verdade, ( "path/to/script" )é suficiente.

Depende de. Resumidamente ... Se você deseja carregar variáveis ​​no console atual e executar, você pode usar source myshellfile.shno seu código. Exemplo:

!#/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 você deseja apenas executar um arquivo e a única coisa interessante para você é o resultado, você pode:

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

Espero que ajude você. Obrigado.

Você pode usar /bin/shpara chamar ou executar outro script (via seu script real):

 # 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

A saída seria:

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

Basta adicionar em uma linha o que você digitou em um terminal para executar o script!
por exemplo:

#!bin/bash
./myscript.sh &

se o script a ser executado não estiver no mesmo diretório, use o caminho completo do script.
por exemplo: `/ home / user / diretório-script /./ myscript.sh &

Primeiro você precisa incluir o arquivo que você chama:

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

então você chama sua função assim:

#!/bin/bash
my_called_function

Fonte simples irá ajudá-lo. Para Ex.

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

Se você tiver outro arquivo no mesmo diretório, poderá:

bash another_script.sh

ou

source another_script.sh

ou

. another_script.sh

Quando você usa, em bashvez de source, o script não pode alterar o ambiente do script pai. O .comando é o padrão POSIX, enquanto o sourcecomando é um sinônimo de bash mais legível para .(eu prefiro sourcesobre .). Se o seu script residir em outro lugar, forneça o caminho para esse script. O caminho relativo e o caminho completo devem funcionar.

A resposta superior sugere adicionar #!/bin/bashlinha à primeira linha do sub-script que está sendo chamado. Mas mesmo se você adicionar o shebang, é muito mais rápido ^* executar um script em um sub-shell e capturar a saída:

$(source SCRIPT_NAME)

Isso funciona quando você deseja continuar executando o mesmo intérprete (por exemplo, do bash para outro script do bash) e garante que a linha shebang do sub-script não seja executada.

Por exemplo:

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

Resultado:

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

^* Por exemplo, quando ferramentas de vírus ou segurança estão sendo executadas em um dispositivo, pode levar mais 100ms para executar um novo 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=$?

Suponha que o novo arquivo seja "/ home / satya / app / app_specific_env" e o conteúdo do arquivo seja o seguinte

#!bin/bash

export FAV_NUMBER="2211"

Anexe esta referência de arquivo ao arquivo ~ / .bashrc

source /home/satya/app/app_specific_env

Sempre que você reiniciar a máquina ou conectar-se novamente, tente echo $FAV_NUMBERno terminal. Isso produzirá o valor.

Apenas no caso, se você quiser ver o efeito imediatamente, source ~/.bashrcna linha de comando.

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

Essa era a única coisa que eu precisava. Depois que o script a ser executado for executável dessa maneira, você (pelo menos no meu caso) não precisará de nenhuma outra operação extra, como shou./ enquanto estiver chamando o script.

Graças ao comentário de @Nathan Lilienthal

Existem alguns problemas para importar funções de outro arquivo.
Primeiro : você não precisa executar este arquivo. Melhor não fazer isso! basta adicionar

. file

para importar todas as funções. E todos eles serão como se estivessem definidos no seu arquivo.
Segundo : você pode definir a função com o mesmo nome. Será substituído. É mau. Você pode declarar assim

declare -f new_function_name=old_function_name 

e somente depois disso importamos. Portanto, você pode chamar a função antiga pelo novo nome.
Terceiro : você pode importar apenas a lista completa de funções definidas no arquivo. Se alguns não forem necessários, você pode desmarcá-los. Mas se você reescrever suas funções após a desativação, elas serão perdidas. Mas se você definir a referência conforme descrito acima, poderá restaurar após a definição com o mesmo nome.
FinalmenteNo procedimento comum de importação é perigoso e não é tão simples. Seja cuidadoso! Você pode escrever um script para fazer isso mais fácil e seguro. Se você usar apenas parte das funções (não todas), é melhor dividi-las em arquivos diferentes. Infelizmente, essa técnica não se saiu bem no bash. No python, por exemplo, e em outras linguagens de script, é fácil e seguro. É possível fazer importação parcial apenas das funções necessárias com seus próprios nomes. Todos nós queremos que nas próximas versões do mato seja feita a mesma funcionalidade. Mas agora precisamos escrever muitos bacalhaus adicionais para fazer o que quiser.

Use retalhos.

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

Em seguida, busque a saída do script produtor como um argumento no script consumidor.