Obtendo o Último Argumento Passado para um Shell Script

$1é o primeiro argumento.
$@são todos eles.

Como posso encontrar o último argumento passado para um script de shell?

Isso é meio que um hack:

for last; do true; done
echo $last

Este também é bastante portátil (novamente, deve funcionar com bash, ksh e sh) e não muda os argumentos, o que poderia ser bom.

Ele usa o fato de forimplicitamente repetir os argumentos se você não informar o que fazer loop e o fato de que as variáveis ​​de loop não têm escopo definido: elas mantêm o último valor para o qual foram definidas.

Isso é apenas Bash:

echo "${@: -1}"

$ set quick brown fox jumps

$ echo ${*: -1:1} # last argument
jumps

$ echo ${*: -1} # or simply
jumps

$ echo ${*: -2:1} # next to last
fox

O espaço é necessário para que ele não seja interpretado como um valor padrão .

Observe que isso é apenas para o bash.

A resposta mais simples para o bash 3.0 ou superior é

_last=${!#}       # *indirect reference* to the $# variable
# or
_last=$BASH_ARGV  # official built-in (but takes more typing :)

É isso aí.

$ cat lastarg
#!/bin/bash
# echo the last arg given:
_last=${!#}
echo $_last
_last=$BASH_ARGV
echo $_last
for x; do
   echo $x
done

A saída é:

$ lastarg 1 2 3 4 "5 6 7"
5 6 7
5 6 7
1
2
3
4
5 6 7

Use a indexação combinada com o comprimento de:

echo ${@:${#@}} 

Observe que isso é apenas para o bash.

O seguinte funcionará para você. O @ é para matriz de argumentos. : significa às. $ # é o comprimento da matriz de argumentos. Portanto, o resultado é o último elemento:

${@:$#} 

Exemplo:

function afunction{
    echo ${@:$#} 
}
afunction -d -o local 50
#Outputs 50

Observe que isso é apenas para o bash.

Foi encontrado ao procurar separar o último argumento de todos os anteriores. Embora algumas das respostas recebam o último argumento, elas não ajudam muito se você precisar de todos os outros argumentos também. Isso funciona muito melhor:

heads=${@:1:$#-1}
tail=${@:$#}

Observe que isso é apenas para o bash.

Isso funciona em todos os shells compatíveis com POSIX:

eval last=\${$#}

Fonte: http://www.faqs.org/faqs/unix-faq/faq/part2/section-12.html

Aqui está a minha solução:

• bastante portátil (todos os POSIX sh, bash, ksh, zsh) devem funcionar
• não muda argumentos originais (muda uma cópia).
• não usa o mal eval
• não repete a lista inteira
• não usa ferramentas externas

Código:

ntharg() {
    shift $1
    printf '%s\n' "$1"
}
LAST_ARG=`ntharg $# "$@"`

Das soluções mais antigas às mais recentes:

A solução mais portátil, ainda mais antiga sh(funciona com espaços e caracteres glob) (sem loop, mais rápido):

eval printf "'%s\n'" "\"\${$#}\""

Desde a versão 2.01 do bash

$ set -- The quick brown fox jumps over the lazy dog

$ printf '%s\n'     "${!#}     ${@:(-1)} ${@: -1} ${@:~0} ${!#}"
dog     dog dog dog dog

Para ksh, zsh e bash:

$ printf '%s\n' "${@: -1}    ${@:~0}"     # the space beetwen `:`
                                          # and `-1` is a must.
dog   dog

E para "próximo ao último":

$ printf '%s\n' "${@:~1:1}"
lazy

Usando printf para solucionar problemas com argumentos que começam com um traço (como -n ).

Para todas as conchas e para as mais antigas sh(funciona com espaços e caracteres glob) é:

$ set -- The quick brown fox jumps over the lazy dog "the * last argument"

$ eval printf "'%s\n'" "\"\${$#}\""
The last * argument

Ou, se você deseja definir um lastvar:

$ eval last=\${$#}; printf '%s\n' "$last"
The last * argument

E para "próximo ao último":

$ eval printf "'%s\n'" "\"\${$(($#-1))}\""
dog

Se você estiver usando o Bash> = 3.0

echo ${BASH_ARGV[0]}

Pois bash, este comentário sugeriu o muito elegante:

echo "${@:$#}"

Como um bônus, isso também funciona zsh.

shift `expr $# - 1`
echo "$1"

Isso muda os argumentos pelo número de argumentos menos 1 e retorna o primeiro (e único) argumento restante, que será o último.

Eu testei apenas no bash, mas deve funcionar em sh e ksh também.

Se você deseja fazer isso de maneira não destrutiva, uma maneira é passar todos os argumentos para uma função e retornar o último:

#!/bin/bash

last() {
        if [[ $# -ne 0 ]] ; then
            shift $(expr $# - 1)
            echo "$1"
        #else
            #do something when no arguments
        fi
}

lastvar=$(last "$@")
echo $lastvar
echo "$@"

pax> ./qq.sh 1 2 3 a b
b
1 2 3 a b

Se você realmente não se importa em manter os outros argumentos, não precisa disso em uma função, mas é difícil pensar em uma situação em que você nunca iria querer manter os outros argumentos, a menos que eles já tenham sido processados, nesse caso, eu usaria o método process / shift / process / shift / ... para processá-los sequencialmente.

Estou assumindo aqui que você deseja mantê-los porque não seguiu o método seqüencial. Este método também lida com o caso em que não há argumentos, retornando "". Você pode ajustar esse comportamento facilmente inserindo a elsecláusula comentada .

Para tcsh:

set X = `echo $* | awk -F " " '{print $NF}'`
somecommand "$X"

Tenho certeza de que essa seria uma solução portátil, exceto pela atribuição.

Achei a resposta do @ AgileZebra (mais o comentário do @ starfry) a mais útil, mas ela é headsescalar. Uma matriz é provavelmente mais útil:

heads=( "${@:1:$(($# - 1))}" )
tail=${@:${#@}}

Observe que isso é apenas para o bash.

Uma solução usando eval:

last=$(eval "echo \$$#")

echo $last

Depois de ler as respostas acima, escrevi um shell script de Q&D (deve funcionar com sh e bash) para executar o g ++ no PGM.cpp para produzir a imagem executável PGM. Ele pressupõe que o último argumento na linha de comando seja o nome do arquivo (.cpp é opcional) e todos os outros argumentos são opções.

#!/bin/sh
if [ $# -lt 1 ]
then
    echo "Usage: `basename $0` [opt] pgm runs g++ to compile pgm[.cpp] into pgm"
    exit 2
fi
OPT=
PGM=
# PGM is the last argument, all others are considered options
for F; do OPT="$OPT $PGM"; PGM=$F; done
DIR=`dirname $PGM`
PGM=`basename $PGM .cpp`
# put -o first so it can be overridden by -o specified in OPT
set -x
g++ -o $DIR/$PGM $OPT $DIR/$PGM.cpp

O seguinte será definido LASTpara o último argumento sem alterar o ambiente atual:

LAST=$({
   shift $(($#-1))
   echo $1
})
echo $LAST

Se outros argumentos não forem mais necessários e puderem ser alterados, poderá ser simplificado para:

shift $(($#-1))
echo $1

Por motivos de portabilidade, a seguir:

shift $(($#-1));

pode ser substituído por:

shift `expr $# - 1`

Substituindo também $()por aspas, obtemos:

LAST=`{
   shift \`expr $# - 1\`
   echo $1
}`
echo $LAST

echo $argv[$#argv]

Agora só preciso adicionar um texto, porque minha resposta foi muito curta para postar. Preciso adicionar mais texto para editar.

Isso faz parte da minha função de cópia:

eval echo $(echo '$'"$#")

Para usar em scripts, faça o seguinte:

a=$(eval echo $(echo '$'"$#"))

Explicação (a maioria aninhada primeiro):

1. $(echo '$'"$#")retorna $[nr]onde [nr]é o número de parâmetros. Por exemplo, a string $123(não expandida).
2. echo $123 retorna o valor do 123º parâmetro, quando avaliado.
3. evalapenas expande $123para o valor do parâmetro, por exemplo last_arg. Isso é interpretado como uma sequência e retornado.

Funciona com o Bash em meados de 2015.

#! /bin/sh

next=$1
while [ -n "${next}" ] ; do
  last=$next
  shift
  next=$1
done

echo $last

Experimente o script abaixo para encontrar o último argumento

 # cat arguments.sh
 #!/bin/bash
 if [ $# -eq 0 ]
 then
 echo "No Arguments supplied"
 else
 echo $* > .ags
 sed -e 's/ /\n/g' .ags | tac | head -n1 > .ga
 echo "Last Argument is: `cat .ga`"
 fi

Resultado:

 # ./arguments.sh
 No Arguments supplied

 # ./arguments.sh testing for the last argument value
 Last Argument is: value

Obrigado.

Existe uma maneira muito mais concisa de fazer isso. Argumentos para um script bash podem ser trazidos para uma matriz, o que torna muito mais fácil lidar com os elementos. O script abaixo sempre imprimirá o último argumento passado para um script.

  argArray=( "$@" )                        # Add all script arguments to argArray
  arrayLength=${#argArray[@]}              # Get the length of the array
  lastArg=$((arrayLength - 1))             # Arrays are zero based, so last arg is -1
  echo ${argArray[$lastArg]}

Saída de amostra

$ ./lastarg.sh 1 2 buckle my shoe
shoe

Usando expansão de parâmetro (excluir início correspondente):

args="$@"
last=${args##* }

Também é fácil obter tudo antes do último:

prelast=${args% *}

Para retornar o último argumento do comando usado mais recentemente, use o parâmetro especial:

$_

Nesse caso, ele funcionará se for usado dentro do script antes que outro comando seja chamado.

Apenas use !$.

$ mkdir folder
$ cd !$ # will run: cd folder