Início / unix / Perguntas / 456698
Accepted
Jim
Asked: 2018-07-17 23:40:05 +0800 CST

Passando um sinalizador booleano para uma função?

  • 772

Eu tenho uma função que dependendo de um argumento onde a funcionalidade muda.
Eu sei que posso fazer: 

function foo {  
  PARAM1=$1  
  PARAM2="$2"  
  VAR=$3  
  if[[ -z "$VAR" ]]; then  
   # code here  
  else  
   # other code here  
  fi  
}

Eu queria saber se existe uma abordagem mais apropriada para o bash. Isso funcionaria, mas eu não gostaria de ter algo como 

foo "x" "y" "blah"  
foo "x" "y" "true"  
foo "y" "y" "1"

tudo para ser equivalente.

Existe uma abordagem mais adequada ao Bash?

bash shell-script

3 respostas

  1. Best Answer

    Você pode fornecer uma opção de linha de comando para sua função. Usar opções de linha de comando sem argumentos é uma maneira comum de fornecer valores binários/booleanos ("on/off", "true/false", "enable/disable") para scripts de shell, funções de shell e utilitários em geral.

    foo () {
    local flag=false
    OPTIND=1

    while getopts 't' opt; do
        case $opt in
            t) flag=true ;;
            *) echo 'Error in command line parsing' >&2
               exit 1
        esac
    done
    shift "$(( OPTIND - 1 ))"

    local param1="$1"
    local param2="$2"

    if "$flag"; then
        # do things for "foo -t blah blah"
    else
        # do things for "foo blah blah"
    fi
}

    A opção -tfunciona como um sinalizador booleano para o usuário. Usá-lo definiria flagdentro da função para true(alterando-o de seu valor padrão de false). A -topção seria usada como o primeiro argumento para a função.

    A chamada da função seria feita usando

    foo "some value" "some other value"

    ou

    foo -t "some value" "some other value"

    onde a última chamada definiria a flagvariável na função para true.

    • 10

  2. No geral

    Em geral, passar booleanos para funções, em qualquer linguagem, é ilegível. por exemplo calculate_interest 5y 4% true. O leitor fica se perguntando o que é verdade.

    Portanto, use uma enumeração: { per_month, per_year }. Agora você pode fazer calculate_interest 5y 4% per_year. Isso é mais legível.

    Na festa

    O Bash não é tipado estaticamente (ou fortemente tipado, ou tem muito de um sistema de tipos), então você pode passar muitos valores diferentes. Um vai liderar desta forma, os outros não. Não é desejável ter muitos valores diferentes que levam ao mesmo caminho.

    Portanto, adicione código para verificar se a entrada é um dos dois valores aceitáveis. Faça isso no início da função, você não quer sair da metade do caminho para fazer algo.

    O que fazer se você tiver que chamar uma função que recebe um booleano

    Então alguém não seguiu meu conselho, e você tem que chamar uma função que recebe um booleano. O que você pode fazer para tornar seu código legível?

    • Se a linguagem (como Python) permitir argumentos nomeados, por exemplo calculate_interest 5y 4% per_year=True, use-os. Vai ajudar, mas não lhe diz o significado de calculate_interest 5y 4% per_year=False.
    • Se a linguagem não tiver argumentos nomeados, as únicas opções serão viver com código ilegível (não uma opção) ou envolver as funções em funções alfabetizadas.
    • 3

  3. Eu recomendo seguir um formato como este:

    foo() {
  # Limit scope of variables
  local 'opt1' 'opt2' 'opt3' 'operands'

  # Default values
  opt1='default1'
  opt2='default2'
  opt3='false'
  operands=()

  # Arguments handling
  while (( ${#} > 0 )); do
    case "${1}" in
      ( '--opt1='* ) opt1="${1#*=}" ;;           # Handles --opt1
      ( '--opt2='* ) opt2="${1#*=}" ;;           # Handles --opt2
      ( '--opt3='* ) opt3="${1#*=}" ;;           # Handles --opt3
      ( '--' ) operands+=( "${@:2}" ); break ;;  # End of options
      ( '-'?* ) ;;                               # Discard non-valid options
      ( * ) operands+=( "${1}" )                 # Handles operands
    esac
    shift
  done

  ...
}

    Dessa forma, a função será mais robusta e legível:

    $ foo
Options:
  opt1: [default1]
  opt2: [default2]
  opt3: [false]

    $ foo --opt1='value1' --opt2='value2' --opt3='true' 'foo' 'bar' 'baz'
Options:
  opt1: [value1]
  opt2: [value2]
  opt3: [true]
Operands:
  1: [foo]
  2: [bar]
  3: [baz]

    Prós:

    • Fácil de ler e compreender.
    • A sintaxe é semelhante a qualquer utilitário de linha de comando típico.
    • É fácil adicionar mais opções sem quebrar a compatibilidade.

    Contras:

    • Pode ser um exagero para scripts pequenos e simples.
    • Difícil escrever um equivalente portátil e compatível com POSIX que também lide com opções e operandos longos.
    • 3

relate perguntas