一个bash函数像其他语言一样接受参数？

我有一个bash函数来设置$PATH这样-

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
}

但是问题是，我必须为不同的变量编写不同的函数（例如，为$CLASSPATHlike 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：
：xxx：
$ 
$错误Y $ X1
$ echo：$ Y：
：$ X3：
$ 
$分配Y $ X1
$ echo：$ Y：
：$ X2：
$ 
$分配Y“你好世界”
$ echo：$ Y：
：你好世界：
$＃以下可能是意外的
$分配Z $ Y
$ echo“：$ Z：”
：你好：
$＃，因此如果它是变量，则必须引用第二个参数
$指定Z“ $ Y”
$ echo“：$ Z：”
：你好世界：

但是您无需使用即可实现您的目标eval。我喜欢这样更简单。

以下功能以正确的方式进行替换（我希望）

增加（）{
  本地货币= $ 1
  本地AUGMENT = $ 2
  本地新
  如果[[-z $ CURRENT]]; 然后
    新= $ AUGMENT
  小精灵[[！（（（$ CURRENT = $ AUGMENT）||（$ CURRENT = $ AUGMENT：*）|| \
    （$ CURRENT = *：$ AUGMENT）|| （$ CURRENT = *：$ AUGMENT：*））]]; 然后
    NEW = $ CURRENT：$ AUGMENT
  其他
    NEW = $ CURRENT
    科幻
  回显“ $ 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：


增加：/ bin
:: / bin


扩充“ / usr lib”“ / usr bin”
/ usr库：/ usr bin

扩充“ / usr lib：/ usr bin”“ / usr bin”
/ usr库：/ 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 shell进行迭代改进。因此，它需要确保某些事物尽可能在两个外壳之间工作。因此，这并不意味着总体上编写脚本更容易，而只是比Bourne更好，同时还确保了如果您将脚本从Bourne环境迁移到整个过程中，bash则尽可能地容易。这并不是小菜一碟，因为许多贝壳仍然将Bourne视为事实上的标准。由于人们将其脚本编写为与Bourne兼容（出于这种可移植性），因此这种需求仍然存在，并且永远不会改变。

如果可能的话，最好python还是完全看一下其他的shell脚本（如之类的东西）。如果您遇到某种语言的限制，则需要开始使用一种新的语言。

使用标准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=确保它具有空值，因为参数扩展具有内置的保护措施，以防止在已经设置内联环境的情况下直接重新分配外壳程序环境。

解：

对于您的特定问题，我认为命名参数不是必需的，尽管它们确实是可能的。使用$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很方便。

我找不到像ruby，python等之类的东西，但是感觉离我更近

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

在我看来，可读性更好，声明参数名称需要4行。看起来也更接近现代语言。