다른 언어와 마찬가지로 인수를 취하는 bash 함수?

다음 $PATH과 같이 설정하는 bash 함수가 있습니다.

assign-path()
{
    str=$1
    # if the $PATH is empty, assign it directly.
    if [ -z $PATH ]; then
        PATH=$str;
    # if the $PATH does not contain the substring, append it with ':'.
    elif [[ $PATH != *$str* ]]; then
        PATH=$PATH:$str;
    fi
}

그러나 문제는 내가 다른 변수에 대한 다른 기능을 쓸 필요가있다 (예를 들어, 또 다른 기능 $CLASSPATH등 assign-classpath()등). bash 함수에 인수를 전달하여 참조로 액세스 할 수있는 방법을 찾을 수 없습니다.

다음과 같은 것이 있다면 더 좋을 것입니다.

assign( bigstr, substr )
{
    if [ -z bigstr ]; then
        bigstr=substr;
    elif [[ bigstr != *str* ]]; then
        bigstr=bigstr:substr;
    fi
}

bash에서 위와 같은 것을 얻는 방법은 무엇입니까?

에서 bash당신이 사용할 수있는 ${!varname}또 다른의 내용에 의해 참조 변수를 확장 할 수 있습니다. 예 :

$ var=hello
$ foo () { echo "${!1}"; }
$ foo var
hello

매뉴얼 페이지에서 :

${!prefix*}
${!prefix@}
       Names matching prefix.  Expands to the names of variables whose names
       begin with prefix, separated by the first character of the IFS special
       variable.  When @ is used  and the expansion appears within double quotes,
       each variable name expands to a separate word.

또한 내용에서 참조하는 변수를 (위험없이 eval) 설정하려면을 사용할 수 있습니다 declare. 예 :

$ var=target
$ declare "$var=hello"
$ echo "$target"
hello

따라서 다음과 같이 함수를 작성할 수 있습니다 (함수 declare에서 사용 하는 -g경우 변수를 제공해야합니다 .

shopt -s extglob

assign()
{
  target=$1
  bigstr=${!1}
  substr=$2

  if [ -z "$bigstr" ]; then
    declare -g -- "$target=$substr"
  elif [[ $bigstr != @(|*:)$substr@(|:*) ]]; then
    declare -g -- "$target=$bigstr:$substr"
  fi
}

그리고 그것을 다음과 같이 사용하십시오 :

assign PATH /path/to/binaries

또한 substr콜론으로 구분 된 멤버 중 하나의 하위 문자열이지만 이미 bigstr자체 멤버가 아닌 하위 버그 인 경우 추가되지 않는 버그를 수정했습니다 . 예를 들어, 이미 포함 /bin된 PATH변수에 추가 할 수 /usr/bin있습니다. extglob문자열의 시작 / 끝 또는 콜론과 일치 하는 집합을 사용합니다 . 이 없으면 extglob대안은 다음과 같습니다.

[[ $bigstr != $substr && $bigstr != *:$substr &&
   $bigstr != $substr:* && $bigstr != *:$substr:* ]]

bash 4.3의 새로운 기능은 & -n옵션입니다 .declarelocal

func() {
    local -n ref="$1"
    ref="hello, world"
}

var='goodbye world'
func var
echo "$var"

인쇄됩니다 hello, world.

eval매개 변수를 설정하는 데 사용할 수 있습니다 . 이 명령에 대한 설명은 여기 에서 찾을 수 있습니다 . 다음 사용법 eval이 잘못되었습니다.

잘못된(){
  평가 $ 1 = $ 2
}

추가 평가와 관련하여 eval사용해야합니까?

양수인(){
  평가 $ 1 = '$ 2'
}

다음 기능을 사용한 결과를 확인하십시오.

$ X1 = '$ X2'
$ X2 = '$ X3'
$ X3 = 'xxx'
$ 
$ echo : $ X1 :
: $ X2 :
$ echo : $ X2 :
: $ X3 :
$ echo : $ X3 :
:트리플 엑스:
$ 
$ 잘못된 Y $ X1
$ echo : $ Y :
: $ X3 :
$ 
$ 할당 Y $ X1
$ echo : $ Y :
: $ X2 :
$ 
$ "할로 월드"할당
$ echo : $ Y :
: 할로 월드 :
$ # 다음은 예상치 못한 것일 수 있습니다.
$ 할당 Z $ Y
$ echo ": $ Z :"
:어이:
$ # 그래서 변수의 경우 두 번째 인수를 인용해야합니다
$ Z "$ Y"할당
$ echo ": $ Z :"
: 할로 월드 :

그러나를 사용하지 않고도 목표를 달성 할 수 있습니다 eval. 더 간단한 방법을 선호합니다.

다음 함수는 올바른 방식으로 대체를 만듭니다.

기능 보강 () {
  로컬 CURRENT = $ 1
  지역 AUGMENT = $ 2
  지역 NEW
  [[-z $ CURRENT]] 인 경우; 그때
    NEW = $ AUGMENT
  elif [[! (($ CURRENT = $ AUGMENT) || ($ CURRENT = $ AUGMENT : *) || \
    ($ CURRENT = * : $ AUGMENT) || ($ CURRENT = * : $ AUGMENT : *))]] ;; 그때
    NEW = $ 현재 : $ AUGMENT
  그밖에
    NEW = $ 현재
    fi
  에코 "$ NEW"
}

다음 출력을 확인하십시오

확대 / usr / bin / bin
/ usr / bin : / bin

기능 보강 / usr / bin : / bin / bin
/ usr / bin : / bin

기능 보강 / usr / bin : / bin : / usr / local / bin / bin
/ usr / bin : / bin : / usr / local / bin

기능 보강 / bin : / usr / bin / bin
/ bin : / usr / bin

기능 보강 / bin / bin
/큰 상자


기능 보강 / usr / bin : / bin
/ usr / bin :: / bin

기능 보강 / usr / bin : / bin : / bin
/ usr / bin : / bin :

기능 보강 / usr / bin : / bin : / usr / local / bin : / bin
/ usr / bin : / bin : / usr / local / bin :

기능 보강 / bin : / usr / bin : / bin
/ bin : / usr / bin :

기능 보강 / bin : / bin
/큰 상자:


기능 보강 : / bin
::/큰 상자


기능 보강 "/ usr lib" "/ usr bin"
/ usr lib : / usr bin

기능 보강 "/ usr lib : / usr bin" "/ usr bin"
/ usr lib : / usr bin

이제 augment다음 방법으로 함수를 사용하여 변수를 설정할 수 있습니다.

PATH =`확장 경로 / bin`
CLASSPATH =`CLASSPATH / bin` 기능 보강
LD_LIBRARY_PATH =`LD_LIBRARY_PATH / usr / lib를 추가하십시오`

몇 가지 트릭을 사용하면 실제로 배열과 함께 명명 된 매개 변수를 함수에 전달할 수 있습니다 (bash 3 및 4에서 테스트 됨).

내가 개발 한 방법을 사용하면 다음과 같은 함수에 전달 된 매개 변수에 액세스 할 수 있습니다

testPassingParams() {

    @var hello
    l=4 @array anArrayWithFourElements
    l=2 @array anotherArrayWithTwo
    @var anotherSingle
    @reference table   # references only work in bash >=4.3
    @params anArrayOfVariedSize

    test "$hello" = "$1" && echo correct
    #
    test "${anArrayWithFourElements[0]}" = "$2" && echo correct
    test "${anArrayWithFourElements[1]}" = "$3" && echo correct
    test "${anArrayWithFourElements[2]}" = "$4" && echo correct
    # etc...
    #
    test "${anotherArrayWithTwo[0]}" = "$6" && echo correct
    test "${anotherArrayWithTwo[1]}" = "$7" && echo correct
    #
    test "$anotherSingle" = "$8" && echo correct
    #
    test "${table[test]}" = "works"
    table[inside]="adding a new value"
    #
    # I'm using * just in this example:
    test "${anArrayOfVariedSize[*]}" = "${*:10}" && echo correct
}

fourElements=( a1 a2 "a3 with spaces" a4 )
twoElements=( b1 b2 )
declare -A assocArray
assocArray[test]="works"

testPassingParams "first" "${fourElements[@]}" "${twoElements[@]}" "single with spaces" assocArray "and more... " "even more..."

test "${assocArray[inside]}" = "adding a new value"

다시 말해, 이름으로 매개 변수를 호출 할 수있을뿐만 아니라 (더 읽기 쉬운 코어를 구성 함) 실제로 배열을 전달할 수 있습니다 (변수에 대한 참조-이 기능은 bash 4.3에서만 작동합니다). 또한 매핑 된 변수는 모두 $ 1 (및 기타)과 같이 로컬 범위에 있습니다.

이 작업을 수행하는 코드는 매우 가볍고 bash 3 및 bash 4에서 모두 작동합니다 (이것은 테스트 한 유일한 버전입니다). bash로 개발하는 것을 훨씬 더 좋고 쉽게 만드는 더 많은 트릭에 관심이 있다면 Bash Infinity Framework를 살펴보십시오. 아래 코드는 그 목적을 위해 개발되었습니다.

Function.AssignParamLocally() {
    local commandWithArgs=( $1 )
    local command="${commandWithArgs[0]}"

    shift

    if [[ "$command" == "trap" || "$command" == "l="* || "$command" == "_type="* ]]
    then
        paramNo+=-1
        return 0
    fi

    if [[ "$command" != "local" ]]
    then
        assignNormalCodeStarted=true
    fi

    local varDeclaration="${commandWithArgs[1]}"
    if [[ $varDeclaration == '-n' ]]
    then
        varDeclaration="${commandWithArgs[2]}"
    fi
    local varName="${varDeclaration%%=*}"

    # var value is only important if making an object later on from it
    local varValue="${varDeclaration#*=}"

    if [[ ! -z $assignVarType ]]
    then
        local previousParamNo=$(expr $paramNo - 1)

        if [[ "$assignVarType" == "array" ]]
        then
            # passing array:
            execute="$assignVarName=( \"\${@:$previousParamNo:$assignArrLength}\" )"
            eval "$execute"
            paramNo+=$(expr $assignArrLength - 1)

            unset assignArrLength
        elif [[ "$assignVarType" == "params" ]]
        then
            execute="$assignVarName=( \"\${@:$previousParamNo}\" )"
            eval "$execute"
        elif [[ "$assignVarType" == "reference" ]]
        then
            execute="$assignVarName=\"\$$previousParamNo\""
            eval "$execute"
        elif [[ ! -z "${!previousParamNo}" ]]
        then
            execute="$assignVarName=\"\$$previousParamNo\""
            eval "$execute"
        fi
    fi

    assignVarType="$__capture_type"
    assignVarName="$varName"
    assignArrLength="$__capture_arrLength"
}

Function.CaptureParams() {
    __capture_type="$_type"
    __capture_arrLength="$l"
}

alias @trapAssign='Function.CaptureParams; trap "declare -i \"paramNo+=1\"; Function.AssignParamLocally \"\$BASH_COMMAND\" \"\$@\"; [[ \$assignNormalCodeStarted = true ]] && trap - DEBUG && unset assignVarType && unset assignVarName && unset assignNormalCodeStarted && unset paramNo" DEBUG; '
alias @param='@trapAssign local'
alias @reference='_type=reference @trapAssign local -n'
alias @var='_type=var @param'
alias @params='_type=params @param'
alias @array='_type=array @param'

assign () 
{ 
    if [ -z ${!1} ]; then
        eval $1=$2
    else
        if [[ ${!1} != *$2* ]]; then
            eval $1=${!1}:$2
        fi
    fi
}

$ echo =$x=
==
$ assign x y
$ echo =$x=
=y=
$ assign x y
$ echo =$x=
=y=
$ assign x z
$ echo =$x=
=y:z=

맞습니까?

명명 된 인수는 단순히 Bash의 구문이 설계된 방식이 아닙니다. Bash는 Bourne 쉘을 반복적으로 개선하도록 설계되었습니다. 따라서 가능한 한 두 쉘 사이에서 특정 작업을 수행해야합니다. 가되지 않도록 의미 전반적인와 스크립트 쉽게로, 당신이 넘어서하는 본 환경에서 스크립트를 가지고가는 경우에 보장하면서 Bourne 씨보다 더 될 운명이야 bash는 가능한 한 쉽게합니다. 많은 껍질이 여전히 Bourne을 사실상의 표준으로 취급하기 때문에 사소한 것은 아닙니다. 사람들이 스크립트를 Bourne과 호환되도록 작성하기 때문에 (이 이식성을 위해) 요구는 여전히 유효하며 변경되지 않을 것입니다.

python가능하다면 다른 쉘 스크립트 (예 : 비슷한 것)를 완전히 보는 것이 좋습니다. 언어의 한계에 부딪 치면 새로운 언어를 사용해야합니다.

표준 sh구문을 사용하면 (에서뿐만 bash아니라에서 작동 bash할 수 있음) 다음을 수행 할 수 있습니다.

assign() {
  eval '
    case :${'"$1"'}: in
      (::) '"$1"'=$2;;   # was empty, copy
      (*:"$2":*) ;;      # already there, do nothing
      (*) '"$1"'=$1:$2;; # otherwise, append with a :
    esac'
}

솔루션은 사용처럼 bash의를 declare, 그것의 안전 만큼으로 $1유효한 변수의 이름이 포함되어 있습니다.

명명 된 아치에서 :

이것은 매우 간단하게 수행되며 bash전혀 필요하지는 않습니다. 이것은 매개 변수 확장을 통한 기본 POSIX 지정 할당 동작입니다.

: ${PATH:=this is only assigned to \$PATH if \$PATH is null or unset}

@Graeme과 비슷한 맥락에서 휴대용 방식으로 데모하려면 :

_fn() { echo "$1 ${2:-"$1"} $str" ; }

% str= ; _fn "${str:=hello}"
> hello hello hello

그리고 str=매개 변수 확장에는 이미 설정된 쉘 환경을 인라인으로 재할 당하지 못하도록 내장 된 보호 기능이 있기 때문에 null 값을 갖도록하기 만합니다.

해결책:

귀하의 특정 문제에 대해서는 분명히 가능하지만 명명 된 인수가 필요하다고 생각하지 않습니다. $IFS대신 사용하십시오 :

assign() { oFS=$IFS ; IFS=: ; add=$* 
    set -- $PATH ; for p in $add ; do { 
        for d ; do [ -z "${d%"$p"}" ] && break 
        done ; } || set -- $* $p ; done
    PATH= ; echo "${PATH:="$*"}" ; IFS=$oFS
}

내가 그것을 실행할 때 얻는 것은 다음과 같습니다.

% PATH=/usr/bin:/usr/yes/bin
% assign \
    /usr/bin \
    /usr/yes/bin \
    /usr/nope/bin \
    /usr/bin \
    /nope/usr/bin \
    /usr/nope/bin

> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin

% echo "$PATH"
> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin

% dir="/some crazy/dir"
% p=`assign /usr/bin /usr/bin/new "$dir"`
% echo "$p" ; echo "$PATH"
> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin:/some crazy/dir:/usr/bin/new
> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin:/some crazy/dir:/usr/bin/new

아직 없었 $PATH거나 이전에 나온 주장 만 추가 했습니까? 아니면 심지어 하나 이상의 논쟁이 필요 했습니까? $IFS편리합니다.

루비, 파이썬 등과 같은 것을 찾을 수 없지만 이것은 나에게 더 가깝습니다.

foo() {
  BAR="$1"; BAZ="$2"; QUUX="$3"; CORGE="$4"
  ...
}

내 의견으로는 가독성이 더 좋으며 매개 변수 이름을 선언하는 데 4 줄이 과도합니다. 현대 언어에 더 가깝게 보입니다.