Das letzte Argument an ein Shell-Skript übergeben

$1ist das erste Argument.
$@ist alle von ihnen.

Wie finde ich das letzte Argument, das an ein Shell-Skript übergeben wurde?

Das ist ein bisschen wie ein Hack:

for last; do true; done
echo $last

Dieser ist auch ziemlich portabel (sollte wieder mit bash, ksh und sh funktionieren) und verschiebt die Argumente nicht, was nett sein könnte.

Es wird die Tatsache verwendet, dass fordie Argumente implizit durchlaufen werden, wenn Sie nicht angeben, was durchlaufen werden soll, und die Tatsache, dass for-Schleifenvariablen keinen Gültigkeitsbereich haben: Sie behalten den letzten Wert bei, auf den sie festgelegt wurden.

Dies ist nur 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

Der Speicherplatz ist erforderlich, damit er nicht als Standardwert interpretiert wird .

Beachten Sie, dass dies nur Bash ist.

Die einfachste Antwort für 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 ist:

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

Verwenden Sie die Indizierung kombiniert mit der Länge von:

echo ${@:${#@}} 

Beachten Sie, dass dies nur Bash ist.

Folgendes wird für Sie funktionieren. Das @ steht für ein Array von Argumenten. : bedeutet bei. $ # ist die Länge des Array von Argumenten. Das Ergebnis ist also das letzte Element:

${@:$#} 

Beispiel:

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

Beachten Sie, dass dies nur Bash ist.

Ich habe dies gefunden, als ich versucht habe, das letzte Argument von allen vorherigen zu trennen. Während einige der Antworten das letzte Argument erhalten, sind sie nicht sehr hilfreich, wenn Sie auch alle anderen Argumente benötigen. Das funktioniert viel besser:

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

Beachten Sie, dass dies nur Bash ist.

Dies funktioniert in allen POSIX-kompatiblen Shells:

eval last=\${$#}

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

Hier ist meine Lösung:

• ziemlich portabel (alle POSIX sh, bash, ksh, zsh) sollte funktionieren
• verschiebt nicht die ursprünglichen Argumente (verschiebt eine Kopie).
• benutzt das Böse nicht eval
• durchläuft nicht die gesamte Liste
• verwendet keine externen Tools

Code:

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

Von den ältesten zu den neueren Lösungen:

Die tragbarste Lösung, auch älter sh(funktioniert mit Leerzeichen und Glob-Zeichen) (keine Schleife, schneller):

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

Seit Version 2.01 von bash

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

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

Für ksh, zsh und bash:

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

Und für "vorletzte":

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

Verwenden von printf, um Probleme mit Argumenten zu umgehen, die mit einem Bindestrich beginnen (z -n ).

Für alle Shells und für ältere sh(funktioniert mit Leerzeichen und Glob-Zeichen) gilt:

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

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

Oder wenn Sie eine Variable festlegen möchten last:

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

Und für "vorletzte":

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

Wenn Sie Bash> = 3.0 verwenden

echo ${BASH_ARGV[0]}

Für bash, dieser Kommentar vorgeschlagen , die sehr elegant:

echo "${@:$#}"

Als Bonus funktioniert dies auch in zsh.

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

Dies verschiebt die Argumente um die Anzahl der Argumente minus 1 und gibt das erste (und einzige) verbleibende Argument zurück, das das letzte sein wird.

Ich habe nur in Bash getestet, aber es sollte auch in Sh und Ksh funktionieren.

Wenn Sie dies zerstörungsfrei tun möchten, besteht eine Möglichkeit darin, alle Argumente an eine Funktion zu übergeben und das letzte zurückzugeben:

#!/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 es dich eigentlich nicht interessiert , die anderen Argumente beizubehalten, brauchen Sie sie nicht in einer Funktion, aber es fällt mir schwer, an eine Situation zu denken, in der Sie die anderen Argumente niemals behalten möchten, es sei denn, sie wurden bereits verarbeitet. In diesem Fall würde ich die Methode process / shift / process / shift / ... verwenden, um sie nacheinander zu verarbeiten.

Ich gehe hier davon aus, dass Sie sie behalten möchten, weil Sie die sequentielle Methode nicht befolgt haben . Diese Methode behandelt auch den Fall, dass keine Argumente vorhanden sind und "" zurückgegeben werden. Sie können dieses Verhalten leicht anpassen, indem Sie die auskommentierte elseKlausel einfügen .

Für tcsh:

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

Ich bin mir ziemlich sicher, dass dies eine tragbare Lösung wäre, abgesehen von der Aufgabe.

Ich fand die Antwort von @ AgileZebra (plus den Kommentar von @ starfry) am nützlichsten, aber sie setzt headsauf einen Skalar. Ein Array ist wahrscheinlich nützlicher:

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

Beachten Sie, dass dies nur Bash ist.

Eine Lösung mit eval:

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

echo $last

Nachdem ich die obigen Antworten gelesen hatte, schrieb ich ein Q & D-Shell-Skript (sollte mit sh und bash funktionieren), um g ++ auf PGM.cpp auszuführen und ein ausführbares Image-PGM zu erstellen. Es wird davon ausgegangen, dass das letzte Argument in der Befehlszeile der Dateiname ist (.cpp ist optional) und alle anderen Argumente Optionen sind.

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

Folgendes wird auf LASTdas letzte Argument gesetzt, ohne die aktuelle Umgebung zu ändern:

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

Wenn andere Argumente nicht mehr benötigt werden und verschoben werden können, kann dies vereinfacht werden zu:

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

Aus Gründen der Portabilität:

shift $(($#-1));

kann ersetzt werden durch:

shift `expr $# - 1`

$()Wenn wir auch durch Backquotes ersetzen, erhalten wir:

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

echo $argv[$#argv]

Jetzt muss ich nur noch Text hinzufügen, da meine Antwort zu kurz war, um sie zu veröffentlichen. Ich muss mehr Text zum Bearbeiten hinzufügen.

Dies ist Teil meiner Kopierfunktion:

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

Gehen Sie folgendermaßen vor, um sie in Skripten zu verwenden:

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

Erläuterung (am meisten verschachtelt zuerst):

1. $(echo '$'"$#")Gibt zurück, $[nr]wo [nr]die Anzahl der Parameter ist. ZB die Saite $123(nicht erweitert).
2. echo $123 Gibt bei Auswertung den Wert des 123. Parameters zurück.
3. evalerweitert sich einfach $123auf den Wert des Parameters, z last_arg. Dies wird als Zeichenfolge interpretiert und zurückgegeben.

Arbeitet ab Mitte 2015 mit Bash.

#! /bin/sh

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

echo $last

Versuchen Sie das folgende Skript, um das letzte Argument zu finden

 # 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

Vielen Dank.

Es gibt einen viel prägnanteren Weg, dies zu tun. Argumente für ein Bash-Skript können in ein Array eingefügt werden, was den Umgang mit den Elementen erheblich vereinfacht. Das folgende Skript gibt immer das letzte Argument aus, das an ein Skript übergeben wurde.

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

Beispielausgabe

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

Parametererweiterung verwenden (übereinstimmenden Anfang löschen):

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

Es ist auch einfach, alles vorletzt zu bekommen:

prelast=${args% *}

Verwenden Sie den speziellen Parameter, um das letzte Argument des zuletzt verwendeten Befehls zurückzugeben:

$_

In diesem Fall funktioniert es, wenn es im Skript verwendet wird, bevor ein anderer Befehl aufgerufen wurde.

Einfach benutzen !$.

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