So erhalten Sie das letzte Argument für eine / bin / sh-Funktion

Was ist ein besserer Weg, um zu implementieren print_last_arg?

#!/bin/sh

print_last_arg () {
    eval "echo \${$#}"  # this hurts
}

print_last_arg foo bar baz
# baz

(Wenn dies beispielsweise wäre, #!/usr/bin/zshanstatt zu #!/bin/shwissen, was zu tun ist. Mein Problem besteht darin, einen vernünftigen Weg zu finden, dies zu implementieren #!/bin/sh.)

EDIT: Das obige ist nur ein dummes Beispiel. Mein Ziel ist es nicht, das letzte Argument zu drucken , sondern eine Möglichkeit zu haben, auf das letzte Argument innerhalb einer Shell-Funktion zu verweisen.

EDIT2: Ich entschuldige mich für eine so unklar formulierte Frage. Ich hoffe, es diesmal richtig zu machen.

Wenn dies /bin/zshstattdessen wäre /bin/sh, könnte ich so etwas schreiben

#!/bin/zsh

print_last_arg () {
    local last_arg=$argv[$#]
    echo $last_arg
}

Der Ausdruck $argv[$#]ist ein Beispiel für das, was ich in meiner ersten EDIT beschrieben habe , um auf das letzte Argument innerhalb einer Shell-Funktion zu verweisen .

Deshalb hätte ich mein ursprüngliches Beispiel wirklich so schreiben sollen:

print_last_arg () {
    local last_arg=$(eval "echo \${$#}")   # but this hurts even more
    echo $last_arg
}

... um klar zu machen, dass das, wonach ich suche, eine weniger schreckliche Sache ist, die ich rechts von der Aufgabe setzen muss.

Beachten Sie jedoch, dass in allen Beispielen zerstörungsfrei auf das letzte Argument zugegriffen wird . IOW, der Zugriff auf das letzte Argument lässt die Positionsargumente insgesamt unberührt.

eval printf %s${1+"'\n' \"the last arg is \${$#"\}\"}

... gibt entweder die Zeichenfolge the last arg isgefolgt von einem <Leerzeichen> , dem Wert des letzten Arguments und einem nachfolgenden <Newline> aus, wenn mindestens 1 Argument vorhanden ist, oder gibt bei Nullargumenten überhaupt nichts aus.

Wenn du. .. getan hast:

eval ${1+"lastarg=\${$#"\}}

... dann würden Sie entweder der Shell-Variablen den Wert des letzten Arguments zuweisen, $lastargwenn mindestens 1 Argument vorhanden ist, oder Sie würden überhaupt nichts tun. In jedem Fall würden Sie es sicher tun, und es sollte sogar für die Olde Bourne-Shell tragbar sein, denke ich.

Hier ist eine andere, die ähnlich funktionieren würde, obwohl das gesamte arg-Array zweimal kopiert werden muss (und ein printfIn $PATHfür die Bourne-Shell erforderlich ist ) :

if   [ "${1+:}" ]
then set "$#" "$@" "$@"
     shift    "$1"
     printf %s\\n "$1"
     shift
fi

Hier ist ein vereinfachter Weg:

print_last_arg () {
  if [ "$#" -gt 0 ]
  then
    s=$(( $# - 1 ))
  else
    s=0
  fi
  shift "$s"
  echo "$1"
}

(aktualisiert basierend auf dem Punkt von @ cuonglm, dass das Original fehlgeschlagen ist, wenn keine Argumente übergeben wurden; dies gibt jetzt eine leere Zeile wieder - ändern Sie dieses Verhalten in der elseKlausel, falls gewünscht)

Am Beispiel des Eröffnungspostens (Positionsargumente ohne Leerzeichen):

print_last_arg foo bar baz

Für den Standard IFS=' \t\n', wie etwa:

args="$*" && printf '%s\n' "${args##* }"

Für eine sicherere Erweiterung von "$*"setzen Sie IFS (per @ StéphaneChazelas):

( IFS=' ' args="$*" && printf '%s\n' "${args##* }" )

Das Obige schlägt jedoch fehl, wenn Ihre Positionsargumente Leerzeichen enthalten können. Verwenden Sie in diesem Fall stattdessen Folgendes:

for a in "$@"; do : ; done && printf '%s\n' "$a"

Beachten Sie, dass diese Techniken die Verwendung vermeiden evalund keine Nebenwirkungen haben.

Getestet bei shellcheck.net

POSIXly:

while [ "$#" -gt 1 ]; do
  shift
done

printf '%s\n' "$1"

(Dieser Ansatz funktioniert auch in der alten Bourne-Shell)

Mit anderen Standardwerkzeugen:

awk 'BEGIN{print ARGV[ARGC-1]}' "$@"

(Dies funktioniert nicht mit alten awk, die nicht hatten ARGV)

Dies sollte mit jeder POSIX-kompatiblen Shell funktionieren und auch mit der älteren Solaris Bourne-Shell vor POSIX:

do=;for do do :;done;printf "%s\n" "$do"

und hier ist eine Funktion, die auf dem gleichen Ansatz basiert:

print_last_arg()
  if [ "$*" ]; then
    for do do :;done
    printf "%s\n" "$do"
  else
    echo
  fi

PS: Sag mir nicht, dass ich die geschweiften Klammern um den Funktionskörper vergessen habe ;-)

Aus "Unix - Häufig gestellte Fragen"

(1)

unset last
if    [ $# -gt 0 ]
then  eval last=\${$#}
fi
echo  "$last"

Wenn die Anzahl der Argumente Null sein könnte, wird dem Argument Null $0(normalerweise der Name des Skripts) zugewiesen $last. Das ist der Grund für das Wenn.

(2)

unset last
for   last
do    :
done
echo  "$last"

(3)

for     i
do
        third_last=$second_last
        second_last=$last
        last=$i
done
echo    "$last"

Um zu vermeiden, dass eine leere Zeile gedruckt wird, wenn keine Argumente vorhanden sind, ersetzen Sie das echo "$last"for:

${last+false} || echo "${last}"

Eine Anzahl von Nullargumenten wird durch vermieden if [ $# -gt 0 ].

Dies ist keine exakte Kopie dessen, was auf der Seite verlinkt ist. Einige Verbesserungen wurden hinzugefügt.

Obwohl diese Frage etwas mehr als 2 Jahre alt ist, dachte ich, ich würde eine etwas kompakte Option teilen.

print_last_arg () {
    echo "${@:${#@}:${#@}}"
}

Lass es uns laufen

print_last_arg foo bar baz
baz

Erweiterung der Bash- Shell-Parameter .

Bearbeiten

Noch prägnanter: echo "${@: -1}"

(Achten Sie auf den Raum)

Quelle

Getestet unter macOS 10.12.6, sollte aber auch das letzte Argument für die meisten verfügbaren * nix-Varianten zurückgeben ...

Tut viel weniger weh ¯\_(ツ)_/¯

Dies sollte auf allen perlinstallierten Systemen funktionieren (daher die meisten UNICES):

print_last_arg () {
    printf '%s\0' "$@" | perl -0ne 's/\0//;$l=$_;}{print "$l\n"'
}

Der Trick besteht darin printf, \0nach jedem Shell-Argument und dann perlden -0Schalter einzufügen, der das Datensatztrennzeichen auf NULL setzt. Dann iterieren wir über die Eingabe, entfernen die \0und speichern jede NULL-terminierte Zeile als $l. Der ENDBlock (das ist, was der }{ist) wird ausgeführt, nachdem alle Eingaben gelesen wurden, und gibt die letzte "Zeile" aus: das letzte Shell-Argument.

Hier ist eine Version mit Rekursion. Keine Ahnung, wie POSIX-konform dies ist ...

print_last_arg()
{
    if [ $# -gt 1 ] ; then
        shift
        echo $( print_last_arg "$@" )
    else
        echo "$1"
    fi
}

Ein einfaches Konzept, keine Arithmetik, keine Schleife, keine Auswertung , nur Funktionen.
Denken Sie daran, dass die Bourne-Shell keine Arithmetik hatte (extern benötigt expr). Wenn Sie eine arithmetikfreie evalWahl treffen möchten , ist dies eine Option. Benötigte Funktionen bedeutet SVR3 oder höher (kein Überschreiben von Parametern).
Unten finden Sie eine robustere Version mit printf.

printlast(){
    shift "$1"
    echo "$1"
}

printlast "$#" "$@"          ### you may use ${1+"$@"} here to allow
                             ### a Bourne empty list of arguments,
                             ### but wait for a correct solution below.

Diese Struktur Anruf printlastwird fixiert , die Argumente in der Liste der Argumente Schale festgelegt werden müssen $1, $2usw. (das Argument stack) und der Anruf wird als gegeben getan.

Wenn die Liste der Argumente geändert werden muss, legen Sie sie einfach fest:

set -- o1e t2o t3r f4u
printlast "$#" "$@"

Oder erstellen Sie eine benutzerfreundlichere Funktion ( getlast), die generische Argumente zulässt (aber nicht so schnell, Argumente werden zweimal übergeben).

getlast(){ printlast "$#" "$@"; }
getlast o1e t2o t3r f4u

Bitte beachten Sie, dass Argumente (von getlastoder alle in $@printlast enthaltenen) Leerzeichen, Zeilenumbrüche usw. enthalten können, jedoch nicht NUL.

Besser

Diese Version wird nicht gedruckt, 0wenn die Liste der Argumente leer ist, und verwendet das robustere printf (greifen Sie auf zurück, echowenn printffür alte Shells kein externes verfügbar ist).

printlast(){ shift  "$1"; printf '%s' "$1"; }
getlast  ()  if     [ $# -gt 0 ]
             then   printlast "$#" "$@"
                    echo    ### optional if a trailing newline is wanted.
             fi
### The {} braces were removed on purpose.

getlast 1 2 3 4    # will print 4

EVAL verwenden.

Wenn die Bourne-Shell noch älter ist und keine Funktionen vorhanden sind oder wenn aus irgendeinem Grund die Verwendung von eval die einzige Option ist:

So drucken Sie den Wert:

if    [ $# -gt 0 ]
then  eval printf "'1%s\n'" \"\$\{$#\}\"
fi

So legen Sie den Wert in einer Variablen fest:

if    [ $# -gt 0 ]
then  eval 'last_arg='\"\$\{$#\}\"
fi

Wenn dies in einer Funktion erfolgen muss, müssen die Argumente in die Funktion kopiert werden:

print_last_arg () {
    local last_arg                ### local only works on more modern shells.
    eval 'last_arg='\"\$\{$#\}\"
    echo "last_arg3=$last_arg"
}

print_last_arg "$@"               ### Shell arguments are sent to the function.

Dieser Kommentar schlug vor, das sehr elegante zu verwenden:

echo "${@:$#}"