Отримання останнього аргументу передається сценарію оболонки

$1є першим аргументом.
$@це всі вони.

Як я можу знайти останній аргумент, переданий сценарію оболонки?

Це трохи хак:

for last; do true; done
echo $last

Цей також досить портативний (знову ж, він повинен працювати з bash, ksh та sh), і він не змінює аргументи, що може бути добре.

Він використовує той факт, що forнеявно перетворює циркуляцію на аргументи, якщо ви не вказуєте, на що робити цикл, а також про те, що для змінних циклу не застосовується обсяг: вони зберігають останнє значення, на яке вони були встановлені.

Це лише 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

Простір необхідний, щоб він не трактувався як значення за замовчуванням .

Зауважте, що це лише баш.

Найпростіша відповідь для bash 3.0 або вище

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

Це воно.

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

Вихід:

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

Використовуйте індексацію в поєднанні з довжиною:

echo ${@:${#@}} 

Зауважте, що це лише баш.

Наступне буде працювати для вас. @ - це масив аргументів. : означає при. $ # - довжина масиву аргументів. Отже, результат - останній елемент:

${@:$#} 

Приклад:

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

Зауважте, що це лише баш.

Виявив це, шукаючи відокремити останній аргумент від усіх попередніх аргументів. Хоча деякі відповіді отримують останній аргумент, вони не дуже допомагають, якщо вам знадобляться і всі інші аргументи. Це працює набагато краще:

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

Зауважте, що це лише баш.

Це працює у всіх сумісних з POSIX оболонках:

eval last=\${$#}

Джерело: http://www.faqs.org/faqs/unix-faq/faq/part2/section-12.html

Ось моє рішення:

• досить портативний (всі POSIX sh, bash, ksh, zsh) повинен працювати
• не зміщує оригінальні аргументи (зміщує копію).
• не вживає зла eval
• не повторюється через весь список
• не використовує зовнішніх інструментів

Код:

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

Від найстаріших до новіших рішень:

Найбільш портативне рішення, навіть старіше sh(працює з пробілами та глобальними символами) (без циклу, швидше):

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

З версії 2.01 bash

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

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

Для ksh, zsh та bash:

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

А для "поруч з останнім":

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

Використання printf для вирішення будь-яких проблем з аргументами, які починаються з тире (як -n).

Для всіх оболонок і для старих sh(працює з пробілами та символами глобуса) є:

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

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

Або якщо ви хочете встановити lastvar:

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

А для "поруч з останнім":

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

Якщо ви використовуєте Bash> = 3.0

echo ${BASH_ARGV[0]}

Для bash , цей коментар запропонував дуже елегантна:

echo "${@:$#}"

Як бонус, це також працює zsh.

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

Це зміщує аргументи на кількість аргументів мінус 1 і повертає перший (і єдиний) аргумент, що залишився, який буде останнім.

Я протестував лише в bash, але він також повинен працювати в sh і ksh.

Якщо ви хочете зробити це неруйнівним способом, один із способів - передати всі аргументи функції і повернути останній:

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

Якщо вам насправді все одно про збереження інших аргументів, вам це не потрібно у функції, але я важко придумую ситуацію, коли ви ніколи не хочете зберігати інші аргументи, якщо вони вже не були оброблені, в такому випадку я б використовував метод process / shift / process / shift / ..., щоб послідовно їх обробити.

Я припускаю, що ви хочете їх зберегти, оскільки ви не дотримувались послідовного методу. Цей метод також обробляє випадок, коли немає аргументів, повертаючи "". Ви можете легко скорегувати таку поведінку, вставивши зауважений коментований elseпункт.

Для tcsh:

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

Я впевнений, що це було б портативне рішення, крім завдання.

Я знайшов відповідь @ AgileZebra (плюс коментар @ starfry) найбільш корисною, але вона ставиться headsдо скаляра. Масив, мабуть, корисніший:

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

Зауважте, що це лише баш.

Рішення з використанням eval:

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

echo $last

Прочитавши відповіді вище, я написав сценарій оболонки Q&D (повинен працювати над sh та bash), щоб запустити g ++ на PGM.cpp, щоб створити виконуваний PGM зображення. Він передбачає, що останнім аргументом у командному рядку є ім'я файлу (.cpp є необов’язковим), а всі інші аргументи - це параметри.

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

Нижче буде встановлено LASTостанній аргумент без зміни поточного середовища:

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

Якщо інші аргументи більше не потрібні і можуть бути зміщені, їх можна спростити до:

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

З причин портативності наступні:

shift $(($#-1));

можна замінити на:

shift `expr $# - 1`

Замінюючи також $()зворотними котируваннями, ми отримуємо:

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

echo $argv[$#argv]

Тепер мені просто потрібно додати текст, оскільки моя відповідь була надто короткою для публікації. Мені потрібно додати більше тексту для редагування.

Це частина моєї функції копіювання:

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

Щоб використовувати в сценаріях, виконайте це:

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

Пояснення (найперше вкладене):

1. $(echo '$'"$#")повертає, $[nr]де [nr]кількість параметрів. Наприклад, рядок $123(нерозгорнута).
2. echo $123 повертає значення 123-го параметра при оцінці.
3. evalпросто розширюється $123до значення параметра, наприклад last_arg. Це трактується як рядок і повертається.

Працює з Bash станом на середину 2015 року.

#! /bin/sh

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

echo $last

Спробуйте описати нижче сценарій, щоб знайти останній аргумент

 # 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

Вихід:

 # ./arguments.sh
 No Arguments supplied

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

Дякую.

Існує набагато більш стислий спосіб зробити це. Аргументи до bash-скрипту можна перенести в масив, що робить роботу з елементами набагато простішою. Сценарій нижче завжди буде друкувати останній аргумент, переданий до сценарію.

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

Вибірка зразка

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

Використання розширення параметрів (видалення відповідного початку):

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

Це також легко отримати все до останнього:

prelast=${args% *}

Для повернення останнього аргументу останньо використаної команди використовуйте спеціальний параметр:

$_

У цьому випадку він буде працювати, якщо він буде використаний у сценарії до виклику іншої команди.

Просто використовуйте !$.

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