Ottenere l'ultimo argomento passato a uno script di shell

$1è il primo argomento.
$@sono tutti loro.

Come posso trovare l'ultimo argomento passato a uno script di shell?

Questo è un po 'un trucco:

for last; do true; done
echo $last

Anche questo è abbastanza portatile (di nuovo, dovrebbe funzionare con bash, ksh e sh) e non sposta gli argomenti, il che potrebbe essere carino.

Usa il fatto che forricopre implicitamente gli argomenti se non gli dici cosa ricorrere al loop e il fatto che per le variabili del loop non sono comprese: mantengono l'ultimo valore su cui sono state impostate.

Questo è 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

Lo spazio è necessario in modo che non venga interpretato come valore predefinito .

Nota che questo è solo bash.

La risposta più semplice per bash 3.0 o successive è

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

Questo è tutto.

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

L'output è:

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

Usa l'indicizzazione combinata con la lunghezza di:

echo ${@:${#@}} 

Nota che questo è solo bash.

Quanto segue funzionerà per te. @ È per una serie di argomenti. : significa a. $ # è la lunghezza dell'array di argomenti. Quindi il risultato è l'ultimo elemento:

${@:$#} 

Esempio:

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

Nota che questo è solo bash.

Trovato questo quando si cerca di separare l'ultimo argomento da tutti i precedenti. Mentre alcune delle risposte ottengono l'ultimo argomento, non sono di grande aiuto se hai bisogno anche di tutti gli altri argomenti. Funziona molto meglio:

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

Nota che questo è solo bash.

Funziona con tutte le shell compatibili con POSIX:

eval last=\${$#}

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

Ecco la mia soluzione:

• abbastanza portatile (tutti i POSIX sh, bash, ksh, zsh) dovrebbero funzionare
• non sposta gli argomenti originali (sposta una copia).
• non usa il male eval
• non scorre l'intera lista
• non utilizza strumenti esterni

Codice:

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

Dalle soluzioni più vecchie a quelle più recenti:

La soluzione più portatile, anche più vecchia sh(funziona con spazi e caratteri glob) (no loop, più veloce):

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

Dalla versione 2.01 di bash

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

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

Per ksh, zsh e bash:

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

E per "prossimo all'ultimo":

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

Uso di printf per risolvere eventuali problemi con argomenti che iniziano con un trattino (come -n).

Per tutte le shell e per le versioni precedenti sh(funziona con spazi e caratteri glob) è:

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

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

Oppure, se si desidera impostare un lastvar:

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

E per "prossimo all'ultimo":

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

Se stai usando Bash> = 3.0

echo ${BASH_ARGV[0]}

Per bash, questo commento ha suggerito il molto elegante:

echo "${@:$#}"

Come bonus, anche questo funziona zsh.

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

Ciò sposta gli argomenti in base al numero di argomenti meno 1 e restituisce il primo (e unico) argomento rimanente, che sarà l'ultimo.

Ho provato solo in bash, ma dovrebbe funzionare anche in sh e ksh.

Se vuoi farlo in modo non distruttivo, un modo è passare tutti gli argomenti a una funzione e restituire l'ultimo:

#!/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 in realtà non ti interessa mantenere gli altri argomenti, non ne hai bisogno in una funzione, ma faccio fatica a pensare a una situazione in cui non vorrai mai mantenere gli altri argomenti a meno che non siano già stati elaborati, nel qual caso utilizzerei il metodo process / shift / process / shift / ... per elaborarli in sequenza.

Presumo che tu voglia mantenerli perché non hai seguito il metodo sequenziale. Questo metodo gestisce anche il caso in cui non ci siano argomenti, restituendo "". È possibile regolare facilmente tale comportamento inserendo la elseclausola commentata .

Per tcsh:

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

Sono abbastanza sicuro che questa sarebbe una soluzione portatile, ad eccezione del compito.

Ho trovato la risposta di @ AgileZebra (più il commento di @ starfry) la più utile, ma è impostata headssu uno scalare. Un array è probabilmente più utile:

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

Nota che questo è solo bash.

Una soluzione che utilizza eval:

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

echo $last

Dopo aver letto le risposte sopra ho scritto uno script di shell Q&D (dovrebbe funzionare su sh e bash) per eseguire g ++ su PGM.cpp per produrre un'immagine eseguibile PGM. Presuppone che l'ultimo argomento sulla riga di comando sia il nome del file (.cpp è facoltativo) e tutti gli altri argomenti sono opzioni.

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

Quanto segue imposterà LASTl'ultimo argomento senza modificare l'ambiente corrente:

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

Se altri argomenti non sono più necessari e possono essere spostati, è possibile semplificarli per:

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

Per motivi di portabilità seguenti:

shift $(($#-1));

può essere sostituito con:

shift `expr $# - 1`

Sostituendo anche $()con i backquotes otteniamo:

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

echo $argv[$#argv]

Ora ho solo bisogno di aggiungere del testo perché la mia risposta era troppo breve per pubblicare. Devo aggiungere più testo per modificarlo.

Questo fa parte della mia funzione di copia:

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

Per utilizzare negli script, procedere come segue:

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

Spiegazione (prima la maggior parte nidificata):

1. $(echo '$'"$#")ritorna $[nr]dove [nr]è il numero di parametri. Ad esempio la stringa $123(non espansa).
2. echo $123 restituisce il valore del 123 ° parametro, quando valutato.
3. evalsi espande semplicemente $123al valore del parametro, ad es last_arg. Questo viene interpretato come una stringa e restituito.

Funziona con Bash dalla metà del 2015.

#! /bin/sh

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

echo $last

Prova lo script seguente per trovare l'ultimo argomento

 # 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

Produzione:

 # ./arguments.sh
 No Arguments supplied

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

Grazie.

C'è un modo molto più conciso per farlo. Gli argomenti di uno script bash possono essere portati in un array, il che rende molto più semplice gestire gli elementi. Lo script seguente stamperà sempre l'ultimo argomento passato a uno 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]}

Uscita campione

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

Utilizzando l'espansione dei parametri (elimina l'inizio corrispondente):

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

È anche facile ottenere tutto prima dell'ultimo:

prelast=${args% *}

Per restituire l'ultimo argomento del comando utilizzato più di recente, utilizzare il parametro speciale:

$_

In questo caso funzionerà se viene utilizzato all'interno dello script prima che sia stato invocato un altro comando.

Basta usare !$.

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