Возвращаемое значение в функции Bash

Я работаю со скриптом bash и хочу выполнить функцию для вывода возвращаемого значения:

function fun1(){
  return 34
}
function fun2(){
  local res=$(fun1)
  echo $res
}

Когда я выполняю fun2, он не печатает «34». Почему это так?

Несмотря на то, что bash имеет returnоператор, единственное, что вы можете указать с его помощью, это собственный exitстатус функции (значение между 0и 255, 0 означает «успех»). Так returnчто не то, что вы хотите.

Возможно, вы захотите преобразовать ваш returnоператор в echoоператор - таким образом, вывод вашей функции может быть получен с помощью $()фигурных скобок, что кажется именно тем, что вы хотите.

Вот пример:

function fun1(){
  echo 34
}

function fun2(){
  local res=$(fun1)
  echo $res
}

Другой способ получить возвращаемое значение (если вы просто хотите вернуть целое число 0-255) - это $?.

function fun1(){
  return 34
}

function fun2(){
  fun1
  local res=$?
  echo $res
}

Кроме того, обратите внимание, что вы можете использовать возвращаемое значение, чтобы использовать логическую логику, которая fun1 || fun2будет запускаться, только fun2если fun1возвращает 0значение. Возвращаемым значением по умолчанию является выходное значение последнего оператора, выполненного в функции.

$(...)захватывает текст, отправленный на стандартный вывод командой, содержащейся в. returnне выводит на стандартный вывод. $?содержит код результата последней команды.

fun1 (){
  return 34
}

fun2 (){
  fun1
  local res=$?
  echo $res
}

Функции в Bash не являются функциями, как на другом языке; они на самом деле команды. Таким образом, функции используются так, как если бы они были двоичными файлами или скриптами, извлеченными из вашего пути. С точки зрения логики вашей программы не должно быть никакой разницы.

Команды оболочки связаны трубами (или потоками), а не фундаментальными или определяемыми пользователем типами данных, как в «реальных» языках программирования. Нет такой вещи, как возвращаемое значение для команды, возможно, в основном потому, что нет реального способа объявить это. Это может произойти на странице руководства или на --helpвыходе команды, но оба они доступны только для чтения человеком и, следовательно, записываются на ветер.

Когда команда хочет получить ввод, она читает ее из своего потока ввода или списка аргументов. В обоих случаях текстовые строки должны быть проанализированы.

Когда команда хочет что-то вернуть, она должна echoпередать это в свой выходной поток. Другой часто практикуемый способ - хранить возвращаемое значение в выделенных глобальных переменных. Запись в выходной поток является более четкой и гибкой, поскольку она также может принимать двоичные данные. Например, вы можете легко вернуть BLOB:

encrypt() {
    gpg -c -o- $1 # encrypt data in filename to stdout (asks for a passphrase)
}

encrypt public.dat > private.dat # write function result to file

Как написали другие в этом потоке, вызывающая сторона также может использовать подстановку команд $()для захвата вывода.

Параллельно функция «вернет» код выхода gpg(GnuPG). Думайте о коде выхода как о бонусе, которого нет в других языках, или, в зависимости от вашего темперамента, как о «Schmutzeffekt» функциях оболочки. По условию это состояние равно 0 в случае успеха или целое число в диапазоне 1-255 для чего-то еще. Чтобы прояснить это: return(например exit) может принимать значение только от 0 до 255, а значения, отличные от 0, не обязательно являются ошибками, как это часто утверждается.

Если вы не предоставите явное значение со returnстатусом, оно берется из последней команды в инструкции / функции / команды Bash и так далее. Так что всегда есть статус, и returnэто просто простой способ его предоставления.

returnОператор устанавливает код завершения функции, так же , как exitбудет делать для всего сценария.

Код выхода для последней команды всегда доступен в $?переменной.

function fun1(){
  return 34
}

function fun2(){
  local res=$(fun1)
  echo $? # <-- Always echos 0 since the 'local' command passes.

  res=$(fun1)
  echo $?  #<-- Outputs 34
}

Проблема с другими ответами заключается в том, что они либо используют глобальные переменные, которые могут быть перезаписаны, когда несколько функций находятся в цепочке вызовов, либо echoэто означает, что ваша функция не может выводить диагностическую информацию (вы забудете, что ваша функция выполняет это, и "результат", т.е. возвращает значение, будет содержать больше информации, чем ожидает ваш вызывающий объект, что приведет к странным ошибкам) ​​или evalслишком тяжелым и хакерским.

Правильный способ сделать это - поместить в функцию материал верхнего уровня и использовать localправило динамической видимости bash. Пример:

func1() 
{
    ret_val=hi
}

func2()
{
    ret_val=bye
}

func3()
{
    local ret_val=nothing
    echo $ret_val
    func1
    echo $ret_val
    func2
    echo $ret_val
}

func3

Это выводы

nothing
hi
bye

Динамическая область видимости означает, что ret_valв зависимости от абонента указывается на другой объект! Это отличается от лексической области видимости, которая используется большинством языков программирования. На самом деле это документированная функция , которую легко не заметить, и она не очень хорошо объяснена, вот документация к ней (выделение мое):

Переменные, локальные для функции, могут быть объявлены с помощью локальной встроенной функции. Эти переменные видны только функции и командам, которые она вызывает .

Для кого-то с фоном C / C ++ / Python / Java / C # / javascript это, вероятно, самое большое препятствие: функции в bash не являются функциями, они являются командами и ведут себя как таковые: они могут выводить в stdout/ stderr, они могут передавать в / out, они могут вернуть код выхода. По сути, нет никакой разницы между определением команды в скрипте и созданием исполняемого файла, который можно вызывать из командной строки.

Так что вместо того, чтобы писать свой сценарий так:

top-level code 
bunch of functions
more top-level code

напишите это так:

# define your main, containing all top-level code
main() 
bunch of functions
# call main
main  

где main()объявляется ret_valкак localи все другие функции возвращают значения через ret_val.

См. Также следующий вопрос по Unix и Linux: Область действия локальных переменных в функциях оболочки .

Другое, возможно, даже лучшее решение, в зависимости от ситуации, - это то , которое использует ya.tecklocal -n .

Еще один способ добиться этого - ссылки на имена (требуется Bash 4.3+).

function example {
  local -n VAR=$1
  VAR=foo
}

example RESULT
echo $RESULT

Мне нравится делать следующее, если выполняется в сценарии, где определена функция:

POINTER= # used for function return values

my_function() {
    # do stuff
    POINTER="my_function_return"
}

my_other_function() {
    # do stuff
    POINTER="my_other_function_return"
}

my_function
RESULT="$POINTER"

my_other_function
RESULT="$POINTER"

Мне нравится это, потому что я могу включить эхо-операторы в свои функции, если я хочу

my_function() {
    echo "-> my_function()"
    # do stuff
    POINTER="my_function_return"
    echo "<- my_function. $POINTER"
}

В качестве дополнения к отличным постам других, вот статья, обобщающая эти приемы:

• установить глобальную переменную
• установить глобальную переменную, имя которой вы передали функции
• установить код возврата (и забрать его с помощью $?)
• 'echo' некоторые данные (и забрать их с MYVAR = $ (myfunction))

Возвращение значений из функций Bash

Git Bash в Windows с использованием массивов для нескольких возвращаемых значений

BASH КОД:

#!/bin/bash

##A 6-element array used for returning
##values from functions:
declare -a RET_ARR
RET_ARR[0]="A"
RET_ARR[1]="B"
RET_ARR[2]="C"
RET_ARR[3]="D"
RET_ARR[4]="E"
RET_ARR[5]="F"


function FN_MULTIPLE_RETURN_VALUES(){

   ##give the positional arguments/inputs
   ##$1 and $2 some sensible names:
   local out_dex_1="$1" ##output index
   local out_dex_2="$2" ##output index

   ##Echo for debugging:
   echo "running: FN_MULTIPLE_RETURN_VALUES"

   ##Here: Calculate output values:
   local op_var_1="Hello"
   local op_var_2="World"

   ##set the return values:
   RET_ARR[ $out_dex_1 ]=$op_var_1
   RET_ARR[ $out_dex_2 ]=$op_var_2
}


echo "FN_MULTIPLE_RETURN_VALUES EXAMPLES:"
echo "-------------------------------------------"
fn="FN_MULTIPLE_RETURN_VALUES"
out_dex_a=0
out_dex_b=1
eval $fn $out_dex_a $out_dex_b  ##<--Call function
a=${RET_ARR[0]} && echo "RET_ARR[0]: $a "
b=${RET_ARR[1]} && echo "RET_ARR[1]: $b "
echo
##----------------------------------------------##
c="2"
d="3"
FN_MULTIPLE_RETURN_VALUES $c $d ##<--Call function
c_res=${RET_ARR[2]} && echo "RET_ARR[2]: $c_res "
d_res=${RET_ARR[3]} && echo "RET_ARR[3]: $d_res "
echo
##----------------------------------------------##
FN_MULTIPLE_RETURN_VALUES 4 5  ##<---Call function
e=${RET_ARR[4]} && echo "RET_ARR[4]: $e "
f=${RET_ARR[5]} && echo "RET_ARR[5]: $f "
echo
##----------------------------------------------##


read -p "Press Enter To Exit:"

ОЖИДАЕМЫЙ ВЫХОД:

FN_MULTIPLE_RETURN_VALUES EXAMPLES:
-------------------------------------------
running: FN_MULTIPLE_RETURN_VALUES
RET_ARR[0]: Hello
RET_ARR[1]: World

running: FN_MULTIPLE_RETURN_VALUES
RET_ARR[2]: Hello
RET_ARR[3]: World

running: FN_MULTIPLE_RETURN_VALUES
RET_ARR[4]: Hello
RET_ARR[5]: World

Press Enter To Exit: