Bash 함수에서 문자열 값을 반환하는 방법

Bash 함수에서 문자열 값을 반환하는 방법

Bash 함수의 문자열을 반환하고 싶습니다.

이 예제를 Java로 작성하여 원하는 작업을 나타냅니다.

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

String variable = getSomeString();

다음 예시는 bash로 동작합니다만, 더 좋은 방법이 있을까요?

function getSomeString {
   echo "tadaa"
}

VARIABLE=$(getSomeString)

내가 아는 것보다 더 좋은 방법은 없다.Bash는 stdout에 기록된 상태 코드(정수)와 문자열만 알고 있습니다.

함수를 통해 변수를 첫 번째 arg로 지정하고 반환할 문자열을 사용하여 변수를 수정할 수 있습니다.

#!/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 raboof" 라고 출력합니다.

편집: 적절한 위치에 따옴표를 추가하여 @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

위의 모든 답변은 bash의 man 페이지에 기재된 내용을 무시합니다.

• 함수 내에서 선언된 모든 변수는 호출 환경과 공유됩니다.
• 로컬로 선언된 모든 변수는 공유되지 않습니다.

코드 예시

#!/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에서 이 스크립트는 동일한 작업을 수행합니다.

버전 4.3, 2014년 2월(?) 이후 Bash는 "eval" 이상의 참조 변수 또는 이름 참조(namerefs)를 명시적으로 지원하여 동일한 성능 및 간접 효과를 얻을 수 있습니다.또한 스크립트에서 "valuation"을 잊어버리고 이 오류를 수정하기가 어려울 수 있습니다.

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

또, 다음과 같은 것도 있습니다.

파라미터

변수는 declare 명령어 또는 local builtin 명령어에 -n 옵션을 사용하여 nameref Atribute(아래 declare 및 local 설명 참조)를 할당하여 nameref 또는 다른 변수에 대한 참조를 작성할 수 있습니다.이를 통해 변수를 간접적으로 조작할 수 있습니다.nameref 변수가 참조 또는 할당될 때마다 실제로 nameref 변수 값으로 지정된 변수에 대해 동작이 수행됩니다.nameref는 일반적으로 셸 함수 내에서 함수의 인수로 이름이 전달되는 변수를 참조하기 위해 사용됩니다.예를 들어 변수 이름이 첫 번째 인수로 셸 함수에 전달되면

      declare -n ref=$1

함수 내부에 nameref 변수 ref를 만듭니다.이 값은 첫 번째 인수로 전달된 변수 이름입니다.참조 및 참조 할당은 참조로 처리되며 이름이 $1로 전달된 변수에 대한 할당으로 처리됩니다.for 루프의 제어 변수가 nameref 속성을 가지고 있는 경우 단어 목록은 셸 변수 목록이 될 수 있으며 루프가 실행될 때 목록 내의 각 단어에 대해 이름 참조가 확립됩니다.배열 변수에는 -n 특성을 지정할 수 없습니다.그러나 nameref 변수는 배열 변수와 첨자가 있는 배열 변수를 참조할 수 있습니다.namerefs는 -n 옵션을 사용하여 설정되지 않은 빌트인에 대해 설정 해제할 수 있습니다.그렇지 않으면 nameref 변수 이름을 인수로 하여 unset이 실행되면 nameref 변수가 참조하는 변수는 unset이 됩니다.

예를 들어 (EDIT 2: (감사합니다 Ron)은 외부 변수 경합을 최소화하기 위해 함수 내부 변수 이름을 명명(프리픽스)하여 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
}

다음 예를 테스트합니다.

$ return_a_string result; echo $result
The date is 20160817

bash "declare" builtin은 함수로 사용될 때 선언된 변수를 기본적으로 "local"로 만들고 "-n"은 "local"과 함께 사용할 수도 있습니다.

나는 "중요 선언" 변수와 "지루한 로컬" 변수를 구별하는 것을 선호하기 때문에, "선언"과 "로컬"을 이런 방식으로 사용하는 것이 문서 역할을 한다.

편집 1 - (아래의 Karsten의 코멘트에 대한 응답) - 아래에 코멘트를 추가할 수 없습니다.그러나 Karsten의 코멘트를 보고 다음 테스트를 실시했습니다.WORKS FINE, AFAICT - Karsten을 읽고 있는 경우는, 커맨드 라인에 있는 문제의 정확한 테스트 순서를 기입해 주세요.다음의 순서는 정상적으로 동작하기 때문입니다.

$ return_a_string ret; echo $ret
The date is 20170104

(방금 위의 함수를 bash 용어에 붙여넣은 후 실행했는데, 보시다시피 결과는 정상입니다.)

위의 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셸 특수문자로 표시됩니다.나는 이것이 그 보다 훨씬 더 빠른 것을 발견했다.result=$(some_func "arg1")츠미야속도 차이는 함수 호출로부터의 stdout 캡처가 거의 치명적인 MSYS에서 bash를 사용하면 더욱 두드러집니다.

로컬은 bash로 동적으로 스코프가 지정되므로 로컬 변수를 전송해도 괜찮습니다.

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

함수 출력을 캡처할 수도 있습니다.

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

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

이상하게 보이지만 전역 변수 IMHO를 사용하는 것보다 더 좋습니다. 매개 변수를 전달하면 평소처럼 작동합니다. 매개 변수를 괄호나 백틱에 넣기만 하면 됩니다.

가장 간단하고 견고한 솔루션은 다음과 같이 명령어 대체를 사용하는 것입니다.

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

가장 우아한 솔루션은 함수의 반환값에 대해 하나의 글로벌 이름을 예약하고 사용자가 쓰는 모든 함수에 일관되게 사용하는 것입니다.

앞서 설명한 바와 같이 함수에서 문자열을 반환하는 "올바른" 방법은 명령어 대체를 사용하는 것입니다.함수도 콘솔에 출력해야 하는 경우(@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]

이것이 사람들에게 도움이 되기를 바란다

-앤디

글로벌 변수를 사용할 수 있습니다.

declare globalvar='some string'

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

string globalvar

echo "'${globalvar}'"

이것으로 알 수 있다.

'some other string'

에 대한 Andy를 사용하지 기술자를 합니다./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]"

그래도 여전히 끔찍해.

당신이 가지고 있는 방법만이 범위를 벗어나지 않고 이 일을 할 수 있는 유일한 방법입니다.Bash에는 반환 유형의 개념이 없습니다.종료 코드와 파일 기술자(stdin/out/err 등)만 있습니다.

비키 로넨의 머리를 위로 향하게 하고 다음 코드를 고려:

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이치노

모든 옵션이 열거된 것 같습니다.하나를 고르는 것은 당신의 용도에 가장 적합한 스타일의 문제로 귀결될 수 있기 때문에, 저는 그런 점에서 유용하다고 생각되는 특정 스타일을 제안하고 싶습니다.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로 이동"해야 하는 신호라는 생각과는 달리, 어떤 언어의 복잡성에도 규칙이 항상 중요하다는 것이 나의 철학이다.

할 수 있는 (「」를 사용하고 있는지 입니다.eval ★★★★★★★★★★★★★★★★★」declare -n)의 에일리어스가 잘못되어 있습니다.즉, 이름이 충돌합니다.캡슐화의 관점에서는 함수의 모든 발신자를 먼저 체크하고 출력 파라미터와 같은 이름을 전달하고 싶지 않은지 확인하지 않고 함수에 로컬 변수를 추가하거나 이름을 변경할 수 없는 것은 매우 어렵습니다.(또는 다른 방향에서는사용하는 출력 파라미터가 해당 함수의 로컬이 아닌 것을 확인하기 위해 호출하는 함수의 소스를 읽을 필요는 없습니다.)

를 해결하는 유일한 은 단일 입니다.REPLY(Evi1M4chine이 제안한) 또는 론 버크(Ron Burk)가 제안한 것과 유사한 규약.

단, 함수는 내부적으로 고정된 출력 변수를 사용하고, 그 위에 설탕을 조금 첨가하여 발신자에게 이 사실을 숨길 수 있습니다.call하다만, 은, 이라고 생각하시면 됩니다.

• 을 '돌아가다'에 합니다.REPLY대로 종료 .
• 는 「로컬」 「글로벌」을 포함한 임의의 또는 글로벌할 수 .REPLY 「」를 해 주세요).wrapper（ ） 참참참참주 。 이러한 하세요.if ★★★★★★★★★★★★★★★★★」while또는 유사한 구조가 예상대로 작동합니다.
• 구문론적으로 함수 호출은 여전히 하나의 단순한 문입니다.

는 「 」의 「 」의 「 」에 있습니다.call 수 function 、 음음 、 음음음음음음음음음음 other other other other other other other other other other other other other other other other 이외의 변수를 하지 않습니다.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)

좋은 답변이 많았지만 모두 내가 원하는 대로 되지 않았다.다음 요점을 가진 솔루션을 소개합니다.

건망증이 심한 프로그래머 지원

것 에 있는 것 같아요.var=$(myFunction)

바꿈 값을 할 수 있습니다.\n

일부 솔루션에서는 할당할 값 주위에 있는 작은 따옴표를 잊어버렸기 때문에 이를 허용하지 않습니다. 바른법 right right:eval "${returnVariable}='${value}'"또는 더 나은 방법: 다음 사항을 참조하십시오.

「」를 사용합니다.printfeval

이런 거.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
# ===========

이렇게 .$REPLY는 변수인 for입니다.read그 목적을 위해 사용합니다.

function getSomeString {
  REPLY="tadaa"
}

getSomeString
echo $REPLY

(''를 하지 않는 한)local "키워드"bash에는 모든 변수를 스크립트 전체로 글로벌하게 만드는 이상한 동작이 있습니다(적어도 스크립트 작성 후 실행 중인 모든 변수).함수의 범위/폐쇄 내부에 생성된 경우에도 마찬가지입니다. 이 ★★★★★★★★★★★★★★★★★.echo

tadaa

는 는는더 prefer prefer i$REPLY에 의해서도 사용되기 때문에read ★★★★★★★★★★★★★★★★★」select미리 정의되어 있는 것이 좋으며, 다른 목적으로 사용할 가능성은 낮아질 것입니다.그러나 충돌을 피하기 위해서는 다른 글로벌 변수가 필요합니다.

declare result

function getSomeString {
  result="tadaa"
}

getSomeString
echo $result

declare 전 하면 이 가 계속 합니다.bash(어느 쪽인가) '어느 쪽인가'export합니다.ing ing 은 、 은 、 은 、 은 、 은 ing 、 ing ing 、 called ing ing ing ing called called called called called 。

그것만으로는 부족하면 Markarian451의 솔루션을 추천합니다.

하면 돼요.echo잡고 |의 기능을 다른 의 기능을 다른 것으로 변경합니다.

하다, 하다, 하다, 하다, 이렇게 하면 돼요.expr단, Shell Check는 이 사용법을 폐지된 것으로 보고합니다.

bash pattern: 스칼라 및 어레이 값 개체를 모두 반환합니다.

정의.

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
}

#기능에 대한 범용 리턴 스택 구현:

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}

사용자 zenaan이 이전에 게시한 내용을 바탕으로 https://stackoverflow.com/a/38997681/3423146를 작성했습니다.

코드를 복사하여 콘솔에 붙여넣고 있습니다.따라서 콘솔 환경을 코드의 중간 스토리지로 사용합니다.

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

콘솔에서 그런 걸 할 수 있게 해줬어요.

$ declare -f return_a_string
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_date; echo $result_date
The date is Do 16. Mär 14:29:04 CET 2023

$ unset -f return_a_string

$ declare -f return_a_string

$

그가 증명하는 것과는 달리, 셸 스크립트의 실제 온디맨드 라이브러리 통합을 실행할 가능성이 있습니다.이러한 통합은 문자열 값도 반환됩니다(개개의 셸 스크립트 간에 문자열 결과를 건네주는 것과는 아직 약간 다릅니다).이것은 'source' 명령 또는 '로 단축된 것입니다.파일 내의 코드에 의해 부과된 제한을 뛰어넘습니다.

테스트/패키지 코드가 포함된 유사한 라이브러리의 예를 참조하십시오(예: python 스크립트 내에서 사용할 수 있는 스타일).이러한 파일은 MYLIB.bash라고 불립니다.

#!/usr/bin/env bash

function MYLIB_get_current_date_string () {
    # $1 : string; your variable to contain the return value
    declare -n MYLIB_ret=$1

    local MYLIB_get_current_date_string_message="The date is "
    MYLIB_get_current_date_string_message+=$(date)

    MYLIB_ret=$MYLIB_get_current_date_string_message
}

function MYLIB_get_current_date_string_test () {
    local MYLIB_current_date="<unknown>"
    echo "MYLIB_current_date=$MYLIB_current_date"
    MYLIB_get_current_date_string MYLIB_current_date
    echo "MYLIB_current_date=$MYLIB_current_date"
}

MYLIB_base_name=${0##*/}
if [ "$MYLIB_base_name" == "MYLIB.bash" ]; then
    echo "__main__ begin ($MYLIB_base_name)"

    # some test/demo codes:
    MYLIB_get_current_date_string_test

    echo "__main__ end ($MYLIB_base_name)"
fi

# ### EOF ###

위의 라이브러리에서 찾을 수 있는 문자열을 반환하는 함수를 사용하는 다른 셸 스크립팅을 여기서 찾을 수 있습니다.이러한 파일은 MYLIB_app.bash라고 불립니다.

#!/usr/bin/env bash
base_name=${0##*/}
echo "begin ($base_name)"

. ./MYLIB.bash

MYLIB_get_current_date_string current_date
echo current_date=$current_date

echo "end ($base_name)"
# ### EOF ###

첫 번째 파일을 실행하면 다음과 같은 출력이 나타납니다.

$ ./MYLIB.bash
__main__ begin (MYLIB.bash)
MYLIB_current_date=<unknown>
MYLIB_current_date=The date is Do 16. Mär 14:38:29 CET 2023
__main__ end (MYLIB.bash)

두 번째 파일을 실행하면 다음과 같은 출력이 나타납니다.

$ ./MYLIB_app.bash
begin (MYLIB_app.bash)
current_date=The date is Do 16. Mär 14:39:12 CET 2023
end (MYLIB_app.bash)

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=

언급URL : https://stackoverflow.com/questions/3236871/how-to-return-a-string-value-from-a-bash-function