Como carregar Shell Script externo da melhor maneira ? [RESOLVIDO]

Olá Shelleiros plantonistas !!!

Estou caminhando no aprendizado e preciso entender melhor as diferenças quando carregar algum Shell Script externo, a saber:

Quando carrego um script externo usando o source, com ou sem parâmetros.

$ source ProgressBar.sh 5 # Na minha visão ele funciona como se estivesse no mesmo arquivo após chamado a primeira vez.

$ . PauseScript.sh "$TEMP_MSG" # Colocando o ponto com espaço antes do nome do Script. Qual a diferença prática ?

$ PauseScript.sh "$TEMP_MSG" # Chamando o arquivo direto com parâmetro. Parece ser bem diferente dos 2 outros acima. Tenho problema com variáveis de retorno.

Procurei por artigos sobre estas diferenças, mas não achei. Encontrei até artigos falando sobre a questão do source, outro sobre o [.] com o espaço antes do nome do SCRIPT SHELL. Aliás rsrs, foi aqui que aprendi a usa-los.

Quem puder passar detalhes ou indicar algum material que tenha comparativos entre as 3 maneiras de carregar scripts externos, por favor, estou precisando.

Qual das 3 maneiras é a melhor para chamar scripts externos que TEM dentro deles várias funções ?

Existe algum pulo do gato para passar parâmetros para as funções dentro de cada tipo de carregamento diferente ?

Se alguma pergunta for absurda, rsrs, releve por favor. Tô me esforçando para aprender este trem certinho porque vou precisar e MUITO :)

Obrigado e a disposição.

GA

Olá, estou programando em SHELL SCRIPT há alguns meses, e já peguei alguns detalhes como os que você sitou.

source ProgressBar.sh 5
-> Funciona como include do PHP, é como você falou ele carrega o arquivo para dentro do script que o chamou e acaba fazendo parte da mesma sessão do SHELL, as variáveis definidas fazem parte do mesmo escopo, tome cuidado :-)

. PauseScript.sh "$TEMP_MSG"
-> Funciona como o source, é apenas um atalho para o mesmo.

PauseScript.sh "$TEMP_MSG"
-> Funciona bem diferente mesmo, ele abre mais uma sessão do SHELL, dai a sua perda de variáveis :-), o que você pode fazer nesse caso é criar variáveis GLOBAIS :-), fazendo:

export NOME_DA_VARIÁVEL

ai ela pode ser acessada em ambos os scripts.

Pode também colocar retornos, mas deve tomar cuidado pois deve ser um simples:
echo $VALOR_RETORNO

ai no script que espera o retorno coloca:

VARIAVEL=$(./nome_script.sh)

-----------------

Estou usando os dois modos nos meus programas, geralmente uso o source apenas para carregar arquivos com funções úteis para outro script usar, como se fosse uma biblioteca.


Abraços

Adicionando algo a mais ao que o colega escreveu acima...


O source ou '.' inclui o arquivo e geralmente é muito usado para incluir funções - procedimentos, acho isso uma maneira de oferecer algum suporte de programação de objetos mas de maneira tosca.

Veja que o arquivo incluído através do source não necessita de permissões de execução. Ele funciona com um atalho para uma linha de comando como essa a seguir...

eval "$( cat include.sh )"

Chamando o arquivo pelo caminho você estará o executando como um comando, e portanto o arquivo necessita de permissão de execução.

Prefira o uso do source no lugar do . (ponto), pois um ponto no meio do código fica quase ilegível.

A mesma coisa para o `comando` (crase), prefira usar o $(comando)

Olá @rai3mb , @ronin :)

Ok. Entendi bem claro agora a questão do source ou o espaço .(ponto) meuscript. Tanto um quanto outro passam a fazer parte do mesmo script. Não sabia que ele era uma forma de atalho para chamar outros scripts como foi mostrado no caso do eval.

Continuo na dúvida como e quando sou obrigado a usar o eval rsrs. Em que condições ele é obrigatório. Até onde estou lendo, nunca é recomendado usar o eval.

Sobre a integração com PHP é um outro assunto que interessa muito. Passar parâmetros do PHP para SHELL SCRIPT e vice versa. Acho que este assunto pode ficar para outra dúvida na comunidade.

Sobre a questão do escopo das variáveis, eu entendi que se eu tenho as variáveis já criadas antes de chamar via source o próximo script, ao entrar nele, elas continuam valendo.

Sobre o export NOME_DA_VARIÁVEL , ainda não usei. Já li a respeito e me parece que serve para conseguir passar os valores ao próximo SHELL SCRIPT chamado na forma VARIAVEL=$(./nome_script.sh) e lá dentro elas ainda continuarão valendo. Não sei como funciona na prática. Vou testar.

A minha necessidade em variáveis exportadas é fazer o contrário. Conseguir alterar a variável dentro de outro SHELL SCRIPT e receber o valor alterado de volta.
Até agora não consegui receber o retorno alterado. Também não usei o export rsrs.

Dúvida: Variáveis GLOBAIS devem ser só no 1° SHELL SCRIPT ? Ou podem ser feitas nos secundários ? Se sim, qual a forma correta ?

Retorno de SHELL SCRIPT secundário.

Para retornar valor de um SHELL SCRIPT secundário a última linha tem sempre que ser conforme abaixo ?

$ echo $VALOR_RETORNO

E se eu preciso de vários retornos e não apenas 1 ? O retorno pode ser array ? (Ainda nem usei , mas em php pode.)

Percebi que colocar as funções no início do script fica ruim para acompanhar.
Estou separando tudo em funções, desde que tenham a possibilidade de se repetir, exemplo:

MsgProg.sh - Lá estou colocando todas as mensagens que o script irá enviar na tela e que de alguma forma podem ser repetidas em outros locais do Script.

Dentro tem um função _HelpProg() que irá receber 1 parâmetro. Ele irá indicar qual é a mensagem a ser mostrada na tela.

Estou fazendo desta forma para entender como funcionam as passagens de parâmetros e os retornos. Só está funcionando bem se eu coloco a chamada como source.

Após declarar todas as variáveis necessárias, faço uma chamada ao source MsgProg.sh sem nenhum parâmetro.

No local onde eu preciso, faço a referência a função que existe no MsgProg.sh da seguinte forma: _HelpProg 0
Está correto fazer dessa forma ? Existe uma forma melhor ?

Percebi como já foi citado, que usando o source o arquivo carregado nem precisa de permissão de execução. É verdade mesmo rsrs, nem tinha dado permissão para estes outros arquivos e estavam funcionando. Aprendi mais uma, que perigo.

Pelo que pude entender, não posso usar variáveis na linha do source por questões de segurança. Um variável maliciosa poderia fazer a execução de algum comando não esperado.

Sobre as variáveis dentro das funções.
======================================

Todas as variáveis criadas até o momento dentro de funções estou deixando como local.
Falta entender melhor quando eu precisar alterar um valor já existente e devolver este retorno a quem chamou alterado.

Obrigado novamente ao @rai3mb e @ronin por ajudar com as dúvidas.

GA

ps: Tenho a péssima mania de escrever todo o texto aqui e tentar enviar e já expirou a geripoca rsrs. Já perdi vários textos. Tô salvando antes de enviar para não perder.

[cidtando] @rai3mb
Prefira o uso do source no lugar do . (ponto), pois um ponto no meio do código fica quase ilegível.

A mesma coisa para o `comando` (crase), prefira usar o $(comando)
[/citando]

Já parei de usar o lance do . (ponto) ontem rsrs. Valeu.
Também estou revendo onde usei a (crase) e vou mudar para como foi sugerido.

:-), viu até para achar as benditas crases fica difícil depois.

Prefira sempre deixar mais legível, pois conforme o tempo for passando, o código vai crescendo e a manutenção pode ficar mais difícil se o código não tiver bem organizado e legível.

Abraços

Citando: "ps: Tenho a péssima mania de escrever todo o texto aqui e tentar enviar e já expirou a geripoca rsrs. Já perdi vários textos. Tô salvando antes de enviar para não perder."


Peguei a mania de digitar o texto e depois CTRL+A (selecionando todo o texto) CTRL+C (copiando) ai depois digito o captcha (código), caso der erro, basta digitar colar o texto novamente :-)

Registrando pendências:

[citando]
"Continuo na dúvida como e quando sou obrigado a usar o eval rsrs."
[/citando]

Com base em vários artigos aqui no VOL, o eval é usado para passar o controle a um nova variável nomeando outra variável. Útil para chamadas recursivas onde teremos outros valores de nome ou até mesmo a inclusão de novos Scripts. É um tipo de & (macro expandida) que passa o controle ao próximo que executa. E o programador tende a perder o controle sobre ela. Tudo pode acontecer se não for bem utilizado.

[citando]
Sobre o export NOME_DA_VARIÁVEL , ainda não usei. Já li a respeito e me parece que serve para conseguir passar os valores ao próximo SHELL SCRIPT chamado na forma VARIAVEL=$(./nome_script.sh) e lá dentro elas ainda continuarão valendo. Não sei como funciona na prática. Vou testar.
[/citando]

Faltam testes com exemplos.

"Dúvida: Variáveis GLOBAIS devem ser só no 1° SHELL SCRIPT ? Ou podem ser feitas nos secundários ? Se sim, qual a forma correta ? "


Retorno de SHELL SCRIPT secundário.
===================================

Para retornar valor de um SHELL SCRIPT secundário a última linha tem sempre que ser conforme abaixo ?

$ echo $VALOR_RETORNO

E se eu preciso de vários retornos e não apenas 1 ? O retorno pode ser array ?

Valeu @rai3mb :)



Isso que citei é apenas uma técnica não uma regra, veja:

[citando]
#!/bin/bash
func_soma() {
a=2
b=3
valor=$((a+b))
echo $valor
}

echo $(func_soma)

5
[/citando]

Perfeito. Esta forma eu já testei.

[citando]
Se quiser vários, como se tiver-se retornando um array

#!/bin/bash
func_soma() {
a=2
b=3
valor=$((a+b))
echo $valor $a $b
}

VAL=($(func_soma))

echo ${VAL[@]}

5 2 3
[/citando]

Esta é nova pra mim VAL[@] !!

Sobre as {} servem pra executar o conteúdo isolado. Deve evitar problemas textos grudados.
Esta forma de referenciar com o @ eu ainda não tinha feito testes.
Valeu mesmo. Já ajudou uma barbaridade :)

Vou dar como encerrado este tópico. As outras dúvidas vou me virando.

GA