Das letzte Argument an ein Shell-Skript übergeben

$1 ist das erste argument.

$@ ist alle.

Wie finde ich die letzten argument übergeben Sie eine shell
Skript?

InformationsquelleAutor der Frage Thomas | 2009-12-05

143

Dies ist ein bisschen ein hack:
```
for last; do true; done
echo $last
```
Dieser ist auch ziemlich portable (wieder, sollten die arbeiten mit der bash, ksh und sh) und es verrutscht nicht, die Argumente, die könnten nett sein.

Es nutzt die Tatsache, dass for implizit Schleifen über die Argumente, wenn Sie nicht sagen, was zu Durchlaufen, und die Tatsache, dass die for-Schleife Variablen nicht scoped: Sie halten den letzten Wert, den Sie eingestellt waren.

InformationsquelleAutor der Antwort Laurence Gonsalves
240

Dies ist Bash-nur:
```
echo "${@: -1}"
```
InformationsquelleAutor der Antwort Dennis Williamson

Die einfachste Antwort für die bash 3.0 oder höher ist

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

Das ist es.

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

Ausgabe:

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

InformationsquelleAutor der Antwort Kevin Little

$ set quick brown fox jumps

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

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

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

Den Raum ist notwendig, damit es nicht interpretiert als Standardwert.

InformationsquelleAutor der Antwort Steven Penny

26

Indizierung nutzen, kombiniert mit Länge:
```
echo ${@:${#@}} 
```
InformationsquelleAutor der Antwort Mark Byers
20

Werden die folgenden arbeiten für Sie. Die @ für array von Argumenten. bedeutet : bei. $# ist die Länge des array von Argumenten. So das Ergebnis ist das Letzte element:
```
${@:$#} 
```
Beispiel:
```
function afunction{
    echo ${@:$#} 
}
afunction -d -o local 50
#Outputs 50
```
InformationsquelleAutor der Antwort Tahsin Turkoz
19

Fand diese bei der Suche zu trennen, das Letzte argument von allen vorherigen(s).
Während einige Antworten bekommen, das Letzte argument, Sie sind nicht viel helfen, wenn Sie benötigen, alle anderen Argumente als gut. Das funktioniert viel besser:
```
heads=${@:1:$(($# - 1))}
tail=${@:$#}
```
InformationsquelleAutor der Antwort AgileZebra
16

Dies funktioniert in allen POSIX-kompatiblen shells:
```
eval last=\${$#}
```
Quelle: http://www.faqs.org/faqs/unix-faq/faq/part2/section-12.html

InformationsquelleAutor der Antwort poiuz
7

Wenn Sie mit Bash >= 3.0
```
echo ${BASH_ARGV[0]}
```
InformationsquelleAutor der Antwort dusan
7

Hier ist meine Lösung:
- ziemlich portable (alle POSIX-sh, bash, ksh, zsh) sollte
- nicht verschieben ursprünglichen Argumente (verschiebt eine Kopie).
- nicht mit ~~böse~~ eval
- nicht Durchlaufen durch die ganze Liste
- nicht mit externen Werkzeugen
Code:
```
ntharg() {
    shift $1
    printf '%s\n' "$1"
}
LAST_ARG=`ntharg $# "$@"`
```
InformationsquelleAutor der Antwort Michał Šrajer
2
```
shift `expr $# - 1`
echo "$1"
```
Dadurch verschiebt sich die Argumente durch die Anzahl der Argumente, minus 1, und gibt die erste (und einzige Verbleibende argument, das der Letzte sein wird.

Ich nur in der bash getestet, es sollte aber in sh und ksh auch.

InformationsquelleAutor der Antwort Laurence Gonsalves
2

Wenn Sie wollen, es zu tun in einem nicht-destruktiven Weg, ein Weg, um alle übergeben der Argumente an eine Funktion und Rückkehr der Letzte:
```
#!/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
```
Wenn Sie nicht wirklich Pflege über die Haltung der anderen Argumente, die Sie nicht brauchen, es in eine Funktion, aber ich habe eine harte Zeit, die denken, eine situation, wo Sie würde niemals wollen, halten die anderen Argumente, es sei denn, Sie haben bereits verarbeitet worden sind, in dem Fall würde ich die Verwendung der Prozess - /shift - /Prozess - /shift - /... - Methode des sequentiellen Verarbeitung.

Gehe ich davon aus, dass Sie hier wollen, Sie zu halten, weil Sie noch nicht folgte die sequenzielle Methode. Diese Methode behandelt auch den Fall, wo es keine Argumente, die Rückgabe "". Du könntest einfach einstellen, dass Verhalten durch einfügen der auskommentierte else - Klausel.

InformationsquelleAutor der Antwort paxdiablo
2

Für tcsh:
```
set X = `echo $* | awk -F " " '{print $NF}'`
somecommand "$X"
```
Ich bin mir ziemlich sicher, das wäre eine tragbare Lösung, außer für die Zuordnung.

InformationsquelleAutor der Antwort Perfect64
1

Einer Lösung mit eval:
```
last=$(eval "echo \$$#")

echo $last
```
InformationsquelleAutor der Antwort Mikael S

Nach der Lektüre der Antworten oben schrieb ich eine Q&D-shell-Skript (sollte auf sh und bash) ausführen, g++ auf PGM.cpp produzieren ausführbaren Bild PGM. Es wird davon ausgegangen, dass das Letzte argument auf der Kommandozeile ist der name der Datei (.cpp ist optional) und alle anderen Argumente sind Optionen.

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

InformationsquelleAutor der Antwort David E.

1

Wird der folgende Satz LAST zum letzten argument ohne änderung der aktuellen Umgebung:
```
LAST=$({
   shift $(($#-1))
   echo $1
})
echo $LAST
```
Wenn andere Argumente nicht mehr benötigt und können verschoben werden es kann vereinfacht werden zu:
```
shift $(($#-1))
echo $1
```
Für die Portabilität Gründen folgende:
```
shift $(($#-1));
```
kann ersetzt werden durch:
```
shift `expr $# - 1`
```
Ersetzen auch $() mit backquotes erhalten wir:
```
LAST=`{
   shift \`expr $# - 1\`
   echo $1
}`
echo $LAST
```
InformationsquelleAutor der Antwort Paweł Nadolski
1
```
echo $argv[$#argv]
```
Nun muss ich nur einen text ergänzen, da meine Antwort zu kurz war, um post. Ich muss hinzufügen mehr text zu Bearbeiten.

InformationsquelleAutor der Antwort frank1rizzo
1

Fand ich @AgileZebra Antwort (plus @starfry Kommentar) die meisten nützlich, aber es setzt heads einen Skalar. Ein array ist wohl nützlicher:
```
heads=( "${@:1:$(($# - 1))}" )
tail=${@:${#@}}
```
InformationsquelleAutor der Antwort EndlosSchleife

#! /bin/sh

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

echo $last

InformationsquelleAutor der Antwort Craig Trader

0

Dies ist Teil meiner Funktion kopieren:
```
eval echo $(echo '$'"$#")
```
Zur Verwendung in Skripten, dies zu tun:
```
a=$(eval echo $(echo '$'"$#"))
```
Erklärung (tiefste zuerst):
1. $(echo '$'"$#") zurück $[nr] wo [nr] ist die Anzahl der Parameter. E. g. der string $123 (unausgebreiteten).
2. echo $123 gibt den Wert des 123rd parameter, wenn Sie ausgewertet werden.
3. eval nur erweitert $123 auf den Wert des Parameters, z.B. last_arg. Dieser wird als string interpretiert und ausgegeben werden.
Arbeiten mit der Bash ab Mitte 2015.

InformationsquelleAutor der Antwort Esavier

-1

Versuchen die unter-Skript zum letzten argument

 # 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

Ausgabe:

 # ./arguments.sh
 No Arguments supplied

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

Dank.

InformationsquelleAutor der Antwort Ranjithkumar T

-1

Es ist sehr viel präziser Weg, dies zu tun. Argumente für ein bash-Skript können mitgebracht werden, in einem array, das macht den Umgang mit den Elementen viel einfacher. Das Skript unten wird immer drucken Sie die letzten argument übergeben Sie ein Skript.

  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]}

Beispiel-Ausgabe

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

InformationsquelleAutor der Antwort tekbot

-1

Diesem format gearbeitet, bei Slackware und Cygwin.

"${x[@]:(-1)}", wenn verwendet mit $@, "${@:(-1)}"

Es bedeutet, ist: ${@:(N)}, werden wieder alle element nach N index.(sind N),
-1 ist thelast.

InformationsquelleAutor der Antwort zw963
-1

Mittels der parameter-expansion (löschen abgestimmt Anfang):
```
args="$@"
last=${args##* }
```
Es ist auch einfach, um alle vor dem letzten:
```
prelast=${args% *}
```
InformationsquelleAutor der Antwort Jurij

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.