Come ottenere l'ultimo argomento in una funzione / bin / sh

Qual è un modo migliore per implementare print_last_arg?

#!/bin/sh

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

print_last_arg foo bar baz
# baz

(Se questo fosse, diciamo, #!/usr/bin/zshinvece di #!/bin/shsapere cosa fare. Il mio problema è trovare un modo ragionevole per implementarlo #!/bin/sh.)

EDIT: quanto sopra è solo un esempio sciocco. Il mio obiettivo non è quello di stampare l'ultimo argomento, ma piuttosto di avere un modo per fare riferimento all'ultimo argomento all'interno di una funzione shell.

EDIT2: mi scuso per una domanda così poco chiara. Spero di farlo bene questa volta.

Se questo fosse /bin/zshal posto di /bin/sh, potrei scrivere qualcosa di simile

#!/bin/zsh

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

L'espressione $argv[$#]è un esempio di ciò che ho descritto nel mio primo EDIT come un modo per fare riferimento all'ultimo argomento all'interno di una funzione shell .

Pertanto, avrei davvero dovuto scrivere il mio esempio originale in questo modo:

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

... per chiarire che quello che sto cercando è una cosa meno terribile da mettere a destra dell'incarico.

Si noti, tuttavia, che in tutti gli esempi, si accede all'ultimo argomento in modo non distruttivo . IOW, l'accesso all'ultimo argomento lascia inalterati gli argomenti posizionali.

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

... o stamperà la stringa the last arg isseguita da uno <spazio> , il valore dell'ultimo argomento e un <newline> finale se c'è almeno 1 argomento, oppure, per zero argomenti, non stamperà nulla.

Se avete fatto:

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

... allora o assegnereste il valore dell'ultimo argomento alla variabile shell $lastargse c'è almeno 1 argomento, o non fareste nulla. Ad ogni modo, lo faresti in modo sicuro, e dovrebbe essere portatile anche per te, conchiglia Olde Bourne, credo.

Ecco un altro che funzionerebbe in modo simile, anche se richiede di copiare l'intero array arg due volte (e richiede un printfin $PATHper la shell Bourne) :

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

Ecco un modo semplicistico:

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

(aggiornato in base al punto di @ cuonglm secondo cui l'originale falliva quando non venivano passati argomenti; questo ora echeggia una riga vuota - elsese lo si desidera modificare tale comportamento nella clausola)

Dato l'esempio del post iniziale (argomenti posizionali senza spazi):

print_last_arg foo bar baz

Per impostazione predefinita IFS=' \t\n', che ne dici di:

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

Per un'espansione più sicura di "$*", impostare IFS (per @ StéphaneChazelas):

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

Ma quanto sopra fallirà se i tuoi argomenti posizionali possono contenere spazi. In tal caso, utilizzare questo invece:

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

Si noti che queste tecniche evitano l'uso evale non hanno effetti collaterali.

Testato su shellcheck.net

Sebbene questa domanda abbia poco più di 2 anni, ho pensato di condividere un'opzione piuttosto compatta.

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

Eseguiamolo

print_last_arg foo bar baz
baz

Espansione dei parametri della shell Bash .

modificare

Ancora più conciso: echo "${@: -1}"

(Mente lo spazio)

fonte

Testato su macOS 10.12.6 ma dovrebbe anche restituire l'ultimo argomento sulla maggior parte dei gusti * nix disponibili ...

Fa molto meno male ¯\_(ツ)_/¯

POSIXly:

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

printf '%s\n' "$1"

(Questo approccio funziona anche nella vecchia shell Bourne)

Con altri strumenti standard:

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

(Questo non funzionerà con il vecchio awk, che non aveva ARGV)

Questo dovrebbe funzionare con qualsiasi shell conforme a POSIX e funzionerà anche con la shell Solaris Bourne precedente a POSIX:

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

e qui è una funzione basata sullo stesso approccio:

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

PS: non dirmi che ho dimenticato le parentesi graffe attorno al corpo della funzione ;-)

Da "Unix - Domande frequenti"

(1)

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

Se il numero di argomenti potrebbe essere zero, $0verrà assegnato l' argomento zero (di solito il nome dello script) $last. Questa è la ragione del se.

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

Per evitare di stampare una riga vuota quando non ci sono argomenti, sostituire il echo "$last"per:

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

Un conteggio argomenti zero è evitato da if [ $# -gt 0 ].

Questa non è una copia esatta di ciò che è nel link nella pagina, sono stati aggiunti alcuni miglioramenti.

Questo dovrebbe funzionare su tutti i sistemi con perlinstallato (quindi la maggior parte degli UNICES):

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

Il trucco è usare printfper aggiungere un \0argomento dopo ogni shell e quindi perll' -0opzione che imposta il separatore dei record su NULL. Quindi iteriamo sull'input, rimuoviamo \0e salvando ogni riga terminata NULL come $l. Il ENDblocco (che è quello che }{è) verrà eseguito dopo aver letto tutti gli input, quindi stamperà l'ultima "riga": l'ultimo argomento della shell.

Ecco una versione che utilizza la ricorsione. Non ho idea di quanto POSIX sia conforme ...

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

Un concetto semplice, nessuna aritmetica, nessun ciclo, nessuna valutazione , solo funzioni.
Ricorda che la shell Bourne non aveva aritmetica (necessaria all'esterno expr). Se vuoi ottenere un'aritmetica libera, evallibera scelta, questa è un'opzione. La necessità di funzioni significa SVR3 o superiore (nessuna sovrascrittura dei parametri).
Cerca di seguito una versione più robusta con 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.

Tale struttura di chiamata printlastè fissata , gli argomenti devono essere impostati nella lista di argomenti shell $1, $2ecc (stack degli argomenti) e la chiamata fatto come dato.

Se l'elenco degli argomenti deve essere modificato, basta impostarli:

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

Oppure crea una funzione più semplice da usare ( getlast) che consenta argomenti generici (ma non altrettanto velocemente, gli argomenti vengono passati due volte).

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

Si noti che gli argomenti (di getlast, o tutti inclusi in $@per printlast) potrebbero avere spazi, nuove righe, ecc. Ma non NUL.

Meglio

Questa versione non viene stampata 0quando l'elenco di argomenti è vuoto e utilizza il printf più robusto (ripiegare su echose esterno printfnon è disponibile per le vecchie shell).

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

Utilizzando EVAL.

Se la shell Bourne è ancora più vecchia e non ci sono funzioni, o se per qualche motivo l'uso di eval è l'unica opzione:

Per stampare il valore:

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

Per impostare il valore in una variabile:

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

Se ciò deve essere fatto in una funzione, gli argomenti devono essere copiati nella funzione:

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.

Questo commento ha suggerito di usare l'elegantissimo:

echo "${@:$#}"