Cách trả về giá trị chuỗi từ hàm Bash

Tôi muốn trả về một chuỗi từ hàm Bash.

Tôi sẽ viết ví dụ trong java để hiển thị những gì tôi muốn làm:

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

String variable = getSomeString();

Ví dụ dưới đây hoạt động trong bash, nhưng có cách nào tốt hơn để làm điều này không?

function getSomeString {
   echo "tadaa"
}

VARIABLE=$(getSomeString)

Không có cách nào tốt hơn tôi biết. Bash chỉ biết mã trạng thái (số nguyên) và chuỗi được ghi vào thiết bị xuất chuẩn.

Bạn có thể có hàm lấy một biến làm đối số đầu tiên và sửa đổi biến với chuỗi bạn muốn trả về.

#!/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

In "foo bar rab oof".

Chỉnh sửa : đã thêm trích dẫn ở vị trí thích hợp để cho phép khoảng trắng trong chuỗi giải quyết nhận xét của @Luca Borrione.

Chỉnh sửa : Như một minh chứng, xem chương trình sau đây. Đây là một giải pháp cho mục đích chung: thậm chí nó còn cho phép bạn nhận một chuỗi thành một biến cục bộ.

#!/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"

Bản in này:

+ 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

Chỉnh sửa : chứng minh rằng giá trị của biến gốc là có sẵn trong các chức năng, như đã sai chỉ trích bởi @Xichen Li trong nhận xét.

#!/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"

Điều này cho đầu ra:

+ 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

Tất cả các câu trả lời ở trên bỏ qua những gì đã được nêu trong trang man của bash.

• Tất cả các biến được khai báo bên trong một hàm sẽ được chia sẻ với môi trường gọi.
• Tất cả các biến được khai báo cục bộ sẽ không được chia sẻ.

Mã ví dụ

#!/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

Và đầu ra

$ 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

Cũng theo pdksh và ksh kịch bản này cũng làm như vậy!

Bash, kể từ phiên bản 4.3, feb 2014 (?), Có hỗ trợ rõ ràng cho các biến tham chiếu hoặc tham chiếu tên (namerefs), ngoài "eval", với hiệu suất và hiệu ứng gián tiếp có lợi tương tự, và có thể rõ ràng hơn trong các tập lệnh của bạn và cũng khó hơn để "quên" eval "và phải sửa lỗi này":

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...

và cũng:

THÔNG SỐ

Một biến có thể được gán thuộc tính nameref bằng cách sử dụng tùy chọn -n cho các lệnh khai báo hoặc lệnh dựng sẵn cục bộ (xem mô tả khai báo và cục bộ bên dưới) để tạo nameref hoặc tham chiếu đến biến khác. Điều này cho phép các biến được thao tác gián tiếp. Bất cứ khi nào biến nameref được tham chiếu hoặc gán cho, thao tác thực sự được thực hiện trên biến được chỉ định bởi giá trị của biến nameref. Một nameref thường được sử dụng trong các hàm shell để chỉ một biến có tên được truyền dưới dạng đối số cho hàm. Chẳng hạn, nếu một tên biến được truyền cho hàm shell làm đối số đầu tiên của nó, thì chạy

      declare -n ref=$1

bên trong hàm tạo ra một biến nameref ref có giá trị là tên biến được truyền làm đối số đầu tiên. Tài liệu tham khảo và bài tập cho ref được coi là tài liệu tham khảo và bài tập cho biến có tên được chuyển là 1 $. Nếu biến điều khiển trong vòng lặp for có thuộc tính nameref, danh sách các từ có thể là danh sách các biến shell và tham chiếu tên sẽ được thiết lập cho mỗi từ trong danh sách, lần lượt, khi vòng lặp được thực thi. Biến mảng không thể được cho thuộc tính -n. Tuy nhiên, các biến nameref có thể tham chiếu các biến mảng và biến mảng được đăng ký. Namerefs có thể được hủy đặt bằng cách sử dụng tùy chọn -n cho phần dựng sẵn chưa đặt. Mặt khác, nếu unset được thực thi với tên của biến nameref làm đối số,

Ví dụ ( EDIT 2 : (cảm ơn Ron) đã đặt tên (tiền tố) tên biến nội bộ hàm, để giảm thiểu xung đột biến ngoài, cuối cùng sẽ trả lời đúng, vấn đề được nêu trong các nhận xét của Karsten):

# $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
}

và thử nghiệm ví dụ này:

$ return_a_string result; echo $result
The date is 20160817

Lưu ý rằng bash "khai báo" dựng sẵn, khi được sử dụng trong một hàm, làm cho biến khai báo là "cục bộ" theo mặc định và "-n" cũng có thể được sử dụng với "cục bộ".

Tôi thích phân biệt các biến "khai báo quan trọng" với các biến "nhàm chán cục bộ", vì vậy sử dụng "khai báo" và "cục bộ" theo cách này đóng vai trò là tài liệu.

EDIT 1 - (Trả lời nhận xét bên dưới của Karsten) - Tôi không thể thêm nhận xét bên dưới nữa, nhưng nhận xét của Karsten khiến tôi suy nghĩ, vì vậy tôi đã thực hiện bài kiểm tra sau đây WORKS FINE, AFAICT - Karsten nếu bạn đọc điều này, vui lòng cung cấp một bộ chính xác trong số các bước kiểm tra từ dòng lệnh, hiển thị sự cố mà bạn cho là tồn tại, bởi vì các bước sau hoạt động tốt:

$ return_a_string ret; echo $ret
The date is 20170104

(Tôi đã chạy nó ngay bây giờ, sau khi dán hàm trên vào một thuật ngữ bash - như bạn có thể thấy, kết quả hoạt động tốt.)

Giống như bstpierre ở trên, tôi sử dụng và khuyên bạn nên sử dụng các biến đầu ra đặt tên rõ ràng:

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
}

Lưu ý việc sử dụng trích dẫn $. Điều này sẽ tránh việc diễn giải nội dung $resultdưới dạng các ký tự đặc biệt. Tôi đã thấy rằng đây là một thứ tự cường độ nhanh hơnresult=$(some_func "arg1") thành ngữ bắt được tiếng vang. Sự khác biệt về tốc độ dường như còn đáng chú ý hơn khi sử dụng bash trên MSYS trong đó việc bắt lỗi từ các lệnh gọi hàm gần như là thảm họa.

Bạn có thể gửi một biến cục bộ vì người dân địa phương có phạm vi động trong bash:

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

Bạn cũng có thể chụp đầu ra chức năng:

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

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

Trông có vẻ lạ, nhưng tốt hơn là sử dụng các biến toàn cầu IMHO. Truyền tham số hoạt động như bình thường, chỉ cần đặt chúng bên trong niềng răng hoặc backticks.

Giải pháp đơn giản và mạnh mẽ nhất là sử dụng thay thế lệnh, như những người khác đã viết:

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

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

Nhược điểm là hiệu suất vì điều này đòi hỏi một quá trình riêng biệt.

Kỹ thuật khác được đề xuất trong chủ đề này, cụ thể là chuyển tên của một biến để gán cho làm đối số, có tác dụng phụ và tôi không đề xuất nó ở dạng cơ bản. Vấn đề là bạn có thể sẽ cần một số biến trong hàm để tính giá trị trả về và có thể xảy ra rằng tên của biến dự định lưu trữ giá trị trả về sẽ can thiệp vào một trong số chúng:

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

Tất nhiên, bạn có thể không khai báo các biến nội bộ của hàm là cục bộ, nhưng bạn thực sự nên luôn luôn làm điều đó vì nếu không, bạn có thể vô tình ghi đè lên một biến không liên quan từ phạm vi cha nếu có một biến có cùng tên .

Một cách giải quyết khác có thể là một tuyên bố rõ ràng về biến được truyền là toàn cục:

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

Nếu tên "x" được truyền dưới dạng đối số, hàng thứ hai của thân hàm sẽ ghi đè khai báo cục bộ trước đó. Nhưng bản thân các tên vẫn có thể can thiệp, vì vậy nếu bạn có ý định sử dụng giá trị được lưu trước đó trong biến đã truyền trước khi ghi giá trị trả về ở đó, hãy lưu ý rằng bạn phải sao chép nó vào một biến cục bộ khác ngay từ đầu; nếu không thì kết quả sẽ khó lường! Bên cạnh đó, điều này sẽ chỉ hoạt động trong phiên bản BASH mới nhất, cụ thể là 4.2. Nhiều mã di động hơn có thể sử dụng các cấu trúc có điều kiện rõ ràng có cùng tác dụng:

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

Có lẽ giải pháp tao nhã nhất là chỉ dành một tên toàn cầu cho các giá trị trả về hàm và sử dụng nó một cách nhất quán trong mọi chức năng bạn viết.

Như đã đề cập trước đây, cách "chính xác" để trả về một chuỗi từ một hàm là thay thế lệnh. Trong trường hợp hàm cũng cần xuất ra giao diện điều khiển (như @Mani đã đề cập ở trên), hãy tạo một fd tạm thời khi bắt đầu chức năng và chuyển hướng đến bàn điều khiển. Đóng fd tạm thời trước khi trả lại chuỗi của bạn.

#!/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]"

thực thi tập lệnh không có thông số sản xuất ...

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

hy vọng điều này sẽ giúp mọi người

-Andy

Bạn có thể sử dụng một biến toàn cục:

declare globalvar='some string'

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

string globalvar

echo "'${globalvar}'"

Điều này mang lại

'some other string'

Để minh họa nhận xét của tôi về câu trả lời của Andy, với thao tác mô tả tệp bổ sung để tránh sử dụng /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]"

Vẫn khó chịu, mặc dù.

Cách bạn có nó là cách duy nhất để làm điều này mà không phá vỡ phạm vi. Bash không có khái niệm về kiểu trả về, chỉ cần thoát mã và mô tả tệp (stdin / out / err, v.v.)

Giải quyết vấn đề của Vicky Ronnen , xem xét đoạn mã sau:

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

sẽ cho

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

Có thể kịch bản bình thường là sử dụng cú pháp được sử dụng trong test_inside_a_funchàm, do đó bạn có thể sử dụng cả hai phương thức trong phần lớn các trường hợp, mặc dù nắm bắt đầu ra là phương pháp an toàn hơn luôn hoạt động trong mọi tình huống, bắt chước giá trị trả về từ một hàm mà bạn có thể tìm trong các ngôn ngữ khác, như được Vicky Ronnenchỉ ra chính xác.

Các tùy chọn đã được liệt kê tất cả, tôi nghĩ. Chọn một thứ có thể đi vào một vấn đề về phong cách tốt nhất cho ứng dụng cụ thể của bạn và trong đó, tôi muốn cung cấp một phong cách cụ thể mà tôi thấy hữu ích. Trong bash, các biến và hàm không nằm trong cùng một không gian tên. Vì vậy, coi biến cùng tên là giá trị của hàm là một quy ước mà tôi thấy giảm thiểu xung đột tên và tăng cường khả năng đọc, nếu tôi áp dụng nó một cách chặt chẽ. Một ví dụ từ cuộc sống thực:

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"
}

Và, một ví dụ về việc sử dụng các chức năng như vậy:

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

Như bạn có thể thấy, trạng thái trả lại là có để bạn sử dụng khi bạn cần hoặc bỏ qua nếu bạn không. Biến "trả lại" cũng có thể được sử dụng hoặc bỏ qua, nhưng tất nhiên chỉ sau hàm được gọi.

Tất nhiên, đây chỉ là một quy ước. Bạn có thể không đặt giá trị được liên kết trước khi quay lại (do đó, quy ước của tôi là luôn vô hiệu hóa nó khi bắt đầu hàm) hoặc chà đạp giá trị của nó bằng cách gọi lại hàm (có thể gián tiếp). Tuy nhiên, đó là một quy ước tôi thấy rất hữu ích nếu tôi thấy mình sử dụng nhiều chức năng bash.

Trái ngược với tình cảm rằng đây là một dấu hiệu, ví dụ như "chuyển sang perl", triết lý của tôi là các quy ước luôn quan trọng để quản lý sự phức tạp của bất kỳ ngôn ngữ nào.

Bạn có thể echomột chuỗi, nhưng bắt nó bằng cách chuyển ( |) hàm sang một thứ khác.

Bạn có thể làm điều đó với expr, mặc dù ShellCheck báo cáo việc sử dụng này là không dùng nữa.

Vấn đề chính của họ về bất kỳ lược đồ 'biến đầu ra có tên' nào mà người gọi có thể chuyển qua tên biến (dù sử dụng evalhay declare -n) là bí danh vô tình, tức là xung đột tên: Từ quan điểm đóng gói, thật tệ khi không thể thêm hoặc đổi tên một biến cục bộ trong một hàm mà không kiểm tra TẤT CẢ người gọi của hàm trước để đảm bảo rằng họ không muốn chuyển cùng tên đó với tham số đầu ra. (Hoặc theo một hướng khác, tôi không muốn phải đọc nguồn của hàm tôi đang gọi chỉ để đảm bảo tham số đầu ra tôi định sử dụng không phải là cục bộ trong hàm đó.)

Cách duy nhất là sử dụng một biến đầu ra chuyên dụng duy nhất như REPLY(như được đề xuất bởi Evi1M4chine ) hoặc một quy ước giống như quy tắc được đề xuất bởi Ron Burk .

Tuy nhiên, có thể có các hàm sử dụng một biến đầu ra cố định trong nội bộ , sau đó thêm một ít đường lên trên cùng để che giấu sự thật này khỏi người gọi , như tôi đã thực hiện với callhàm trong ví dụ sau. Hãy coi đây là một bằng chứng về khái niệm, nhưng những điểm chính là

• Hàm luôn gán giá trị trả về cho REPLYvà cũng có thể trả về mã thoát như bình thường
• Từ quan điểm của người gọi, giá trị trả về có thể được gán cho bất kỳ biến nào (cục bộ hoặc toàn cầu) bao gồm REPLY(xem wrapperví dụ). Mã thoát của hàm được truyền qua, do đó, sử dụng chúng trong ví dụ ifhoặc một whilecấu trúc tương tự hoạt động như mong đợi.
• Cú pháp gọi hàm vẫn là một câu lệnh đơn giản.

Lý do điều này hoạt động là vì callbản thân hàm không có địa phương và không sử dụng biến nào khác ngoài việc REPLYtránh bất kỳ tiềm năng nào cho xung đột tên. Tại điểm đặt tên biến đầu ra do người gọi xác định, chúng tôi thực sự ở trong phạm vi của người gọi (về mặt kỹ thuật trong phạm vi giống hệt của callhàm), thay vì trong phạm vi của hàm được gọi.

#!/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

Đầu ra:

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

mẫu bash để trả về cả hai đối tượng giá trị vô hướng và mảng :

Định nghĩa

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
}

cầu khẩn

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
}

Trong các chương trình của tôi, theo quy ước, đây là những gì mà biến trước $REPLYđó readdùng để sử dụng cho mục đích chính xác đó.

function getSomeString {
  REPLY="tadaa"
}

getSomeString
echo $REPLY

Đây echoes

tadaa

Nhưng để tránh xung đột, bất kỳ biến toàn cầu nào khác sẽ làm.

declare result

function getSomeString {
  result="tadaa"
}

getSomeString
echo $result

Nếu điều đó là không đủ, tôi khuyên bạn nên sử dụng giải pháp Markarian451 .

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=