Diferença entre retorno e saída nas funções do Bash

Qual é a diferença entre a instrução returne exitnas funções do Bash em relação aos códigos de saída?

A partir man bashde return [n];

Faz com que uma função pare de executar e retorne o valor especificado por n ao seu chamador. Se n for omitido, o status de retorno é o do último comando executado no corpo da função.

... em exit [n]:

Faça com que o shell saia com o status n. Se n for omitido, o status de saída é o do último comando executado. Uma interceptação em EXIT é executada antes que o shell termine.

EDITAR:

Conforme sua edição da pergunta, em relação aos códigos de saída, returnnada tem a ver com códigos de saída. Os códigos de saída destinam-se a aplicativos / scripts , não a funções. Portanto, a este respeito, a única palavra-chave que define o código de saída do script (aquele que pode ser capturado pelo programa de chamada usando a $?variável shell) é exit.

EDIT 2:

Minha última declaração referente exitestá causando alguns comentários. Foi feito para diferenciar returne exitpara o entendimento do OP e, de fato, em qualquer ponto determinado de um script de programa / shell, exité a única maneira de finalizar o script com um código de saída para o processo de chamada.

Cada comando executado no shell produz um local "código de saída": ele define a $?variável para que o código, e pode ser usado com if, &&e outros operadores para condicionalmente executar outros comandos.

Esses códigos de saída (e o valor da $?variável) são redefinidos a cada execução de comando.

Aliás, o código de saída do último comando executado pelo script é usado como o código de saída do próprio script, conforme visto pelo processo de chamada.

Finalmente, as funções, quando chamadas, agem como comandos do shell em relação aos códigos de saída. O código de saída da função ( dentro da função) é definido usando return. Portanto, quando uma função return 0é executada, a execução da função termina, fornecendo um código de saída 0.

returnfará com que a função atual fique fora do escopo, enquanto exitfará com que o script termine no ponto em que é chamado. Aqui está um exemplo de programa para ajudar a explicar isso:

#!/bin/bash

retfunc()
{
    echo "this is retfunc()"
    return 1
}

exitfunc()
{
    echo "this is exitfunc()"
    exit 1
}

retfunc
echo "We are still here"
exitfunc
echo "We will never see this"

Resultado

$ ./test.sh
this is retfunc()
We are still here
this is exitfunc()

Não acho que alguém tenha realmente respondido totalmente à pergunta porque não descreve como os dois são usados. OK, acho que sabemos que exit mata o script, onde quer que seja chamado e você pode atribuir um status a ele, como sair ou sair 0 ou sair 7 e assim por diante. Isso pode ser usado para determinar como o script foi forçado a parar se chamado por outro script, etc. Chega na saída.

return quando chamado retornará o valor especificado para indicar o comportamento da função, geralmente 1 ou 0. Por exemplo:

    #!/bin/bash
    isdirectory() {
      if [ -d "$1" ]
      then
        return 0
      else
        return 1
      fi
    echo "you will not see anything after the return like this text"
    }

verifique assim:

    if isdirectory $1; then echo "is directory"; else echo "not a directory"; fi

ou assim:

    isdirectory || echo "not a directory"

Neste exemplo, o teste pode ser usado para indicar se o diretório foi encontrado. observe que nada após o retorno não será executado na função. 0 é verdadeiro, mas falso é 1 no shell, diferente de outros programas.

Para obter mais informações sobre funções: http://www.linuxjournal.com/content/return-values-bash-functions

NOTA: A função isdirectory é apenas para fins instrucionais. Não deve ser assim que você executa essa opção em um script real.

Lembre-se de que as funções são internas a um script e normalmente retornam de onde foram chamadas usando a instrução return. Chamar um script externo é outra questão inteiramente, e os scripts geralmente terminam com uma instrução de saída.

A diferença "entre a declaração de retorno e saída nas funções BASH em relação aos códigos de saída" é muito pequena. Ambos retornam um status, não valores per se. Um status zero indica sucesso, enquanto qualquer outro status (1 a 255) indica uma falha. A instrução de retorno retornará ao script de onde foi chamada, enquanto a instrução de saída encerrará o script inteiro de onde for encontrado.

return 0  # returns to where the function was called.  $? contains 0 (success).

return 1  # returns to where the function was called.  $? contains 1 (failure).

exit 0  # exits the script completely.  $? contains 0 (success).

exit 1  # exits the script completely.  $? contains 1 (failure).

Se sua função simplesmente terminar sem nenhuma instrução de retorno, o status do último comando executado será retornado como o código de status (e será colocado em $?).

Lembre-se de retornar e sair devolvendo um código de status de 0 a 255, disponível em $?. Você não pode inserir mais nada em um código de status (por exemplo, retornar "cat"); isso não vai funcionar. Porém, um script pode transmitir 255 motivos diferentes de falha usando códigos de status.

Você pode definir variáveis ​​contidas no script de chamada ou fazer eco dos resultados na função e usar a substituição de comandos no script de chamada; mas o objetivo do retorno e da saída é passar códigos de status, não valores ou resultados de computação, como seria de esperar em uma linguagem de programação como C.

Às vezes, você executa um script usando .ou source.

. a.sh

Se você incluir um exitno a.sh, ele não apenas encerrará o script, mas também encerrará sua sessão do shell.

Se você incluir um returnno a.sh, ele simplesmente interromperá o processamento do script.

Em palavras simples (principalmente para iniciantes em codificação), podemos dizer,

`return` : exits the function,
`exit()` : exits the program(called as process while running)

Além disso, se você observou, isso é muito básico, mas ...,

`return` : is the keyword
`exit()` : is the function

• exitencerrar o processo atual ; com ou sem código de saída, considere isso um sistema mais que uma função do programa. Observe que, ao fazer o sourcing, exito shell será finalizado; no entanto, ao executar, será apenas exito script.

• returnde uma função, volte para a instrução após a chamada, com ou sem um código de retorno. returné opcional e está implícito no final da função. returnsó pode ser usado dentro de uma função.

Quero acrescentar que, enquanto estiver sendo originado, não é fácil para exito script de dentro de uma função sem matar o shell. Eu acho que um exemplo é melhor em um script de 'teste'

#!/bin/bash
function die(){
   echo ${1:=Something terrible wrong happen}
   #... clean your trash
   exit 1
}

[ -f /whatever/ ] || die "whatever is not available"
# now we can proceed
echo "continue"

fazendo o seguinte:

user$ ./test
Whatever is not available
user$

test - e - a concha será fechada.

user$ . ./test
Whatever is not available

somente testterminará e o prompt será exibido.

A solução é incluir o potencial procedimento em (e)

#!/bin/bash
function die(){
   echo $(1:=Something terrible wrong happen)
   #... clean your trash
   exit 1
}

( # added        
    [ -f /whatever/ ] || die "whatever is not available"
    # now we can proceed
    echo "continue"
) # added

agora, em ambos os casos, apenas testsairá.

A pergunta do OP: Qual é a diferença entre a declaração de retorno e saída nas funções BASH em relação aos códigos de saída?

Por fim, alguns esclarecimentos são necessários:

• Uma instrução (return | exit) não é necessária para finalizar a execução de uma (função | shell). Uma (função | shell) será finalizada quando chegar ao final de sua lista de códigos, mesmo sem a declaração (return | exit).
• Uma instrução (return | exit) não é necessária para passar um valor de volta de um terminado (função | shell). Todo processo possui uma variável interna $? que sempre tem um valor numérico. É uma variável especial que não pode ser definida como "? = 1", mas é definida apenas de maneiras especiais (veja abaixo *). O valor de $? após o último comando a ser executado no (chamado sub-função | função) é o valor que é passado de volta para o (chamador | função-pai | shell). Isso é verdade se o último comando executado é ("return [n]" | "exit [n]") ou simples ("return" ou qualquer outra coisa que por acaso seja o último comando no código de funções chamado.

Na lista de marcadores acima, escolha entre "(x | y)" sempre o primeiro item ou sempre o segundo item para obter instruções sobre funções e retorno ou shells e saída, respectivamente.

O que está claro é que ambos compartilham o uso comum da variável especial $? para passar valores para cima depois que eles terminam.

* Agora, para as formas especiais que $? Pode ser configurado:

• Quando uma função chamada termina e retorna ao chamador, $? no chamador será igual ao valor final de $? na função finalizada.
• Quando um shell pai espera implicitamente ou explicitamente em um único sub shell e é liberado pelo término desse sub shell, então $? no shell pai será igual ao valor final de $? no sub shell finalizado.
• Algumas funções internas podem modificar $? dependendo do resultado deles. Mas alguns não.
• Funções internas "return" e "exit", quando seguidas por um argumento numérico, tanto $? com argumento e encerre a execução.

Vale a pena notar que $? pode ser atribuído um valor chamando exit em um sub shell, assim:

# (exit 259)
# echo $?
3  

Primeiro de tudo, returné uma palavra-chave e exitmeu amigo é uma função.

Dito isto, aqui está uma das explicações mais simples.

return Retorna um valor de uma função.

exit Ele sai ou abandona o shell atual.