Eu quero escrever uma função bash que verifique se um arquivo tem certas propriedades e retorna verdadeiro ou falso. Então eu posso usá-lo em meus scripts no "se". Mas o que devo retornar?

function myfun(){ ... return 0; else return 1; fi;}

então eu uso assim:

if myfun filename.txt; then ...

claro que isso não funciona. Como pode ser isto alcançado?

Use 0 para verdadeiro e 1 para falso.

Amostra:

#!/bin/bash

isdirectory() {
  if [ -d "$1" ]
  then
    # 0 = true
    return 0 
  else
    # 1 = false
    return 1
  fi
}


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

Editar

No comentário de @ amichair, isso também é possível

isdirectory() {
  if [ -d "$1" ]
  then
    true
  else
    false
  fi
}


isdirectory() {
  [ -d "$1" ]
}

Por que você deveria se importar com o que eu digo, apesar de haver uma resposta mais de 250 votada

Não é isso 0 = truee 1 = false. É: zero significa nenhuma falha (sucesso) e diferente de zero significa falha (do tipo N) .

Embora a resposta selecionada seja tecnicamente "verdadeira" , não coloque return 1** no seu código como falso . Terá vários efeitos colaterais infelizes.

1. Desenvolvedores experientes o identificarão como amador (pelo motivo abaixo).
2. Desenvolvedores experientes não fazem isso (por todos os motivos abaixo).
3. É propenso a erros.
   • Até desenvolvedores experientes podem confundir 0 e 1 como falso e verdadeiro, respectivamente (pelo motivo acima).
4. Requer (ou encorajará) comentários estranhos e ridículos.
5. Na verdade, é menos útil que status de retorno implícito.

Aprenda alguma festa

O manual do bash diz (ênfase minha)

retornar [n]

Faça com que uma função de shell pare de executar e retorne o valor n ao seu chamador. Se n não for fornecido , o valor retornado é o status de saída do último comando executado na função.

Portanto, nunca precisamos usar 0 e 1 para indicar Verdadeiro e Falso. O fato de fazer isso é essencialmente um conhecimento trivial, útil apenas para depurar código, entrevistar perguntas e surpreender os novatos.

O manual do bash também diz

caso contrário, o status de retorno da função é o status de saída do último comando executado

O manual do bash também diz

( $? ) Expande para o status de saída do pipeline de primeiro plano executado mais recentemente .

Uau, espera. Pipeline? Vamos voltar ao manual do bash mais uma vez.

Um pipeline é uma sequência de um ou mais comandos separados por um dos operadores de controle '|' ou '| &'.

Sim. Eles disseram que 1 comando é um pipeline. Portanto, todas as três citações estão dizendo a mesma coisa.

• $? diz o que aconteceu por último.
• Borbulha.

Minha resposta

Portanto, enquanto o @Kambus demonstrou que, com uma função tão simples, isso não returné necessário. Eu acho que era irrealisticamente simples comparado às necessidades da maioria das pessoas que lerão isso.

Por que return?

Se uma função retornará o status de saída do último comando, por que usar return? Porque faz com que uma função pare de executar.

Pare a execução sob várias condições

01  function i_should(){
02      uname="$(uname -a)"
03
04      [[ "$uname" =~ Darwin ]] && return
05
06      if [[ "$uname" =~ Ubuntu ]]; then
07          release="$(lsb_release -a)"
08          [[ "$release" =~ LTS ]]
09          return
10      fi
11
12      false
13  }
14
15  function do_it(){
16      echo "Hello, old friend."
17  }
18
19  if i_should; then
20    do_it
21  fi

O que temos aqui é ...

Line 04é um retorno explícito [-ish] true, porque o RHS de &&apenas é executado se o LHS for true

Linha 09retorna verdadeiro ou falso, correspondendo ao status da linha08

Linha 13retorna falsa por causa da linha12

(Sim, isso pode ser resolvido, mas o exemplo inteiro é artificial.)

Outro padrão comum

# Instead of doing this...
some_command
if [[ $? -eq 1 ]]; then
    echo "some_command failed"
fi

# Do this...
some_command
status=$?
if ! $(exit $status); then
    echo "some_command failed"
fi

Observe como definir uma statusvariável desmistifica o significado de $?. (É claro que você sabe o que $?significa, mas alguém com menos conhecimento do que você terá que pesquisar no Google algum dia. A menos que seu código esteja negociando em alta frequência, mostre algum amor , defina a variável.) Mas a verdadeira desvantagem é que "se não existe status "ou vice-versa" se o status de saída "puder ser lido em voz alta e explicar seu significado. No entanto, esse último pode ser um pouco ambicioso, porque ver a palavra exitpode fazer você pensar que está saindo do script, quando na realidade está saindo do $(...)subshell.

** Se você absolutamente insistir em usar return 1falso, sugiro que você use pelo menos return 255. Isso fará com que seu futuro eu ou qualquer outro desenvolvedor que precise manter seu código questione "por que isso é 255?" Então eles estarão prestando atenção e terão uma chance melhor de evitar um erro.

myfun(){
    [ -d "$1" ]
}
if myfun "path"; then
    echo yes
fi
# or
myfun "path" && echo yes

Cuidado ao verificar o diretório apenas com a opção -d!
se a variável $ 1 estiver vazia, o cheque ainda será bem sucedido. Para ter certeza, verifique também se a variável não está vazia.

#! /bin/bash

is_directory(){

    if [[ -d $1 ]] && [[ -n $1 ]] ; then
        return 0
    else
        return 1
    fi

}


#Test
if is_directory $1 ; then
    echo "Directory exist"
else
    echo "Directory does not exist!" 
fi

Encontrei um ponto (ainda não mencionado explicitamente?) Sobre o qual estava tropeçando. Ou seja, não como retornar o booleano, mas como avaliá-lo corretamente!

Eu estava tentando dizer if [ myfunc ]; then ..., mas isso é simplesmente errado. Você não deve usar os suportes! if myfunc; then ...é a maneira de fazer isso.

Como no @Bruno e outros, reiteramos truee falsesão comandos , não valores! Isso é muito importante para entender os booleanos nos scripts de shell.

Neste post, expliquei e demonstrei usando variáveis booleanas : https://stackoverflow.com/a/55174008/3220983 . Eu sugiro fortemente verificar isso, porque é muito relacionado.

Aqui, fornecerei alguns exemplos de retorno e avaliação de booleanos a partir de funções:

Este:

test(){ false; }                                               
if test; then echo "it is"; fi                                 

Não produz saída de eco. (ou seja, false retorna falso)

test(){ true; }                                                
if test; then echo "it is"; fi                                 

Produz:

it is                                                        

(ou seja, true retorna verdadeiro)

E

test(){ x=1; }                                                
if test; then echo "it is"; fi                                 

Produz:

it is                                                                           

Porque 0 (ou seja, verdadeiro) foi retornado implicitamente .

Agora, isso é o que estava me ferrando ...

test(){ true; }                                                
if [ test ]; then echo "it is"; fi                             

Produz:

it is                                                                           

E

test(){ false; }                                                
if [ test ]; then echo "it is"; fi                             

TAMBÉM produz:

it is                                                                           

Usar os colchetes aqui produziu um falso positivo ! (Eu deduzo que o resultado do comando "externo" é 0.)

A principal vantagem do meu post é: não use colchetes para avaliar uma função booleana (ou variável) como você faria para uma verificação de igualdade típica, por exemplo if [ x -eq 1 ]; then...!

Use os comandos trueou falseimediatamente antes do seu e return, em seguida, returnsem parâmetros. O returnusará automaticamente o valor do seu último comando.

O fornecimento de argumentos para returné inconsistente, digite específico e propenso a erros se você não estiver usando 1 ou 0. E, como comentários anteriores declararam, usar 1 ou 0 aqui não é o caminho certo para abordar essa função.

#!/bin/bash

function test_for_cat {
    if [ $1 = "cat" ];
    then
        true
        return
    else
        false
        return
    fi
}

for i in cat hat;
do
    echo "${i}:"
    if test_for_cat "${i}";
    then
        echo "- True"
    else
        echo "- False"
    fi
done

Resultado:

$ bash bash_return.sh

cat:
- True
hat:
- False

Pode funcionar se você reescrever isso function myfun(){ ... return 0; else return 1; fi;}como este function myfun(){ ... return; else false; fi;}. Ou seja, se falseé a última instrução na função, você obtém resultado falso para toda a função, mas returninterrompe a função com resultado verdadeiro de qualquer maneira. Acredito que seja verdade para o meu intérprete de festa, pelo menos.

Encontrei a forma mais curta para testar a saída da função é simplesmente

do_something() {
    [[ -e $1 ]] # e.g. test file exists
}

do_something "myfile.txt" || { echo "File doesn't exist!"; exit 1; }

Por razões de legibilidade do código, acredito que o retorno verdadeiro / falso deve:

• estar em uma linha
• seja um comando
• seja fácil de lembrar
• mencione a palavra-chave returnseguida por outra palavra-chave ( trueou false)

Minha solução é return $(true)ou return $(false)como mostrado:

is_directory()
{
    if [ -d "${1}" ]; then
        return $(true)
    else
        return $(false)
    fi
}

Seguindo @Bruno Bronosky e @mrteatime, ofereço a sugestão de que você escreva seu retorno booleano "para trás". É isso que eu quero dizer:

foo()
{
    if [ "$1" == "bar" ]; then
        true; return
    else
        false; return
    fi;
}

Isso elimina o feio requisito de duas linhas para cada declaração de retorno.