Jak uzyskać ostatni argument do funkcji / bin / sh

Jaki jest lepszy sposób wdrożenia print_last_arg?

#!/bin/sh

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

print_last_arg foo bar baz
# baz

(Gdyby tak było, powiedzmy, #!/usr/bin/zshzamiast #!/bin/shwiedzieć, co robić. Moim problemem jest znalezienie rozsądnego sposobu na wdrożenie tego #!/bin/sh.)

EDYCJA: Powyższe to tylko głupi przykład. Moim celem nie jest wydrukowanie ostatniego argumentu, ale raczej sposób na odniesienie się do ostatniego argumentu w funkcji powłoki.

EDYCJA 2: Przepraszam za tak niejasno sformułowane pytanie. Mam nadzieję, że tym razem wszystko będzie dobrze.

Gdyby tak było /bin/zsh, zamiast /bin/sh, mogę napisać coś takiego

#!/bin/zsh

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

Wyrażenie $argv[$#]jest przykładem tego, co opisałem w moim pierwszym EDYCJI jako sposobu na odniesienie do ostatniego argumentu w funkcji powłoki .

Dlatego naprawdę powinienem był napisać mój oryginalny przykład w ten sposób:

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

... aby wyjaśnić, że to, czego szukam, jest mniej okropnym posunięciem na prawo od zadania.

Należy jednak pamiętać, że we wszystkich przykładach do ostatniego argumentu można uzyskać dostęp nieniszczący . IOW, dostęp do ostatniego argumentu pozostawia argumenty pozycyjne jako całość bez zmian.

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

... wypisze ciąg znaków, the last arg ispo którym następuje <spacja> , wartość ostatniego argumentu i końcowy <nowyline>, jeśli jest co najmniej 1 argument, lub w przypadku argumentów zerowych nic nie wypisze.

Jeśli zrobiłeś:

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

... wtedy albo przypisujesz wartość ostatniego argumentu do zmiennej powłoki, $lastargjeśli jest co najmniej 1 argument, albo nic nie robisz. Tak czy inaczej, zrobiłbyś to bezpiecznie i powinien być przenośny nawet dla skorupy Olde Bourne, tak myślę.

Oto jeszcze jeden, który działa podobnie, choć wymaga kopiując cały szereg arg dwukrotnie (i wymaga printfw $PATHdla powłoki Bourne) :

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

Oto uproszczony sposób:

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

(zaktualizowano w oparciu o punkt @ cuonglm, że oryginał zawiódł, gdy nie przekazał żadnych argumentów; teraz wyświetla się pusty wiersz - w elserazie potrzeby zmień to zachowanie w klauzuli)

Biorąc pod uwagę przykład postu otwierającego (argumenty pozycyjne bez spacji):

print_last_arg foo bar baz

Domyślnie IFS=' \t\n', co powiesz na:

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

Aby zwiększyć bezpieczeństwo "$*", ustaw IFS (per @ StéphaneChazelas):

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

Ale powyższe nie powiedzie się, jeśli argumenty pozycyjne mogą zawierać spacje. W takim przypadku użyj tego zamiast:

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

Należy pamiętać, że techniki te pozwalają uniknąć stosowania evalefektów ubocznych i nie powodują ich.

Testowany w shellcheck.net

Chociaż to pytanie ma nieco ponad 2 lata, pomyślałem, że podzielę się nieco bardziej złożoną opcją.

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

Uruchommy to

print_last_arg foo bar baz
baz

Rozszerzenie parametru powłoki Bash .

Edytować

Jeszcze bardziej zwięzłe: echo "${@: -1}"

(Uważaj na przestrzeń)

Źródło

Przetestowano na macOS 10.12.6, ale powinien również zwrócić ostatni argument na większości dostępnych smaków * nix ...

Boli znacznie mniej ¯\_(ツ)_/¯

POSIXly:

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

printf '%s\n' "$1"

(To podejście działa również w starej powłoce Bourne'a)

Z innymi standardowymi narzędziami:

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

(To nie będzie działać ze starymi awk, które nie miały ARGV)

Powinno to działać z dowolną powłoką zgodną z POSIX i działać również z wcześniejszą powłoką Solaris Bourne starszą od POSIX:

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

a oto funkcja oparta na tym samym podejściu:

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

PS: nie mów mi, że zapomniałem nawiasów klamrowych wokół korpusu funkcji ;-)

Z „Unix - często zadawane pytania”

(1)

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

Jeśli liczba argumentów może wynosić zero, wówczas $0przypisany zostanie argument zero (zwykle nazwa skryptu) $last. To jest powód, dla którego.

(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"

Aby uniknąć drukowania pustej linii, gdy nie ma argumentów, zamień echo "$last"na:

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

Unika się zerowej liczby argumentów if [ $# -gt 0 ].

To nie jest dokładna kopia tego, co znajduje się w linku na stronie, dodano pewne ulepszenia.

Powinno to działać na wszystkich systemach z perlzainstalowanym (więc większość UNICES):

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

Sztuką jest, aby użyć printf, aby dodać \0po każdym argumencie powłoki, a następnie perl„s -0przełącznik, który ustawia swój rekord separator NULL. Następnie iterujemy dane wejściowe, usuwamy \0i zapisujemy każdą linię zakończoną znakiem NULL jako $l. ENDBlok (to właśnie }{jest) będą realizowane po wszystkim wejście została odczytana tak drukuje ostatnią „linia”: ostatni argument powłoki.

Oto wersja z rekurencją. Nie mam pojęcia, jak to jest zgodne z POSIX ...

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

Prosta koncepcja, bez arytmetyki, bez pętli, bez ewaluacji , tylko funkcje.
Pamiętaj, że powłoka Bourne'a nie miała arytmetyki (potrzebna zewnętrzna expr). Jeśli chcesz uzyskać arytmetykę wolny, evalwolny wybór, jest to opcja. Potrzebowanie funkcji oznacza SVR3 lub wyższy (bez nadpisywania parametrów).
Poniżej znajdziesz bardziej solidną wersję z 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.

Ta struktura na wezwanie printlastjest stałe , argumenty muszą być ustawione w liście argumentów powłoki $1, $2itd (stos argument) i rozmowa odbywa się, jak podano.

Jeśli lista argumentów wymaga zmiany, wystarczy je ustawić:

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

Lub stwórz łatwiejszą w użyciu funkcję ( getlast), która może dopuszczać ogólne argumenty (ale nie tak szybko, argumenty są przekazywane dwa razy).

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

Zauważ, że argumenty ( getlastlub wszystkie zawarte w $@printlast) mogą mieć spacje, znaki nowej linii itp. Ale nie NUL.

Lepszy

Ta wersja nie jest drukowana, 0gdy lista argumentów jest pusta, i użyj bardziej niezawodnego printf (cofnij się, echojeśli opcja zewnętrzna printfnie jest dostępna dla starych powłok).

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

Korzystanie z EVAL.

Jeśli powłoka Bourne'a jest jeszcze starsza i nie ma żadnych funkcji, lub jeśli z jakiegoś powodu użycie eval jest jedyną opcją:

Aby wydrukować wartość:

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

Aby ustawić wartość w zmiennej:

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

Jeśli trzeba to zrobić w funkcji, argumenty należy skopiować do funkcji:

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.

Ten komentarz sugeruje użycie bardzo eleganckiego:

echo "${@:$#}"