Получение последнего аргумента, переданного в сценарий оболочки

$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.

Самый простой ответ для 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 ${@:${#@}} 

Обратите внимание, что это только для bash.

Следующее будет работать для вас. @ Для массива аргументов. : означает в. $ # - длина массива аргументов. Итак, результатом является последний элемент:

${@:$#} 

Пример:

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

Обратите внимание, что это только для bash.

Нашел это, когда пытался отделить последний аргумент от всех предыдущих. Хотя некоторые ответы получают последний аргумент, они не сильно помогают, если вам нужны все остальные аргументы. Это работает намного лучше:

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

Обратите внимание, что это только для bash.

Это работает во всех 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

Или, если вы хотите установить lastпеременную:

$ 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=${@:${#@}}

Обратите внимание, что это только для bash.

Решение с использованием 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