Início / unix / Perguntas / 772232
Accepted
Schmaehgrunza
Asked: 2024-03-13 16:11:11 +0800 CST

valor de retorno de uma função

  • 772

Alguém pode me explicar por que o valor de retorno de uma função bash é sempre ecoado na função e depois consumido por my_var=$(my_func arg1 arg2 ..), quando examino exemplos de código.

my_func ()
   {
   echo "$1 , $2, $3"
   }

my_var=$(my_func .. .. ..);

em vez de usar isso, o que não abriria um subshell

declare g_RV  #-- global return value for all functions

myfunc ()
   {
   g_RV="$1 , $2, $3"
   }

myfunc .. .. ..; my_var=$g_RV;

porque eu uso o segundo método e me pergunto se isso falharia no primeiro método em alguns casos. Deve haver uma causa, porque todo mundo está abrindo um subshell.

EDIT: por causa dos comentários de Kusalananda e Paul_Pedant
eu adicionei uma chamada de função recursiva com g_RV - LAF function , listo todos os arquivos de um diretório $1, ou faço isso recursivamente se $2 INT>0
e então chamadas de função dentro de uma função para outras funções (veja funções de soma!

declare g_RV

shopt -s dotglob nullglob

#-- Recursive call with g_RV
#---------------------------
#-- call: LAF [directory STR] [recursive INT (>0 .. true, 0 .. false)]  ... List all files in a folder or inclusive all files in subfolders (recursive
LAF ()
   {
   local file files="" dir_path=$1
   if [[ ${dir_path:0:1} != "/" ]]; then dir_path=$(readlink -f "$dir_path"); fi
   
   for file in "$dir_path/"*; do
      if [[ -d $file ]]; then (($2)) && { LAF "$file"; files+=$g_RV; }                    #-- recursive call
      else files+="${file}"$'\n'; fi
      done
   g_RV=$files
   }
   
LAF "/tmp" 1; my_var1=$g_RV; echo "$my_var1";

#-- function calling other functions with g_RV
#---------------------------------------------
sum_A ()
   { 
   g_RV=$(($1+$2))
   }

sum_B()
   {
   g_RV=$(($1+$2))
   }

sum_C ()
   {
   local -i sum=0;
   sum_A 5 6; sum+=$g_RV
   sum_B 12 18; sum+=$g_RV
   g_RV=$sum
   }
  
sum_C; my_var2=$g_RV; echo "sum: $my_var2";
bash

4 respostas

  1. Best Answer

    Ferramentas e utilitários padrão retornam informações via stdout , qualificando o resultado com o status de saída (0=ok, caso contrário erro). Suas funções devem fazer o mesmo para que possam ser usadas da mesma maneira consistente.

    Seu exemplo mostra uma única variável global para todos os retornos de funções. Assim que você adotar essa abordagem, não será possível interpolar funções em pipelines ou mesmo em strings sem aumentar a complexidade e reduzir a legibilidade.

    Considerar

    f() { sed 's/^/> /'; }
g() { nl; }

echo try | f | g    # "     1  > try"

    Se você tiver uma variável global para o retorno de cada função (ou pior, a mesma variável global para ambas), você precisará passar por vários obstáculos para obter o mesmo efeito.

    Você está executando um shell e, no momento em que considera toda a sobrecarga, o número de subprocessos é - ou deveria ser - em grande parte irrelevante. Se você precisa de velocidade, não escreva em shell script.

    • 3

  2. Usar uma variável global não é reutilizável em geral. Pode haver um conflito de nomes com uma variável global usada em outro lugar.

    Além disso, não é a maneira padrão como a maioria das pessoas espera que as funções funcionem.

    • 1
    • Menos código
    • Mais fácil de ler
    • A forma tradicional tem menos probabilidade de levar a erros
    • echoé uma função integrada que computacionalmente não custa quase nada
    • Bash é um Bourne Again SHell, não é uma linguagem de programação [clássica]
    • A maneira clássica de fazer as coisas é resiliente source/.- o que significa que sempre funcionará independentemente.
    • 1

  4. Nem sempre é feito assim. Na verdade, você fez isso de outra maneira na sua pergunta!

    Na verdade, as funções do Shell não podem retornar nada além de um status de saída, que é limitado a um número inteiro entre 0..255, portanto, não é muito útil. Então, as opções são usar uma variável externa ou imprimir os dados necessários e capturar a saída.

    Imprimir e capturar a saída também apresenta problemas; mesmo se ignorarmos os problemas de desempenho que a maioria dos shells sofre com as substituições de comandos, há também o problema de que a saída é uma única string ou fluxo de bytes, desprovido de qualquer estrutura. E em shells diferentes do zsh, uma substituição de comando não pode capturar bytes NUL de qualquer maneira, portanto, não é nem mesmo um fluxo limpo de bytes de 8 bits.

    Se você precisar, por exemplo, retornar um array, usar uma variável externa pode ser muito mais simples. Em vez de usar um com nome fixo, você pode usar namerefs para permitir que o chamador passe o nome da variável a ser usada para os valores retornados.

    Por exemplo, como um exemplo estúpido, apenas para ter algo com valores difíceis de manusear sem matrizes adequadas:

    #!/bin/bash
funnystrings() {
    declare -n _dst="$1"
    _dst[0]="foo bar"
    _dst[1]="*"
    _dst[2]=$'new\nline'
}

a=()
funnystrings a
declare -p a

    Da mesma forma, você poderia passar outro nome de variável se precisasse na variável de entrada:

    squares() {
    declare -n _src="$1" _dst="$2"
    local _i _val
    for _i in "${!_src[@]}"; do
        _val=${src[$i]}
        _dst[$i]=$(( _val * _val ))
    done
}
a=(1 2 3)
b=()
squares a b

    Na verdade, isso pode funcionar no Bash mesmo se ae bfossem variáveis ​​locais em outra função chamada squares a b, mas observe que pode haver estranhezas em como os locais aninhados funcionam entre shells, especialmente. para o que acompanha unset.

    • 1

relate perguntas