Функция 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
}

Но проблема в том, что мне нужно написать разные функции для разных переменных (например, другую функцию для $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опция declare& local:

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

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

Это распечатывает hello, world.

Вы можете использовать evalдля установки параметра. Описание этой команды можно найти здесь . Следующее использование evalневерно:

неправильно(){
  eval $ 1 = $ 2
}

Что касается дополнительной оценки eval, следует ли вам использовать

правопреемник () {
  eval $ 1 = '$ 2'
}

Проверьте результаты использования этих функций:

$ X1 = '$ X2'
$ X2 = '$ X3'
$ X3 = 'ххх'
$ 
$ echo: $ X1:
: $ X2:
$ echo: $ X2:
: $ X3:
$ echo: $ X3:
: Ххх:
$ 
$ неправильно Y $ X1
$ echo: $ Y:
: $ X3:
$ 
$ assign Y $ X1
$ echo: $ Y:
: $ X2:
$ 
$ assign Y "Привет, мир"
$ echo: $ Y:
: hallo world:
$ # следующее может быть неожиданным
$ assign Z $ Y
$ echo ": $ Z:"
: Hallo:
$ #, поэтому вы должны заключить в кавычки второй аргумент, если это переменная
$ assign Z "$ Y"
$ echo ": $ Z:"
: hallo world:

Но вы можете достичь своей цели без использования eval. Я предпочитаю этот способ, который является более простым.

Следующая функция делает замену правильным образом (надеюсь)

Augment () {
  местный ТОК = 1 $
  местный АВГУМЕНТ = 2 $
  местный NEW
  if [[-z $ CURRENT]]; тогда
    NEW = $ увеличивающие
  элиф [[! (($ CURRENT = $ AUGMENT) || ($ CURRENT = $ AUGMENT: *) || \
    ($ CURRENT = *: $ AUGMENT) || ($ CURRENT = *: $ AUGMENT: *))]]; тогда
    NEW = $ CURRENT: $ увеличивающие
  еще
    NEW = $ ТОК
    фи
  echo "$ NEW"
}

Проверьте следующий вывод

augment / usr / bin / bin
/ USR / бен: / бен

augment / usr / bin: / bin / bin
/ USR / бен: / бен

augment / usr / bin: / bin: / usr / local / bin / bin
/ USR / бен: / бен: / USR / местные / бен

augment / bin: / usr / bin / bin
/ Бен: / USR / бен

аугмент / бин / бин
/ бен


augment / usr / bin: / bin
/ USR / бен :: / бен

augment / usr / bin: / bin: / bin
/ USR / бен: / бен:

augment / usr / bin: / bin: / usr / local / bin: / bin
/ USR / бен: / бен: / USR / местные / бен:

augment / bin: / usr / bin: / bin
/ Бен: / USR / бен:

augment / bin: / bin
/ Бен:


увеличить: / bin
:: / бен


увеличить "/ usr lib" "/ usr bin"
/ usr lib: / usr bin

augment "/ usr lib: / usr bin" "/ usr bin"
/ usr lib: / usr bin

Теперь вы можете использовать augmentфункцию следующим образом для установки переменной:

PATH = `увеличить 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. Как таковой, он должен гарантировать, что определенные вещи работают между двумя оболочками в максимально возможной степени. Таким образом, это не означает, что в целом сценарий проще, он просто лучше, чем Борн, и при этом гарантирует, что если вы перенесете сценарий из среды Борна в bashмаксимально простой режим . Это не тривиально, так как многие оболочки по-прежнему рассматривают Борн как стандарт де-факто. Поскольку люди пишут свои сценарии для 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«s» 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 строки избыточны для объявления имен ваших параметров. Смотрится ближе к современным языкам.