Fungsi bash yang mengambil argumen seperti bahasa lain?

Saya memiliki fungsi bash untuk mengatur $PATHseperti ini -

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
}

Tetapi masalahnya adalah, saya harus menulis fungsi yang berbeda untuk variabel yang berbeda (misalnya, fungsi lain untuk $CLASSPATHsuka assign-classpath()dll.). Saya tidak dapat menemukan cara untuk meneruskan argumen ke fungsi bash sehingga saya dapat mengaksesnya dengan referensi.

Akan lebih baik jika saya memiliki sesuatu seperti -

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

Ada ide, bagaimana mencapai sesuatu seperti di atas di bash?

Di dalamnya bashAnda dapat menggunakan ${!varname}untuk memperluas variabel yang dirujuk oleh konten yang lain. Misalnya:

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

Dari halaman manual:

${!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.

Juga, untuk mengatur variabel yang dirujuk oleh konten (tanpa bahaya eval), Anda dapat menggunakan declare. Misalnya:

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

Dengan demikian, Anda dapat menulis fungsi Anda seperti ini (hati-hati karena jika Anda menggunakan declaresuatu fungsi, Anda harus memberi -gatau variabelnya adalah lokal):

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
}

Dan gunakan seperti:

assign PATH /path/to/binaries

Perhatikan bahwa saya juga telah memperbaiki bug di mana jika substrsudah menjadi substring dari salah satu anggota yang dipisahkan oleh titik dua bigstr, tetapi bukan anggota sendiri, maka itu tidak akan ditambahkan. Misalnya, ini akan memungkinkan penambahan /binke PATHvariabel yang sudah mengandung /usr/bin. Ini menggunakan extglobset untuk mencocokkan awal / akhir string atau titik dua kemudian apa pun. Tanpa extglob, alternatifnya adalah:

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

Baru di bash 4.3, adalah -nopsi untuk declare& local:

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

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

Itu tercetak hello, world.

Anda dapat menggunakan evaluntuk mengatur parameter. Deskripsi perintah ini dapat ditemukan sini . Penggunaan berikut evalsalah:

salah(){
  eval $ 1 = $ 2
}

Sehubungan dengan evaluasi tambahan yang evalharus Anda gunakan

menetapkan(){
  eval $ 1 = '$ 2'
}

Periksa hasil menggunakan fungsi-fungsi ini:

$ X1 = '$ X2'
$ X2 = '$ X3'
$ X3 = 'xxx'
$ 
$ echo: $ X1:
: $ X2:
$ echo: $ X2:
: $ X3:
$ echo: $ X3:
: xxx:
$ 
$ salah Y $ X1
$ echo: $ Y:
: $ X3:
$ 
$ assign Y $ X1
$ echo: $ Y:
: $ X2:
$ 
$ assign Y "hallo world"
$ echo: $ Y:
: hallo world:
$ # berikut ini mungkin tidak terduga
$ assign Z $ Y
$ echo ": $ Z:"
: hallo:
$ # jadi Anda harus mengutip argumen kedua jika itu variabel
$ assign Z "$ Y"
$ echo ": $ Z:"
: hallo world:

Tetapi Anda dapat mencapai tujuan Anda tanpa menggunakan eval. Saya lebih suka cara ini yang lebih sederhana.

Fungsi berikut membuat penggantian dengan cara yang benar (saya harap)

menambah(){
  LANCAR lokal = $ 1
  AUGMENT lokal = $ 2
  lokal BARU
  if [[-z $ CURRENT]]; kemudian
    BARU = $ AUGMENT
  Elif [[! (($ CURRENT = $ AUGMENT) || ($ CURRENT = $ AUGMENT: *) || \
    ($ CURRENT = *: $ AUGMENT) || ($ CURRENT = *: $ AUGMENT: *))]]; kemudian
    BARU = $ LANCAR: $ AUGMENT
  lain
    BARU = $ LANCAR
    fi
  gema "$ BARU"
}

Periksa output berikut

augment / usr / bin / bin
/ usr / bin: / bin

augment / usr / bin: / bin / bin
/ usr / bin: / bin

augment / usr / bin: / bin: / usr / local / bin / bin
/ usr / bin: / bin: / usr / local / bin

augment / bin: / usr / bin / bin
/ bin: / usr / bin

augment / bin / bin
/tempat sampah


augment / usr / bin: / bin
/ usr / bin :: / bin

augment / usr / bin: / bin: / bin
/ usr / bin: / bin:

augment / usr / bin: / bin: / usr / local / bin: / bin
/ usr / bin: / bin: / usr / local / bin:

augment / bin: / usr / bin: / bin
/ bin: / usr / bin:

augment / bin: / bin
/tempat sampah:


augment: / bin
::/tempat sampah


menambah "/ usr lib" "/ usr bin"
/ usr lib: / usr bin

menambah "/ usr lib: / usr bin" "/ usr bin"
/ usr lib: / usr bin

Sekarang Anda dapat menggunakan augmentfungsi dengan cara berikut untuk mengatur variabel:

PATH = `augment PATH / bin`
CLASSPATH = `augment CLASSPATH / bin`
LD_LIBRARY_PATH = `menambah LD_LIBRARY_PATH / usr / lib`

Dengan beberapa trik Anda dapat benar-benar mengirimkan parameter bernama ke fungsi, bersama dengan array (diuji dalam bash 3 dan 4).

Metode yang saya kembangkan memungkinkan Anda untuk mengakses parameter yang dikirimkan ke fungsi seperti ini:

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"

Dengan kata lain, tidak hanya Anda dapat memanggil parameter Anda dengan nama mereka (yang merupakan inti yang lebih mudah dibaca), Anda sebenarnya dapat melewatkan array (dan referensi ke variabel - fitur ini hanya bekerja di bash 4.3)! Plus, variabel yang dipetakan semuanya dalam lingkup lokal, seperti $ 1 (dan lainnya).

Kode yang membuat pekerjaan ini cukup ringan dan bekerja baik di bash 3 dan bash 4 (ini adalah satu-satunya versi yang telah saya uji dengan). Jika Anda tertarik pada lebih banyak trik seperti ini yang membuat pengembangan dengan bash jauh lebih baik dan lebih mudah, Anda dapat melihat pada Bash Infinity Framework saya , kode di bawah ini dikembangkan untuk tujuan itu.

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=

Apakah ini cocok?

Argumen yang dinamai bukan bagaimana sintaks Bash dirancang. Bash dirancang untuk menjadi perbaikan berulang pada kulit Bourne. Karena itu perlu memastikan hal-hal tertentu bekerja antara dua cangkang sebanyak mungkin. Jadi itu tidak dimaksudkan untuk menjadi lebih mudah untuk skrip dengan keseluruhan, itu hanya dimaksudkan untuk menjadi lebih baik daripada Bourne sambil memastikan bahwa jika Anda mengambil skrip dari lingkungan Bourne ke bashsemudah mungkin. Itu tidak sepele karena banyak cangkang masih memperlakukan Bourne sebagai standar de facto. Karena orang menulis skrip mereka agar kompatibel dengan Bourne (untuk portabilitas ini) kebutuhan tetap berlaku dan tidak mungkin untuk pernah berubah.

Anda mungkin lebih baik melihat skrip shell yang berbeda (seperti pythonatau sesuatu) sepenuhnya jika itu layak. Jika Anda menghadapi keterbatasan bahasa, Anda harus mulai menggunakan bahasa baru.

Dengan shsintaks standar (akan berfungsi bash, dan tidak hanya di bash), Anda dapat melakukan:

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

Seperti untuk solusi menggunakan bash's declare, itu aman selama $1mengandung nama variabel yang valid.

TENTANG ARGS NAMED:

Ini sangat sederhana dilakukan dan bashtidak diperlukan sama sekali - ini adalah perilaku penugasan POSIX dasar yang ditentukan melalui ekspansi parameter:

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

Untuk melakukan demo dengan nada yang mirip dengan @Graeme, tetapi dengan cara yang portabel:

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

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

Dan di sana saya hanya melakukan str=untuk memastikan ia memiliki nilai nol, karena ekspansi parameter memiliki perlindungan bawaan terhadap penetapan ulang lingkungan shell inline jika sudah ditetapkan.

LARUTAN:

Untuk masalah spesifik Anda, saya tidak percaya bahwa argumen bernama diperlukan, meskipun tentu saja mungkin. Gunakan $IFSsebaliknya:

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
}

Inilah yang saya dapatkan ketika saya menjalankannya:

% 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

Perhatikan itu hanya menambahkan argumen yang belum ada $PATHatau yang datang sebelumnya? Atau bahkan butuh lebih dari satu argumen? $IFSberguna.

Saya tidak dapat menemukan apa pun seperti ruby, python, dll. Tetapi ini terasa lebih dekat dengan saya

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

Keterbacaan menurut saya lebih baik, 4 baris berlebihan untuk menyatakan nama parameter Anda. Terlihat lebih dekat dengan bahasa modern juga.