Indexando e modificando o array de parâmetros Bash $ @

Question

É possível fazer referência a índices em $@ ? Não consigo encontrar nenhuma referência para usar como o seguinte em qualquer lugar em wiki do GrayCat , e o Guia avançada de scripts e outros atribuem isto a uma variável diferente antes de modificar isso em seu lugar.

$ echo ${@[0]}
-bash: ${@[0]}: bad substitution

O objetivo é DRY : o primeiro argumento é usado para uma coisa e o restante para outra coisa, e gostaria de evitar a duplicação do código para normalizar, a matriz $@ , ou criar uma função separada para isso (embora neste momento seja provavelmente a saída mais fácil).

Esclarecimento: o objetivo era modificar os valores de comprimento-variável $@ para tornar o código mais fácil de depurar. A versão atual é um pouco hacky para o meu gosto, embora funcione mesmo para caminhos bizarros como

$'--$'\! *@ \a\b\e\E\f\r\t\v\\"\' \n'

Atualização : parece que isso não é possível. O código agora usa duplicação de código e dados, mas pelo menos funciona:

path_common()
{
    # Get the deepest common path.
    local common_path="$(echo -n "${1:-}x" | tr -s '/')"
    common_path="${common_path%x}"
    shift # $1 is obviously part of $1
    local path

    while [ -n "${1+defined}" ]
    do
        path="$(echo -n "${1}x" | tr -s '/')"
        path="${path%x}"
        if [[ "${path%/}/" = "${common_path%/}/"* ]]
        then
            shift
        else
            new_common_path="${common_path%/*}"
            [ "$new_common_path" = "$common_path" ] && return 1 # Dead end
            common_path="$new_common_path"
        fi
    done
    printf %s "$common_path"
}

A recompensa vai para qualquer um que possa se livrar da duplicação de código para reduzir as barras duplicadas ou a duplicação de dados para conter $1 e os outros parâmetros, ou ambos , mantendo o código em um tamanho razoável e obtendo sucesso em todos os testes de unidade:

test "$(path_common /a/b/c/d /a/b/e/f; echo x)" = /a/bx
test "$(path_common /long/names/foo /long/names/bar; echo x)" = /long/namesx
test "$(path_common / /a/b/c; echo x)" = /x
test "$(path_common a/b/c/d a/b/e/f ; echo x)" = a/bx
test "$(path_common ./a/b/c/d ./a/b/e/f; echo x)" = ./a/bx
test "$(path_common $'\n/\n/\n' $'\n/\n'; echo x)" = $'\n/\n'x
test "$(path_common --/-- --; echo x)" = '--x'
test "$(path_common '' ''; echo x)" = x
test "$(path_common /foo/bar ''; echo x)" = x
test "$(path_common /foo /fo; echo x)" = x
test "$(path_common $'--$'\! *@ \a\b\e\E\f\r\t\v\\"\' \n' $'--$'\! *@ \a\b\e\E\f\r\t\v\\"\' \n'; echo x)" = $'--$'\! *@ \a\b\e\E\f\r\t\v\\"\' \n'x
test "$(path_common /foo/bar //foo//bar//baz; echo x)" = /foo/barx
test "$(path_common foo foo; echo x)" = foox
test "$(path_common /fo /foo; echo x)" = x

    

Answer 1

POSIX

Para normalizar as barras em todos os parâmetros, usarei o truque do argumento rotativo: shift $1 off, transforme-o e coloque o resultado no final da lista de parâmetros. Se você fizer isso quantas vezes houver parâmetros, você transformou todos os parâmetros e os colocou de volta em ordem.

Para a segunda parte do código, alterei sua lógica para ser menos confusa: o loop externo itera sobre os parâmetros e o loop interno itera sobre os componentes do caminho. for x; do … done itera sobre os parâmetros posicionais, é um idioma conveniente. Eu uso uma maneira compatível com POSIX de combinar uma string com um padrão: o case construct.

Testado com o traço 0.5.5.1, pdksh 5.2.14, bash 3.2.39, bash 4.1.5, ksh 93s +, zsh 4.3.10.

^{Nota: parece haver um bug no bash 4.1.5 (não no 3.2): se o padrão do caso for "${common_path%/}"/* , um dos testes falhará.}

posix_path_common () {
  for tmp; do
    tmp=$(printf %s. "$1" | tr -s "/")
    set -- "$@" "${tmp%.}"
    shift
  done
  common_path=$1; shift
  for tmp; do
    while case ${tmp%/}/ in "${common_path%/}/"*) false;; esac; do
      new_common_path=${common_path%/*}
      if [ "$new_common_path" = "$common_path" ]; then return 1; fi
      common_path=$new_common_path
    done
  done
  printf %s "$common_path"
}

bash, ksh

Se você está em bash (ou ksh), você pode usar arrays - não entendo por que você parece se restringir aos parâmetros posicionais. Aqui está uma versão que usa uma matriz. Eu tenho que admitir que não é particularmente mais claro que a versão POSIX, mas evita o embaralhamento n ^ 2 inicial.

Para a parte de normalização de barra, eu uso a construção ksh93 ${foo//PATTERN/REPLACEMENT} construct para substituir todas as ocorrências de PATTERN em $foo por REPLACEMENT . O padrão é +(\/) para corresponder a uma ou mais barras; sob bash, shopt -s extglob deve estar em vigor (equivalentemente, inicie o bash com bash -O extglob ). A construção set ${!a[@]} configura os parâmetros posicionais para a lista de subíndices da matriz a . Isso fornece uma maneira conveniente de iterar os elementos da matriz.

Para a segunda parte, eu tenho a mesma lógica de loop que a versão POSIX. Dessa vez, posso usar [[ … ]] , já que todos os shells aqui direcionados suportam isso.

Testado com o bash 3.2.39, bash 4.1.5, ksh 93s +.

array_path_common () {
  typeset a i tmp common_path new_common_path
  a=("$@")
  set ${!a[@]}
  for i; do
    a[$i]=${a[$i]//+(\/)//}
  done
  common_path=${a[$1]}; shift
  for tmp; do
    tmp=${a[$tmp]}
    while [[ "${tmp%/}/" != "${common_path%/}/"* ]]; do
      new_common_path="${common_path%/*}"
      if [[ $new_common_path = $common_path ]]; then return 1; fi
      common_path="$new_common_path"
    done
  done
  printf %s "$common_path"
}

zsh

Infelizmente, zsh não possui o recurso ${!array[@]} para executar a versão do ksh93 como está. Felizmente, o zsh tem dois recursos que facilitam a primeira parte. Você pode indexar os parâmetros posicionais como se fossem a matriz @ , portanto não há necessidade de usar uma matriz intermediária. E o zsh tem uma construção da iteração de matriz : "${(@)array//PATTERN/REPLACEMENT}" realiza a substituição do padrão em cada elemento da matriz, por sua vez, avalia a matriz de resultados (confusamente, você precisa das aspas duplas mesmo que o resultado seja várias palavras; isso é uma generalização de "$@" ). A segunda parte é essencialmente inalterada.

zsh_path_common () {
  setopt local_options extended_glob
  local tmp common_path new_common_path
  set -- "${(@)@//\/##//}"
  common_path=$1; shift
  for tmp; do
    while [[ "${tmp%/}/" != "${common_path%/}/"* ]]; do
      new_common_path="${common_path%/*}"
      if [[ $new_common_path = $common_path ]]; then return 1; fi
      common_path="$new_common_path"
    done
  done
  printf %s "$common_path"
}

Casos de teste

Minhas soluções são minimamente testadas e comentadas. Eu mudei a sintaxe de seus casos de teste para analisar em shells que não têm $'…' e relatar falhas de uma forma mais conveniente.

do_test () {
  if test "$@"; then echo 0; else echo $? "$@"; failed=$(($failed+1)); fi
}

run_tests () {
  function_to_test=$1; shift
  failed=0
  do_test "$($function_to_test /a/b/c/d /a/b/e/f; echo x)" = /a/bx
  do_test "$($function_to_test /long/names/foo /long/names/bar; echo x)" = /long/namesx
  do_test "$($function_to_test / /a/b/c; echo x)" = /x
  do_test "$($function_to_test a/b/c/d a/b/e/f ; echo x)" = a/bx
  do_test "$($function_to_test ./a/b/c/d ./a/b/e/f; echo x)" = ./a/bx
  do_test "$($function_to_test '
/
/
' '
/
'; echo x)" = '
/
'x
  do_test "$($function_to_test --/-- --; echo x)" = '--x'
  do_test "$($function_to_test '' ''; echo x)" = x
  do_test "$($function_to_test /foo/bar ''; echo x)" = x
  do_test "$($function_to_test /foo /fo; echo x)" = x
  do_test "$($function_to_test '--$'\! *@ \a\b\e\E\f\r\t\v\\"'\'' 
' '--$'\! *@ \a\b\e\E\f\r\t\v\\"'\'' 
'; echo x)" = '--$'\! *@ \a\b\e\E\f\r\t\v\\"'\'' 
'x
  do_test "$($function_to_test /foo/bar //foo//bar//baz; echo x)" = /foo/barx
  do_test "$($function_to_test foo foo; echo x)" = foox
  do_test "$($function_to_test /fo /foo; echo x)" = x
  if [ $failed -ne 0 ]; then echo $failed failures; return 1; fi
}

    

Answer 2

Por que você não usa apenas $ 1, $ 2 ... $ 9, $ {10}, $ {11} e assim por diante? É ainda mais DRY - do que você está tentando fazer:)

Mais sobre a relação entre $ number e $ @:

$ @ pode ser considerado como abreviação para "todos os elementos de uma matriz contendo todos os argumentos"

Então, $ @ é uma espécie de abreviação de $ {args [@]} (args aqui é um array 'virtual' contendo todos os argumentos - não uma variável real, lembre-se)

$ 1 é $ {args [1]}, $ 2 é $ {args [2]} e assim por diante.

Quando você acertar [9], use uma chave: $ {10} é $ {args [10]}, $ {11} é $ {args [11]} e assim por diante.

Use indiretamente um argumento de linha de comando

argnum=3  # You want to get the 3rd arg
do-something ${!argnum}  # Do something with the 3rd arg

Exemplo:

argc=$#
for (( argn=1; argn<=argc; argn++)); do
    if [[ ${!argn} == "foo" ]]; then
        echo "Argument $argn of $argc is 'foo'"
    fi
done

    

Answer 3

The first argument is used for one thing, and the rest for something else,

Acho que o que você quer é shift

$ set one two three four five
$ echo $@
one two three four five
$ echo $1
one
$ foo=$1
$ echo $foo
one
$ shift
$ echo $@
two three four five
$ shift 2
$ echo $@
four five
$ echo $1
four

    

Answer 4

Eu não sei bem porque você não usa apenas $ 1 $ 2, etc. mas .. Isso pode atender às suas necessidades.

$ script "ed    it" "cat/dog"  33.2  \D  

  echo "-------- Either use 'indirect reference'"
  for ((i=1;i<=${#@};i++)) ;do
    #  eval echo \"\$$i\" ..works, but as *pepoluan* 
    #    has pointed out: echo "${!i}" ..is better.
    echo "${!i}"
  done
  echo "-------- OR use an array"
  array=("$@")
  for ((i=0;i<${#array[@]};i++)) ;do
    echo "${array[$i]}" 
  done
  echo "-------- OR use 'set'"
  set  "$@"
  echo "$1"
  echo "$2"
  echo "$3"
  echo "$4"

saída

  -------- Either use 'indirect reference'
  ed    it
  cat/dog
  33.2
  D
  -------- OR use an array
  ed    it
  cat/dog
  33.2
  D
  -------- OR use 'set'
  ed    it
  cat/dog
  33.2
  D

set funciona de qualquer coisa que se segue, para criar $ 1, $ 2 .. etc. Isto naturalmente anulará os valores originais, então esteja ciente disso.

    

Answer 5

Então aqui está a minha resposta. Nota Eu suporto espaços em nomes de arquivos.

function SplitFilePath {
    IFS=$'/' eval "${1}"=\( \ \)
}
function JoinFilePath {
    IFS=$'/' eval echo -n \"\${*}\"
    [ $# -eq 1 -a "${1}" = "" ] && echo -n "/"
}
function path_common {
    set -- "${@//\/\///}"       ## Replace all '//' with '/'
    local -a Path1
    local -i Cnt=0
    SplitFilePath Path1 "${1}"
    IFS=$'/' eval set -- \ 
    for CName in "${Path1[@]}" ; do
        [ "${CName}" != "${1}" ] && break;
        shift && (( Cnt++ ))
    done
    JoinFilePath "${Path1[@]:0:${Cnt}}"
}

Eu adicionei um caso de teste para nomes de arquivos com espaços e fixei 2 testes que estavam faltando a um /

    do_test () {

  if test "${@}"; then echo 0; else echo $? "$@"; failed=$(($failed+1)); fi
}

run_tests () {
  function_to_test=$1; shift
  failed=0
  do_test "$($function_to_test /a/b/c/d /a/b/e/f; echo x)" = /a/bx
  do_test "$($function_to_test /long/names/foo /long/names/bar; echo x)" = /long/namesx
  do_test "$($function_to_test / /a/b/c; echo x)" = /x      
  do_test "$($function_to_test a/b/c/d a/b/e/f ; echo x)" = a/bx
  do_test "$($function_to_test ./a/b/c/d ./a/b/e/f; echo x)" = ./a/bx
  do_test "$($function_to_test '
/
/
' '
/
'; echo x)" = '
/
'x
  do_test "$($function_to_test --/-- --; echo x)" = '--x'
  do_test "$($function_to_test '' ''; echo x)" = x
  do_test "$($function_to_test /foo/bar ''; echo x)" = x
  do_test "$($function_to_test /foo /fo; echo x)" = /x      ## Changed from x
  do_test "$($function_to_test '--$'\! *@ \a\b\e\E\f\r\t\v\\"'\'' 
' '--$'\! *@ \a\b\e\E\f\r\t\v\\"'\'' 
'; echo x)" = '--$'\! *@ \a\b\e\E\f\r\t\v\\"'\'' 
'x
  do_test "$($function_to_test /foo/bar //foo//bar//baz; echo x)" = /foo/barx
  do_test "$($function_to_test foo foo; echo x)" = foox
  do_test "$($function_to_test /fo /foo; echo x)" = /x          ## Changed from x
  do_test "$($function_to_test "/fo d/fo" "/fo d/foo"; echo x)" = "/fo dx"

  if [ $failed -ne 0 ]; then echo $failed failures; return 1; fi
}

Espero que ajude