如何从 Bash 函数返回字符串值

Question

我想从 Bash 函数中返回一个字符串。

我将用 java 编写示例来展示我想做的事情：

public String getSomeString() {
  return "tadaa";
}

String variable = getSomeString();

以下示例在 bash 中有效，但有更好的方法吗？

function getSomeString {
   echo "tadaa"
}

VARIABLE=$(getSomeString)

Answer 1

我知道没有更好的方法。 Bash 只知道状态码（整数）和写入标准输出的字符串。

Answer 2

您可以使用全局变量：

declare globalvar='some string'

string ()
{
  eval  "$1='some other string'"
} # ----------  end of function string  ----------

string globalvar

echo "'${globalvar}'"

这给了

'some other string'

Answer 3

你可以让函数把一个变量作为第一个参数，然后用你想要返回的字符串修改变量。

#!/bin/bash
set -x
function pass_back_a_string() {
    eval "$1='foo bar rab oof'"
}

return_var=''
pass_back_a_string return_var
echo $return_var

打印“foo bar rab oof”。

编辑：在适当的位置添加引号以允许字符串中的空格来处理@Luca Borrione 的评论。

编辑：作为演示，请参见以下程序。这是一个通用的解决方案：它甚至允许您将字符串接收到局部变量中。

#!/bin/bash
set -x
function pass_back_a_string() {
    eval "$1='foo bar rab oof'"
}

return_var=''
pass_back_a_string return_var
echo $return_var

function call_a_string_func() {
     local lvar=''
     pass_back_a_string lvar
     echo "lvar='$lvar' locally"
}

call_a_string_func
echo "lvar='$lvar' globally"

打印出来：

+ return_var=
+ pass_back_a_string return_var
+ eval 'return_var='\''foo bar rab oof'\'''
++ return_var='foo bar rab oof'
+ echo foo bar rab oof
foo bar rab oof
+ call_a_string_func
+ local lvar=
+ pass_back_a_string lvar
+ eval 'lvar='\''foo bar rab oof'\'''
++ lvar='foo bar rab oof'
+ echo 'lvar='\''foo bar rab oof'\'' locally'
lvar='foo bar rab oof' locally
+ echo 'lvar='\'''\'' globally'
lvar='' globally

编辑：证明原始变量的值在函数中可用，正如@Xichen Li 在评论中错误批评的那样。

#!/bin/bash
set -x
function pass_back_a_string() {
    eval "echo in pass_back_a_string, original $1 is \$$1"
    eval "$1='foo bar rab oof'"
}

return_var='original return_var'
pass_back_a_string return_var
echo $return_var

function call_a_string_func() {
     local lvar='original lvar'
     pass_back_a_string lvar
     echo "lvar='$lvar' locally"
}

call_a_string_func
echo "lvar='$lvar' globally"

这给出了输出：

+ return_var='original return_var'
+ pass_back_a_string return_var
+ eval 'echo in pass_back_a_string, original return_var is $return_var'
++ echo in pass_back_a_string, original return_var is original return_var
in pass_back_a_string, original return_var is original return_var
+ eval 'return_var='\''foo bar rab oof'\'''
++ return_var='foo bar rab oof'
+ echo foo bar rab oof
foo bar rab oof
+ call_a_string_func
+ local 'lvar=original lvar'
+ pass_back_a_string lvar
+ eval 'echo in pass_back_a_string, original lvar is $lvar'
++ echo in pass_back_a_string, original lvar is original lvar
in pass_back_a_string, original lvar is original lvar
+ eval 'lvar='\''foo bar rab oof'\'''
++ lvar='foo bar rab oof'
+ echo 'lvar='\''foo bar rab oof'\'' locally'
lvar='foo bar rab oof' locally
+ echo 'lvar='\'''\'' globally'
lvar='' globally

Answer 4

你拥有它的方式是在不破坏范围的情况下做到这一点的唯一方法。 Bash 没有返回类型的概念，只有退出代码和文件描述符（stdin/out/err 等）

Answer 5

您还可以捕获函数输出：

#!/bin/bash
function getSomeString() {
     echo "tadaa!"
}

return_var=$(getSomeString)
echo $return_var
# Alternative syntax:
return_var=`getSomeString`
echo $return_var

看起来很奇怪，但比使用全局变量恕我直言要好。传递参数照常工作，只需将它们放在大括号或反引号内即可。

Answer 6

以上所有答案都忽略了 bash 手册页中所述的内容。

• 函数内声明的所有变量都将与调用环境共享。
• 所有声明为本地的变量都不会被共享。

示例代码

#!/bin/bash

f()
{
    echo function starts
    local WillNotExists="It still does!"
    DoesNotExists="It still does!"
    echo function ends
}

echo $DoesNotExists #Should print empty line
echo $WillNotExists #Should print empty line
f                   #Call the function
echo $DoesNotExists #Should print It still does!
echo $WillNotExists #Should print empty line

然后输出

$ sh -x ./x.sh
+ echo

+ echo

+ f
+ echo function starts 
function starts
+ local 'WillNotExists=It still does!'
+ DoesNotExists='It still does!'
+ echo function ends 
function ends
+ echo It still 'does!' 
It still does!
+ echo

在 pdksh 和 ksh 下这个脚本也是一样的！

Answer 7

地址Vicky Ronnen的抬头，考虑以下代码：

function use_global
{
    eval "$1='changed using a global var'"
}

function capture_output
{
    echo "always changed"
}

function test_inside_a_func
{
    local _myvar='local starting value'
    echo "3. $_myvar"

    use_global '_myvar'
    echo "4. $_myvar"

    _myvar=$( capture_output )
    echo "5. $_myvar"
}

function only_difference
{
    local _myvar='local starting value'
    echo "7. $_myvar"

    local use_global '_myvar'
    echo "8. $_myvar"

    local _myvar=$( capture_output )
    echo "9. $_myvar"
}

declare myvar='global starting value'
echo "0. $myvar"

use_global 'myvar'
echo "1. $myvar"

myvar=$( capture_output )
echo "2. $myvar"

test_inside_a_func
echo "6. $_myvar" # this was local inside the above function

only_difference

会给

0. global starting value
1. changed using a global var
2. always changed
3. local starting value
4. changed using a global var
5. always changed
6. 
7. local starting value
8. local starting value
9. always changed

也许正常情况是使用test_inside_a_func 函数中使用的语法，因此您可以在大多数情况下使用这两种方法，尽管捕获输出是更安全的方法，在任何情况下始终有效，模仿返回值正如Vicky Ronnen 正确指出的那样，来自您可以在其他语言中找到的函数。

Answer 8

agt@agtsoft:~/temp$ cat ./fc 
#!/bin/sh

fcall='function fcall { local res p=$1; shift; fname $*; eval "$p=$res"; }; fcall'

function f1 {
    res=$[($1+$2)*2];
}

function f2 {
    local a;
    eval ${fcall//fname/f1} a 2 3;
    echo f2:$a;
}

a=3;
f2;
echo after:a=$a, res=$res

agt@agtsoft:~/temp$ ./fc
f2:10
after:a=3, res=

Answer 9

与上面的bstpierre 一样，我使用并推荐使用显式命名输出变量：

function some_func() # OUTVAR ARG1
{
   local _outvar=$1
   local _result # Use some naming convention to avoid OUTVARs to clash
   ... some processing ....
   eval $_outvar=\$_result # Instead of just =$_result
}

注意引用 $ 的用法。这将避免将 $result 中的内容解释为 shell 特殊字符。我发现这比捕获回声的result=$(some_func "arg1") 习惯用法快一个数量级。在 MSYS 上使用 bash 时速度差异似乎更加显着，从函数调用中捕获标准输出几乎是灾难性的。

可以发送局部变量，因为局部变量在 bash 中是动态范围的：

function another_func() # ARG
{
   local result
   some_func result "$1"
   echo result is $result
}

Answer 10

正如其他人所写，最直接、最可靠的解决方案是使用命令替换：

assign()
{
    local x
    x="Test"
    echo "$x"
}

x=$(assign) # This assigns string "Test" to x

缺点是性能，因为这需要一个单独的过程。

本主题中建议的另一种技术，即传递要分配的变量名称作为参数，有副作用，我不推荐它的基本形式。问题是您可能需要函数中的一些变量来计算返回值，并且可能会发生打算存储返回值的变量名称会干扰其中之一：

assign()
{
    local x
    x="Test"
    eval "$1=\$x"
}

assign y # This assigns string "Test" to y, as expected

assign x # This will NOT assign anything to x in this scope
         # because the name "x" is declared as local inside the function

当然，您可能不会将函数的内部变量声明为本地变量，但您确实应该始终这样做，否则您可能会从父范围中意外覆盖不相关的变量，如果有一个同名。

一种可能的解决方法是将传递的变量显式声明为全局变量：

assign()
{
    local x
    eval declare -g $1
    x="Test"
    eval "$1=\$x"
}

如果名称“x”作为参数传递，函数体的第二行将覆盖之前的局部声明。但是名称本身可能仍然会干扰，因此如果您打算在将返回值写入其中之前使用先前存储在传递变量中的值，请注意您必须在一开始就将其复制到另一个局部变量中；否则结果将不可预测！ 此外，这只适用于最新版本的 BASH，即 4.2。更可移植的代码可能会使用具有相同效果的显式条件构造：

assign()
{
    if [[ $1 != x ]]; then
      local x
    fi
    x="Test"
    eval "$1=\$x"
}

也许最优雅的解决方案就是为函数返回值保留一个全局名称，然后 在您编写的每个函数中始终如一地使用它。

Answer 11

如前所述，从函数返回字符串的“正确”方法是使用命令替换。如果该函数还需要输出到控制台（如上面@Mani 所述），请在函数开头创建一个临时 fd 并重定向到控制台。在返回字符串之前关闭临时 fd。

#!/bin/bash
# file:  func_return_test.sh
returnString() {
    exec 3>&1 >/dev/tty
    local s=$1
    s=${s:="some default string"}
    echo "writing directly to console"
    exec 3>&-     
    echo "$s"
}

my_string=$(returnString "$*")
echo "my_string:  [$my_string]"

执行不带参数的脚本会产生...

# ./func_return_test.sh
writing directly to console
my_string:  [some default string]

希望这对人们有所帮助

-安迪

Answer 12

您可以 echo 一个字符串，但通过管道 (|) 将函数传递给其他东西来捕获它。

您可以使用 expr 执行此操作，但 ShellCheck 报告此用法已弃用。

Answer 13

为了说明我对安迪的回答的评论，额外的文件描述符操作以避免使用/dev/tty：

#!/bin/bash

exec 3>&1

returnString() {
    exec 4>&1 >&3
    local s=$1
    s=${s:="some default string"}
    echo "writing to stdout"
    echo "writing to stderr" >&2
    exec >&4-
    echo "$s"
}

my_string=$(returnString "$*")
echo "my_string:  [$my_string]"

不过还是很讨厌。

Answer 14

我想，选项已经全部列举出来了。选择一个可能归结为您的特定应用程序的最佳样式问题，在这种情况下，我想提供一种我发现有用的特定样式。在 bash 中，变量和函数不在同一个命名空间中。因此，将同名的变量视为函数的值是一种约定，如果我严格应用它，我发现它可以最大限度地减少名称冲突并提高可读性。现实生活中的一个例子：

UnGetChar=
function GetChar() {
    # assume failure
    GetChar=
    # if someone previously "ungot" a char
    if ! [ -z "$UnGetChar" ]; then
        GetChar="$UnGetChar"
        UnGetChar=
        return 0               # success
    # else, if not at EOF
    elif IFS= read -N1 GetChar ; then
        return 0           # success
    else
        return 1           # EOF
    fi
}

function UnGetChar(){
    UnGetChar="$1"
}

还有一个使用此类函数的示例：

function GetToken() {
    # assume failure
    GetToken=
    # if at end of file
    if ! GetChar; then
        return 1              # EOF
    # if start of comment
    elif [[ "$GetChar" == "#" ]]; then
        while [[ "$GetChar" != $'\n' ]]; do
            GetToken+="$GetChar"
            GetChar
        done
        UnGetChar "$GetChar"
    # if start of quoted string
    elif [ "$GetChar" == '"' ]; then
# ... et cetera

如您所见，返回状态可供您在需要时使用，如果不需要则忽略。 “返回”变量同样可以使用或忽略，但当然只有在调用函数之后。

当然，这只是一个约定。您可以在返回之前没有设置关联的值（因此我的约定总是在函数开始时将其归零）或通过再次调用函数（可能是间接地）来践踏其值。尽管如此，如果我发现自己大量使用 bash 函数，这仍然是一个非常有用的约定。

与认为这是一个信号的观点相反，例如“转向 perl”，我的理念是约定对于管理任何语言的复杂性总是很重要的。

Answer 15

在我的程序中，按照惯例，这是预先存在的 $REPLY 变量的用途，read 用于该确切目的。

function getSomeString {
  REPLY="tadaa"
}

getSomeString
echo $REPLY

这个echoes

tadaa

但为了避免冲突，任何其他全局变量都可以。

declare result

function getSomeString {
  result="tadaa"
}

getSomeString
echo $result

如果这还不够，我推荐 Markarian451 的解决方案。

Answer 16

Bash，自 2014 年 2 月（？）版本 4.3 以来，除了“eval”之外，明确支持引用变量或名称引用（namerefs），具有相同的有益性能和间接效果，并且在您的脚本中可能更清晰也更难“忘记 'eval' 而必须修复这个错误”：

declare [-aAfFgilnrtux] [-p] [name[=value] ...]
typeset [-aAfFgilnrtux] [-p] [name[=value] ...]
  Declare variables and/or give them attributes
  ...
  -n Give each name the nameref attribute, making it a name reference
     to another variable.  That other variable is defined by the value
     of name.  All references and assignments to name, except for⋅
     changing the -n attribute itself, are performed on the variable
     referenced by name's value.  The -n attribute cannot be applied to
     array variables.
...
When used in a function, declare and typeset make each name local,
as with the local command, unless the -g option is supplied...

还有：

参数

可以使用 -n 选项为变量分配 nameref 属性 declare 或 local 内置命令（参见 declare 和 local 的描述 下面）创建一个nameref，或对另一个变量的引用。这允许 间接操纵的变量。每当 nameref 变量为 引用或赋值给，操作实际上是在变量上执行的 由 nameref 变量的值指定。 nameref 通常用于 shell 函数引用一个变量，该变量的名称作为参数传递给⋅ 功能。例如，如果将变量名称传递给 shell 函数 作为它的第一个参数，运行

      declare -n ref=$1

在函数内部创建一个nameref变量ref，其值为变量 作为第一个参数传递的名称。对 ref 的引用和分配是 被视为对其名称作为传递的变量的引用和赋值 1美元。如果 for 循环中的控制变量具有 nameref 属性，则列表 of words 可以是 shell 变量的列表，名称引用将是⋅ 依次在执行循环时为列表中的每个单词建立。 不能为数组变量赋予 -n 属性。但是，nameref 变量 可以引用数组变量和下标数组变量。 Namerefs 可以是⋅ 使用 unset 内置的 -n 选项取消设置。否则，如果执行 unset 以 nameref 变量的名称作为参数，由⋅ 引用的变量 nameref 变量将被取消设置。

例如（EDIT 2：（谢谢Ron）命名空间（前缀）函数内部变量名称，以尽量减少外部变量冲突，最终应该正确回答，cmets中提出的问题由卡斯滕）：

# $1 : string; your variable to contain the return value
function return_a_string () {
    declare -n ret=$1
    local MYLIB_return_a_string_message="The date is "
    MYLIB_return_a_string_message+=$(date)
    ret=$MYLIB_return_a_string_message
}

并测试这个例子：

$ return_a_string result; echo $result
The date is 20160817

请注意，bash“declare”内置函数在函数中使用时，默认使声明的变量为“local”，“-n”也可以与“local”一起使用。

我更喜欢将“重要的声明”变量与“无聊的局部”变量区分开来，因此以这种方式使用“声明”和“本地”作为文档。

编辑 1 -（Karsten 对下方评论的回应）-我无法再在下方添加 cmets，但 Karsten 的评论让我思考，所以我做了以下测试，该测试工作正常，AFAICT - Karsten如果您阅读本文，请从命令行提供一组准确的测试步骤，显示您认为存在的问题，因为以下步骤可以正常工作：

$ return_a_string ret; echo $ret
The date is 20170104

（我刚刚运行了这个，将上面的函数粘贴到一个 bash 术语中 - 正如你所看到的，结果很好。）

Answer 17

调用者可以传入变量名（无论是使用eval 还是declare -n）的任何“命名输出变量”方案的关键问题是无意的别名，即名称冲突：从封装的角度来看，它是如果不先检查 ALL 函数的调用者以确保他们不想传递与输出参数相同的名称，就无法在函数中添加或重命名局部变量，这真是太糟糕了。 （或者在另一个方向，我不想读取我正在调用的函数的源代码，只是为了确保我打算使用的输出参数不是该函数中的本地参数。）

解决此问题的唯一方法是使用单个专用输出变量，如 REPLY（如 Evi1M4chine 所建议的那样）或类似 Ron Burk 所建议的约定。

但是，可以让函数在内部使用固定的输出变量，然后在顶部添加一些糖以向调用者隐藏这一事实，因为我'我们已经完成了以下示例中的 call 函数。将其视为概念证明，但关键点是

• 函数总是将返回值赋给REPLY，也可以照常返回退出码
• 从调用者的角度来看，返回值可以分配给任何变量（本地或全局），包括REPLY（参见wrapper 示例）。函数的退出代码是通过的，所以在例如使用它们。 if 或 while 或类似构造按预期工作。
• 从语法上讲，函数调用仍然是一个简单的语句。

之所以可行，是因为call 函数本身没有局部变量，并且除了REPLY 之外不使用任何变量，从而避免了任何可能的名称冲突。在分配调用者定义的输出变量名称时，我们实际上是在调用者的范围内（技术上在 call 函数的相同范围内），而不是在被调用函数的范围内。

#!/bin/bash
function call() { # var=func [args ...]
  REPLY=; "${1#*=}" "${@:2}"; eval "${1%%=*}=\$REPLY; return $?"
}

function greet() {
  case "$1" in
    us) REPLY="hello";;
    nz) REPLY="kia ora";;
    *) return 123;;
  esac
}

function wrapper() {
  call REPLY=greet "$@"
}

function main() {
  local a b c d
  call a=greet us
  echo "a='$a' ($?)"
  call b=greet nz
  echo "b='$b' ($?)"
  call c=greet de
  echo "c='$c' ($?)"
  call d=wrapper us
  echo "d='$d' ($?)"
}
main

输出：

a='hello' (0)
b='kia ora' (0)
c='' (123)
d='hello' (0)

Answer 18

bash 模式返回 scalar 和 array 值对象：

定义

url_parse() { # parse 'url' into: 'url_host', 'url_port', ...
   local "$@" # inject caller 'url' argument in local scope
   local url_host="..." url_path="..." # calculate 'url_*' components
   declare -p ${!url_*} # return only 'url_*' object fields to the caller
}

调用

main() { # invoke url parser and inject 'url_*' results in local scope
   eval "$(url_parse url=http://host/path)" # parse 'url'
   echo "host=$url_host path=$url_path" # use 'url_*' components
}

Answer 19

虽然有很多好的答案，但它们都没有按照我希望的方式工作。因此，这是我的解决方案，其中包含以下关键点：

帮助健忘的程序员

至少我很难在这样的事情之后总是记住错误检查：var=$(myFunction)

允许使用换行符分配值\n

有些解决方案不允许这样做，因为有些解决方案忘记了要分配的值周围的单引号。正确的方法：eval "${returnVariable}='${value}'" 甚至更好：请参阅下面的下一点。

使用printf 代替eval

只需尝试使用类似 myFunction "date && var2" 的东西来解决这里的一些假设解决方案。 eval 将执行赋予它的任何内容。我只想分配值，所以我改用printf -v "${returnVariable}" "%s" "${value}"。

封装和防止变量名冲突

如果其他用户或至少对函数了解较少的人（这可能是我几个月后）正在使用myFunction，我不希望他们知道他必须使用全局返回值名称或一些禁止使用变量名。这就是为什么我在myFunction 的顶部添加了名称检查：

    if [[ "${1}" = "returnVariable" ]]; then
        echo "Cannot give the ouput to \"returnVariable\" as a variable with the same name is used in myFunction()!"
        echo "If that is still what you want to do please do that outside of myFunction()!"
        return 1
    fi

请注意，如果您必须检查大量变量，也可以将其放入函数本身。 如果我仍想使用相同的名称（此处：returnVariable），我只需创建一个缓冲区变量，将其提供给myFunction，然后复制值returnVariable。

原来是这样：

myFunction():

myFunction() {
    if [[ "${1}" = "returnVariable" ]]; then
        echo "Cannot give the ouput to \"returnVariable\" as a variable with the same name is used in myFunction()!"
        echo "If that is still what you want to do please do that outside of myFunction()!"
        return 1
    fi
    if [[ "${1}" = "value" ]]; then
        echo "Cannot give the ouput to \"value\" as a variable with the same name is used in myFunction()!"
        echo "If that is still what you want to do please do that outside of myFunction()!"
        return 1
    fi
    local returnVariable="${1}"
    local value=$'===========\nHello World\n==========='
    echo "setting the returnVariable now..."
    printf -v "${returnVariable}" "%s" "${value}"
}

测试用例：

var1="I'm not greeting!"
myFunction var1
[[ $? -eq 0 ]] && echo "myFunction(): SUCCESS" || echo "myFunction(): FAILURE"
printf "var1:\n%s\n" "${var1}"

# Output:
# setting the returnVariable now...
# myFunction(): SUCCESS
# var1:
# ===========
# Hello World
# ===========

returnVariable="I'm not greeting!"
myFunction returnVariable
[[ $? -eq 0 ]] && echo "myFunction(): SUCCESS" || echo "myFunction(): FAILURE"
printf "returnVariable:\n%s\n" "${returnVariable}"

# Output
# Cannot give the ouput to "returnVariable" as a variable with the same name is used in myFunction()!
# If that is still what you want to do please do that outside of myFunction()!
# myFunction(): FAILURE
# returnVariable:
# I'm not greeting!

var2="I'm not greeting!"
myFunction "date && var2"
[[ $? -eq 0 ]] && echo "myFunction(): SUCCESS" || echo "myFunction(): FAILURE"
printf "var2:\n%s\n" "${var2}"

# Output
# setting the returnVariable now...
# ...myFunction: line ..: printf: `date && var2': not a valid identifier
# myFunction(): FAILURE
# var2:
# I'm not greeting!

myFunction var3
[[ $? -eq 0 ]] && echo "myFunction(): SUCCESS" || echo "myFunction(): FAILURE"
printf "var3:\n%s\n" "${var3}"

# Output
# setting the returnVariable now...
# myFunction(): SUCCESS
# var3:
# ===========
# Hello World
# ===========

Answer 20

#为函数实现一个通用的返回栈：

STACK=()
push() {
  STACK+=( "${1}" )
}
pop() {
  export $1="${STACK[${#STACK[@]}-1]}"
  unset 'STACK[${#STACK[@]}-1]';
}

#用法：

my_func() {
  push "Hello world!"
  push "Hello world2!"
}
my_func ; pop MESSAGE2 ; pop MESSAGE1
echo ${MESSAGE1} ${MESSAGE2}