Obtener el último argumento pasado a un script de shell

$1Es el primer argumento.
$@es todos ellos

¿Cómo puedo encontrar el último argumento pasado a un script de shell?

Esto es un poco hack:

for last; do true; done
echo $last

Este también es bastante portátil (nuevamente, debería funcionar con bash, ksh y sh) y no cambia los argumentos, lo que podría ser bueno.

Utiliza el hecho de que forimplícitamente recorre los argumentos si no le dice qué hacer, y el hecho de que las variables de bucle no tienen un alcance: mantienen el último valor en el que se establecieron.

Esto es solo 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

El espacio es necesario para que no se interprete como un valor predeterminado .

Tenga en cuenta que esto es solo bash.

La respuesta más simple para bash 3.0 o superior es

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

Eso es.

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

Salida es:

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

Utilice la indexación combinada con la longitud de:

echo ${@:${#@}} 

Tenga en cuenta que esto es solo bash.

Lo siguiente funcionará para usted. La @ es para una variedad de argumentos. : significa en. $ # es la longitud de la matriz de argumentos. Entonces el resultado es el último elemento:

${@:$#} 

Ejemplo:

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

Tenga en cuenta que esto es solo bash.

Encontré esto cuando buscaba separar el último argumento de todos los anteriores. Si bien algunas de las respuestas obtienen el último argumento, no son de mucha ayuda si necesita todos los otros argumentos también. Esto funciona mucho mejor:

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

Tenga en cuenta que esto es solo bash.

Esto funciona en todos los shells compatibles con POSIX:

eval last=\${$#}

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

Aquí está la solución mía:

• bastante portátil (todos los POSIX sh, bash, ksh, zsh) deberían funcionar
• no cambia los argumentos originales (cambia una copia).
• no usa el mal eval
• no recorre toda la lista
• no usa herramientas externas

Código:

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

De las soluciones más antiguas a las más nuevas:

La solución más portátil, incluso más antigua sh(funciona con espacios y caracteres globales) (sin bucle, más rápido):

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

Desde la versión 2.01 de 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 y bash:

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

Y para "penúltimo":

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

Usar printf para solucionar cualquier problema con argumentos que comienzan con un guión (como -n ).

Para todos los shells y para mayores sh(funciona con espacios y caracteres glob) es:

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

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

O, si desea establecer una lastvar:

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

Y para "penúltimo":

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

Si está utilizando Bash> = 3.0

echo ${BASH_ARGV[0]}

Para bash, este comentario sugirió lo muy elegante:

echo "${@:$#}"

Como beneficio adicional, esto también funciona en zsh.

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

Esto cambia los argumentos por el número de argumentos menos 1, y devuelve el primer (y único) argumento restante, que será el último.

Solo probé en bash, pero también debería funcionar en sh y ksh.

Si desea hacerlo de una manera no destructiva, una forma es pasar todos los argumentos a una función y devolver el ú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

Si realmente no te importa mantener los otros argumentos, no lo necesitas en una función, pero me cuesta pensar en una situación en la que nunca quieras conservar los otros argumentos a menos que ya hayan sido procesados, en cuyo caso usaría el método process / shift / process / shift / ... para procesarlos secuencialmente.

Asumo aquí que desea conservarlos porque no ha seguido el método secuencial. Este método también maneja el caso donde no hay argumentos, devolviendo "". Puede ajustar fácilmente ese comportamiento insertando la elsecláusula comentada .

Para tcsh:

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

Estoy bastante seguro de que esta sería una solución portátil, a excepción de la asignación.

Encontré la respuesta de @ AgileZebra (más el comentario de @ starfry) la más útil, pero se establece headsen un escalar. Una matriz es probablemente más útil:

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

Tenga en cuenta que esto es solo bash.

Una solución usando eval:

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

echo $last

Después de leer las respuestas anteriores, escribí un script de shell Q&D (debería funcionar en sh y bash) para ejecutar g ++ en PGM.cpp para producir una imagen ejecutable PGM. Se supone que el último argumento en la línea de comando es el nombre del archivo (.cpp es opcional) y todos los demás argumentos son opciones.

#!/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

Lo siguiente establecerá el LASTúltimo argumento sin cambiar el entorno actual:

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

Si ya no se necesitan otros argumentos y se pueden cambiar, se puede simplificar a:

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

Por razones de portabilidad siguientes:

shift $(($#-1));

se puede reemplazar con:

shift `expr $# - 1`

Reemplazando también $()con backquotes obtenemos:

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

echo $argv[$#argv]

Ahora solo necesito agregar algo de texto porque mi respuesta fue demasiado corta para publicar. Necesito agregar más texto para editar.

Esto es parte de mi función de copia:

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

Para usar en scripts, haga esto:

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

Explicación (la mayoría anidada primero):

1. $(echo '$'"$#")vuelve $[nr]donde[nr] está el número de parámetros. Por ejemplo, la cadena $123(sin expandir).
2. echo $123 devuelve el valor del parámetro 123, cuando se evalúa.
3. evalsimplemente se expande $123al valor del parámetro, p. ej.last_arg . Esto se interpreta como una cadena y se devuelve.

Trabaja con Bash a partir de mediados de 2015.

#! /bin/sh

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

echo $last

Pruebe el siguiente script para encontrar el ú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

Salida:

 # ./arguments.sh
 No Arguments supplied

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

Gracias.

Hay una manera mucho más concisa de hacer esto. Los argumentos de una secuencia de comandos bash se pueden incorporar a una matriz, lo que simplifica mucho el manejo de los elementos. El siguiente script siempre imprimirá el último argumento pasado a un 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]}

Salida de muestra

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

Usando la expansión de parámetros (eliminar el comienzo coincidente):

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

También es fácil obtener todo antes del último:

prelast=${args% *}

Para devolver el último argumento del comando utilizado más recientemente, use el parámetro especial:

$_

En este caso, funcionará si se usa dentro del script antes de que se haya invocado otro comando.

Solo úsalo !$.

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