Uzyskanie ostatniego argumentu przekazanego do skryptu powłoki

$1to pierwszy argument.
$@to wszystko.

Jak mogę znaleźć ostatni argument przekazany do skryptu powłoki?

To jest trochę włamania:

for last; do true; done
echo $last

Ten jest również dość przenośny (znowu powinien działać z bash, ksh i sh) i nie zmienia argumentów, co może być miłe.

Wykorzystuje fakt, że forniejawnie zapętla się nad argumentami, jeśli nie powiesz, co należy zapętlić, oraz fakt, że w przypadku zmiennych pętli nie ma zasięgu: zachowują ostatnią wartość, dla której zostały ustawione.

To jest tylko 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

Spacja jest niezbędna, aby nie została zinterpretowana jako wartość domyślna .

Zauważ, że jest to tylko bash.

Najprostsza odpowiedź na bash 3.0 lub nowszy to

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

Otóż ​​to.

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

Dane wyjściowe to:

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

Użyj indeksowania w połączeniu z długością:

echo ${@:${#@}} 

Zauważ, że jest to tylko bash.

Poniższe będą działać dla Ciebie. @ Oznacza tablicę argumentów. : oznacza o. $ # to długość tablicy argumentów. Wynik jest ostatnim elementem:

${@:$#} 

Przykład:

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

Zauważ, że jest to tylko bash.

Znaleziono to, gdy chcesz oddzielić ostatni argument od wszystkich poprzednich. Chociaż niektóre odpowiedzi mają ostatni argument, nie są zbyt pomocne, jeśli potrzebujesz wszystkich innych argumentów. Działa to znacznie lepiej:

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

Zauważ, że jest to tylko bash.

Działa to we wszystkich powłokach zgodnych z POSIX:

eval last=\${$#}

Źródło: http://www.faqs.org/faqs/unix-faq/faq/part2/section-12.html

Oto moje rozwiązanie:

• całkiem przenośne (wszystkie POSIX sh, bash, ksh, zsh) powinny działać
• nie zmienia oryginalnych argumentów (przesuwa kopię).
• nie używa zła eval
• nie przechodzi przez całą listę
• nie korzysta z zewnętrznych narzędzi

Kod:

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

Od najstarszych do nowszych rozwiązań:

Najbardziej przenośne rozwiązanie, nawet starsze sh(działa ze spacjami i znakami glob) (bez pętli, szybciej):

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

Od wersji 2.01 bash

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

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

Dla ksh, zsh i bash:

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

A dla „obok ostatniego”:

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

Za pomocą printf można obejść wszelkie problemy z argumentami rozpoczynającymi się od myślnika (np -n.).

Dla wszystkich powłok i starszych sh(działa ze spacjami i znakami glob):

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

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

Lub, jeśli chcesz ustawić lastvar:

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

A dla „obok ostatniego”:

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

Jeśli używasz Bash> = 3.0

echo ${BASH_ARGV[0]}

Dla bash, to komentarz sugeruje bardzo elegancki:

echo "${@:$#}"

Jako bonus, działa również w zsh.

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

Powoduje to przesunięcie argumentów o liczbę argumentów pomniejszoną o 1 i zwraca pierwszy (i jedyny) pozostały argument, który będzie ostatnim.

Testowałem tylko w bashu, ale powinien działać również w sh i ksh.

Jeśli chcesz to zrobić w sposób nieniszczący, jednym ze sposobów jest przekazanie wszystkich argumentów do funkcji i zwrócenie ostatniego:

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

Jeśli tak naprawdę cię to nie obchodzi na zachowaniu innych argumentów, nie potrzebujesz ich w funkcji, ale trudno mi myśleć o sytuacji, w której nigdy nie chciałbyś zatrzymać innych argumentów, chyba że zostały już przetworzone, w takim przypadku użyłbym metody process / shift / process / shift / ... sekwencyjnego ich przetwarzania.

Zakładam, że chcesz je zachować, ponieważ nie zastosowałeś metody sekwencyjnej. Ta metoda obsługuje również przypadek, w którym nie ma argumentów, zwracając „”. Możesz łatwo dostosować to zachowanie, wstawiając skomentowaną elseklauzulę.

Dla tcsh:

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

Jestem pewien, że byłoby to przenośne rozwiązanie, z wyjątkiem zadania.

Uważam, że odpowiedź @ AgileZebra (plus komentarz @ starfry) jest najbardziej użyteczna, ale ustawia headssię na skalar. Tablica jest prawdopodobnie bardziej przydatna:

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

Zauważ, że jest to tylko bash.

Rozwiązanie wykorzystujące eval:

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

echo $last

Po przeczytaniu powyższych odpowiedzi napisałem skrypt powłoki Q&D (powinien działać na sh i bash), aby uruchomić g ++ na PGM.cpp, aby wygenerować obraz wykonywalny PGM. Zakłada się, że ostatnim argumentem w wierszu poleceń jest nazwa pliku (.cpp jest opcjonalny), a wszystkie pozostałe argumenty są opcjami.

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

Poniższy LASTargument ustawi ostatni argument bez zmiany bieżącego środowiska:

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

Jeśli inne argumenty nie są już potrzebne i można je przenieść, można uprościć:

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

Ze względu na przenośność:

shift $(($#-1));

można zastąpić:

shift `expr $# - 1`

Zastępując również $()cudzysłowy otrzymujemy:

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

echo $argv[$#argv]

Teraz muszę tylko dodać tekst, ponieważ moja odpowiedź była zbyt krótka, aby opublikować. Muszę dodać więcej tekstu do edycji.

To jest część mojej funkcji kopiowania:

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

Aby użyć w skryptach, wykonaj następujące czynności:

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

Objaśnienie (najpierw najbardziej zagnieżdżone):

1. $(echo '$'"$#")zwraca $[nr]gdzie [nr]jest liczba parametrów. Np. Ciąg $123(nierozwinięty).
2. echo $123 zwraca wartość parametru 123. po oszacowaniu.
3. evalpo prostu rozwija $123się do wartości parametru, np last_arg. Jest to interpretowane jako ciąg znaków i zwracane.

Działa z Bash od połowy 2015 roku.

#! /bin/sh

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

echo $last

Wypróbuj poniższy skrypt, aby znaleźć ostatni 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

Wynik:

 # ./arguments.sh
 No Arguments supplied

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

Dzięki.

Jest na to o wiele bardziej zwięzły sposób. Argumenty do skryptu bash można wprowadzić do tablicy, co znacznie upraszcza obsługę elementów. Poniższy skrypt zawsze wypisze ostatni argument przekazany do skryptu.

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

Próbka wyjściowa

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

Korzystanie z rozszerzania parametrów (usuń dopasowany początek):

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

Łatwo jest też zdobyć wszystko przed ostatnim:

prelast=${args% *}

Aby zwrócić ostatni argument ostatnio używanej komendy, użyj specjalnego parametru:

$_

W tym przypadku będzie działać, jeśli zostanie użyty w skrypcie przed wywołaniem innego polecenia.

Po prostu użyj !$.

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