Qual a melhor forma para receber retornos de função em Shell Script [RESOLVIDO]

13. Re: Qual a melhor forma para receber retornos de função em Shell Script [RESOLVIDO]

Geraldo Albuquerque
AprendiNoLinux

(usa Ubuntu)

Enviado em 18/04/2012 - 15:34h

Ok


  


14. Re: Qual a melhor forma para receber retornos de função em Shell Script [RESOLVIDO]

Geraldo Albuquerque
AprendiNoLinux

(usa Ubuntu)

Enviado em 18/04/2012 - 15:35h

Aproveitando que viramos a página, a próxima etapa.

AprendiNoLinux escreveu:

Parecia estar tudo se resolvendo na questão de retornar valores de funções. Digo, qual a forma certa em cada caso. Por favor, me corrijam se estiver falando besteira.

No livro do Aurélio (Script profissional) diz mais ou menos assim:

Quando criar uma função
-----------------------

o- Quando precisar usar o mesmo trecho de código duas vezes ou mais.
o- Quando quiser pôr em destaque um trecho de código especialista.
o- Quando precisar de recursividade.
o- Quando quiser, funções sempre ajudam.

extras: Sempre use o comando local para proteger todas as variáveis de uma função. [ESTOU TENTANDO kkkk]

Retorno de funções
------------------

o- Funções só podem retornar números de 0 a 255, usando o comando return.
o- Funções podem retornar strings usando o comando echo.
o- Funções podem gravar variáveis globais, MAS EVITE FAZER ISSO.

Então o trecho abaixo é POG.


$ test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}


O que o livro do Aurélio NÃO DIZ
--------------------------------

o- Quando você trabalha com retorno de strings em funções, não deve ecoar dados dentro da função.
o- Se for para retornar dados de strings, procure faze-lo em array.
o- Como recuperar valores lógicos de funções.
o- Como tratar retornos lógicos de funções.
o- Se dentro de sua função possuir muitos componentes visuais (echo de várias etapas), evite fazer chamadas com retorno, ex: ret=$(myfunc "para" "oi")
o

Resumo da ópera
---------------
Hoje quem vai estar em campo não é a minha barcelusa kkkk


Seguindo as recomendações de quem já participou do tópico ou em outras discussões aqui do VOL, MINHAS conclusões. Por favor, é importante criticar o que não estiver certo. Continuar aprendendo errado e ter que mudar código porque se constrói a arquitetura errada é pior do que torcer pra time rebaixado pra segunda divisão rsrs. Você sabe que ele mais cedo ou mais tarde vai cair, só não sabe quando.

o- Dividir os procedimentos ao máximo. (Estou fazendo neste momento, versão em breve.)
o- Separar funções que precisam de retorno lógico em etapas de micro funções.
o- Investigar se preciso mesmo de chamadas de "retorno" na maioria das funções. Via de regra é porque não é genérica.
o- Funções generalizadas não podem conter qualquer variável pública. Se houver gera dependência e precisa de default.
o- Qualquer função tem que trabalhar isolada do código completo ou não deve ser convertida como tal.
o- Se a função tiver dependência de variável GLOBAL, deve ser documentada.
o- Se a função gerar alguma variável GLOBAL, deve via de regra ser lógica.

ps: Não sei se está correto. Estou chamando de variáveis lógicas aquelas que retornam 0,1,2 (ou códigos de erros).

Quem sabe por favor opinar. Quem não sabe é hora de perguntar :) NÃO LEIAM: http://www.fpepito.org/utils/conjugue.php?verbo=opinar


Do jeito que a coisa está indo o resultado do trabalho poderá se tornar um artigo no VOL.




15. Nova reversão que mostra recebimento de parâmetros de forma estruturada.

Geraldo Albuquerque
AprendiNoLinux

(usa Ubuntu)

Enviado em 18/04/2012 - 15:44h

Tentando responder as perguntas e afirmações da postagem anterior, porque parece que o comprimento de uma linha no forum é mais importante que o problema em si, vamos seguindo em frente.

ANTES:



#--------------------------------------------------------------------#
# INÍCIO >>> Diretorios_de_Trabalho()
# Função: Testa a existência dos diretórios e cria ser for necessário.
# RECEBE:
#--------------------------------------------------------------------#
function Diretorios_de_Trabalho()
{

MSG="Estou conferindo os diretórios de trabalho..."
Debug 1 "$MSG [Função:$FUNCNAME Linha:$LINENO]" 2>/dev/null
unset MSG

if ! [ -d "$dir_pasta_pause" ]; then
MSG="Não encontrou diretório PAUSE: $dir_pasta_pause !!!"
Debug 2 1 "$MSG [Função:$FUNCNAME Linha:$LINENO]"
unset MSG
mkdir -p "$dir_pasta_pause" #Criando diretório recursivamente.
MSG="Retornou com algum erro após a criação da pasta:"
Debug 3 1 "$MSG $dir_pasta_pause ? [ $? ]"
fi

if ! [ -d "$dir_pasta_stop" ]; then
MSG="Não encontrou diretório STOP: $dir_pasta_stop !!!"
Debug 2 1 "$MSG [Função:$FUNCNAME Linha:$LINENO]"
mkdir -p "$dir_pasta_stop" #Criando diretório recursivamente.
MSG="Retornou com algum erro após a criação da pasta:"
Debug 3 1 "$MSG $dir_pasta_stop ? [ $? ]"
fi

if ! [ -d "$dir_pasta_servicos" ]; then
MSG="Não encontrou diretório de Serviços: $dir_pasta_servicos "
Debug 3 1 "$MSG !!! [Função:$FUNCNAME Linha:$LINENO]"
mkdir -p "$dir_pasta_servicos" #Criando diretório recursivamente.
MSG="Retornou com algum erro após a criação da pasta:"
Debug 3 1 "$MSG $dir_pasta_servicos ? [ $? ]"
fi

if ! [ -d "$dir_pasta_start" ]; then
MSG="Não encontrou diretório de Inicializações: $dir_pasta_start "
echo "$MSG !!! [Função:$FUNCNAME Linha:$LINENO]"
mkdir -p "$dir_pasta_start" #Criando diretório recursivamente.
MSG="Retornou com algum erro após a criação da pasta:"
Debug 3 1 "$MSG $dir_pasta_start ? [ $? ]"
fi

if ! [ -d "$dir_pasta_origem" ]; then
MSG="Não encontrou diretório das ORIGENS: $dir_pasta_origem"
echo "$MSG !!! [Função:$FUNCNAME Linha:$LINENO]"
mkdir -p "$dir_pasta_origem" #Criando diretório recursivamente.
MSG="Retornou com algum erro após a criação da pasta:"
Debug 3 1 "$MSG $dir_pasta_origem ? [ $? ]"
fi

if ! [ -d "$dir_pasta_restart" ]; then
MSG="Não encontrou diretório de REINÍCIOS: $dir_pasta_restart "
echo "$MSG CRIANDO AGORA !!! [Função:$FUNCNAME Linha:$LINENO]"
mkdir -p "$dir_pasta_restart" #Criando diretório recursivamente.
MSG="Retornou com algum erro após a criação da pasta:"
Debug 3 1 "$MSG $dir_pasta_restart ? [ $? ]"
fi


}
Diretorios_de_Trabalho



NOVA VERSÃO:


#Diretorios_de_Trabalho

function criando_arquivo()
{
local criar_arquivo="$1" informa_no_debug=${2:-0} gravar_log=${3:-0}

# Recebe no 1º parâmetro o nome da pasta a ser criada.
# Teste lógico se terá permissão para gravar já foi feito antes.
# Faz criação de forma recursiva se necessário.
# 2º parâmetro recebe informação se deve usar DEBUG.
# 3º parâmetro diz se precisa gravar LOG.
if [ ${informa_no_debug} -gt 0 ]; then
Debug 1 "Antes de criar a pasta: $criar_a_pasta [F:$FUNCNAME L:$LINENO]"
fi

# mkdir -p "$criar_arquivo"

if [ $? = 1 ]; then
return 1
fi
if [ ${informa_no_debug} -gt 0 ]; then
Debug 1 "Após criar a pasta: $criar_a_pasta [F:$FUNCNAME L:$LINENO]"
fi
}


function criando_pasta()
{
local criar_a_pasta="$1" informa_no_debug=${2:-0} gravar_log=${3:-0}

# Recebe no 1º parâmetro o nome da pasta a ser criada.
# Teste lógico se terá permissão para gravar já foi feito antes.
# Faz criação de forma recursiva se necessário.
# 2º parâmetro recebe informação se deve usar DEBUG.
# 3º parâmetro diz se precisa gravar LOG.
if [ ${informa_no_debug} -gt 0 ]; then
Debug 1 "Antes de criar a pasta: $criar_a_pasta [F:$FUNCNAME L:$LINENO]"
fi

mkdir -p "$criar_a_pasta"

if [ $? = 1 ]; then
return 1
fi
if [ ${informa_no_debug} -gt 0 ]; then
Debug 1 "Após criar a pasta: $criar_a_pasta [F:$FUNCNAME L:$LINENO]"
fi
}

function Diretorios_de_Trabalho()
{

Debug 1 "Conferindo diretórios...[F:$FUNCNAME L:$LINENO]" 2>/dev/null

GravarPasta ${dir_pasta_restart} 1 0 #Grava se não existe Debug=Sim Log=Não
GravarPasta ${dir_pasta_origem} 1 0 #Grava se não existe Debug=Sim Log=Não
GravarPasta ${dir_pasta_start} 1 0 #Grava se não existe Debug=Sim Log=Não
GravarPasta ${dir_pasta_servicos} 1 0 #Grava se não existe Debug=Sim Log=Não
GravarPasta ${dir_pasta_pause} 1 0 #Grava se não existe Debug=Sim Log=Não


}

# testar se o diretório existe.
# testar se o diretório tem permissão de gravação
# testar se o arquivo existe
# testar se arquivo pode ser gravado.
function teste_logico()
{
# param 1 = recebe o tipo de teste.
# param 2 = O que será testado.
# param 3 = Opcional
test "$2" || return 0

case "$1" in
arquivo_existe)
# Verifica se o arquivo de TEXTO existe.
if [ -f "$2" ]
then
Debug 3 "Arquivo $2 já existe !!! [Função:$FUNCNAME Linha:$LINENO]"
return 0
else
Debug 3 "Arquivo $2 NÃO existe !!! [Função:$FUNCNAME Linha:$LINENO]"
return 1
fi
;;
pasta_existe)
# Verifica se o diretório existe.
if [ -d "$2" ]
then
Debug 3 "Arquivo $2 já existe !!! [F:$FUNCNAME L:$LINENO]"
return 0
else
Debug 3 "Arquivo $2 NÃO existe !!! [F:$FUNCNAME L:$LINENO]"
return 1
fi
;;
arquivo_gravar)
# Arquivo deve existir e tem permissão de escrita.
if ! test -w "$2"
then
Debug 3 "Não é possível gravar $2 [F:$FUNCNAME L:$LINENO]"
return 1
fi
;;
pasta_gravar)
# Diretório tem que existir e ter permissão de escrita.
if ! test -d "$2"
then
Debug 3 "Sem permissão na pasta $2 [F:$FUNCNAME L:$LINENO]"
echo "Diretório $2 não existe. "
return 1
fi
;;
# Outros neste momento ainda não ignorados
esac
}

GravarPasta() {
# $1 = Nome da pasta a ser testada.
# $2 = Se vai usar o Debug
# $3 = Se vai gravar log.
# Para não estourar o forum, não troquei para variáveis locais $1 a $3
teste_logico pasta_existe $1 || [ $? = 0 ] || criando_pasta $1 $2 $3
}

Diretorios_de_Trabalho



Tanto a primeira parte do código ou a segunda fazem rigorosamente a mesma coisa. Não há diferença no resultado final em termos de pastas que irão criar. Você sabe dizer onde está a grande diferença então ?

Que vantagens o 2º código tem sobre o 1º ? Vale a pena ?
Você conseguiu encontrar algum local na segunda opção que deseja mudar ?



Agora vou assistir o Barça sem a LUSA kkkk



16. Re: Qual a melhor forma para receber retornos de função em Shell Script [RESOLVIDO]

Geraldo Albuquerque
AprendiNoLinux

(usa Ubuntu)

Enviado em 20/04/2012 - 08:43h

Já que ninguém respondeu, lá vou eu.

A nova versão do mesmo código é melhor porque deixa 3 funções de uso geral que você poderá aproveitar em qualquer aplicativo sem modificações.
1 - criando_arquivo() - faz tudo, só precisa passar o nome do arquivo.
2 - criando_pasta() - O mesmo da nº 1 mas relacionada a diretórios.
3 - teste_logico() - Será de múltiplos usos e irá crescer com o tempo.

Vejam também: http://vivaolinux.com.br/topico/Shell-Script/Funcao-em-shell-script-que-recebe-numeros-e-retorna-com...




17. Re: Qual a melhor forma para receber retornos de função em Shell Script [RESOLVIDO]

Geraldo Albuquerque
AprendiNoLinux

(usa Ubuntu)

Enviado em 23/04/2012 - 23:48h

Estou reativando o site para colocar os códigos por lá para não estourar o site aqui.
Também vou fazer uns passo a passo de soluções de problemas usando comandos GNU/Linux e aplicativos.

https://sites.google.com/site/shellscriptbr/comandoslinux/sed

bye



Vo procurar remédio na vida noturna kkk



01 02



Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts