Mendapatkan argumen terakhir diteruskan ke skrip shell

$1 adalah argumen pertama.
$@adalah mereka semua.

Bagaimana saya bisa menemukan argumen terakhir yang diteruskan ke skrip shell?

Ini sedikit hack:

for last; do true; done
echo $last

Yang ini juga cukup portabel (sekali lagi, harus bekerja dengan bash, ksh dan sh) dan tidak menggeser argumen, yang bisa bagus.

Ia menggunakan fakta yang forsecara implisit memotong argumen jika Anda tidak memberi tahu apa yang harus diulang, dan fakta bahwa untuk variabel loop tidak dibatasi: mereka menyimpan nilai terakhir yang ditetapkan.

Ini hanya untuk 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

Ruang tersebut diperlukan agar tidak bisa ditafsirkan sebagai nilai default .

Perhatikan bahwa ini hanya untuk bash.

Jawaban paling sederhana untuk bash 3.0 atau lebih tinggi adalah

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

Itu dia.

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

Output adalah:

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

Gunakan pengindeksan dikombinasikan dengan panjang:

echo ${@:${#@}} 

Perhatikan bahwa ini hanya untuk bash.

Berikut ini akan bekerja untuk Anda. @ Adalah untuk berbagai argumen. : berarti pada. $ # adalah panjang dari array argumen. Jadi hasilnya adalah elemen terakhir:

${@:$#} 

Contoh:

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

Perhatikan bahwa ini hanya untuk bash.

Menemukan ini ketika mencari untuk memisahkan argumen terakhir dari semua argumen sebelumnya. Sementara beberapa jawaban mendapatkan argumen terakhir, mereka tidak banyak membantu jika Anda membutuhkan semua argumen lainnya juga. Ini bekerja lebih baik:

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

Perhatikan bahwa ini hanya untuk bash.

Ini bekerja di semua shell yang kompatibel dengan POSIX:

eval last=\${$#}

Sumber: http://www.faqs.org/faqs/unix-faq/faq/part2/section-12.html

Inilah solusi tambang:

• cukup portabel (semua POSIX sh, bash, ksh, zsh) harus berfungsi
• tidak menggeser argumen asli (menggeser salinan).
• tidak menggunakan kejahatan eval
• tidak mengulangi seluruh daftar
• tidak menggunakan alat eksternal

Kode:

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

Dari solusi terlama hingga yang lebih baru:

Solusi paling portabel, bahkan lebih tua sh(bekerja dengan spasi dan karakter gumpal) (tanpa loop, lebih cepat):

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

Sejak versi 2.01 dari bash

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

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

Untuk ksh, zsh dan bash:

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

Dan untuk "selanjutnya":

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

Menggunakan printf untuk menyelesaikan masalah dengan argumen yang dimulai dengan tanda hubung (seperti -n ).

Untuk semua shell dan untuk yang lebih tua sh(bekerja dengan spasi dan karakter glob) adalah:

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

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

Atau, jika Anda ingin mengatur lastvar:

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

Dan untuk "selanjutnya":

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

Jika Anda menggunakan Bash> = 3.0

echo ${BASH_ARGV[0]}

Sebab bash, komentar ini menyarankan yang sangat elegan:

echo "${@:$#}"

Sebagai bonus, ini juga berfungsi di zsh.

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

Ini menggeser argumen dengan jumlah argumen minus 1, dan mengembalikan argumen pertama (dan hanya) yang tersisa, yang akan menjadi yang terakhir.

Saya hanya menguji dalam bash, tetapi harus bekerja di sh dan ksh juga.

Jika Anda ingin melakukannya dengan cara yang tidak merusak, salah satu caranya adalah meneruskan semua argumen ke suatu fungsi dan mengembalikan yang terakhir:

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

Jika Anda tidak peduli tentang mempertahankan argumen lain, Anda tidak memerlukannya dalam suatu fungsi tetapi saya kesulitan memikirkan situasi di mana Anda tidak akan pernah ingin menyimpan argumen lain kecuali mereka sudah diproses, dalam hal ini saya akan menggunakan proses / shift / proses / shift / ... metode pemrosesan secara berurutan.

Saya berasumsi di sini bahwa Anda ingin menyimpannya karena Anda belum mengikuti metode berurutan. Metode ini juga menangani kasus di mana tidak ada argumen, mengembalikan "". Anda dapat dengan mudah menyesuaikan perilaku itu dengan memasukkan elseklausul yang dikomentari .

Untuk tcsh:

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

Saya cukup yakin ini akan menjadi solusi portabel, kecuali untuk penugasan.

Saya menemukan jawaban @ AgileZebra (ditambah komentar @ starfry) yang paling berguna, tetapi disetel headsmenjadi skalar. Array mungkin lebih berguna:

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

Perhatikan bahwa ini hanya untuk bash.

Solusi menggunakan eval:

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

echo $last

Setelah membaca jawaban di atas saya menulis skrip shell Q & D (harus bekerja pada sh dan bash) untuk menjalankan g ++ di PGM.cpp untuk menghasilkan gambar PGM yang dapat dieksekusi. Ini mengasumsikan bahwa argumen terakhir pada baris perintah adalah nama file (.cpp adalah opsional) dan semua argumen lainnya adalah opsi.

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

LASTArgumen berikut akan diatur ke terakhir tanpa mengubah lingkungan saat ini:

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

Jika argumen lain tidak lagi diperlukan dan dapat digeser, dapat disederhanakan menjadi:

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

Untuk alasan portabilitas berikut:

shift $(($#-1));

dapat diganti dengan:

shift `expr $# - 1`

Mengganti juga $() dengan backquotes yang kami dapatkan:

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

echo $argv[$#argv]

Sekarang saya hanya perlu menambahkan beberapa teks karena jawaban saya terlalu pendek untuk dikirim. Saya perlu menambahkan lebih banyak teks untuk diedit.

Ini adalah bagian dari fungsi salin saya:

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

Untuk digunakan dalam skrip, lakukan ini:

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

Penjelasan (paling bersarang terlebih dahulu):

1. $(echo '$'"$#")mengembalikan di $[nr]mana [nr]jumlah parameter. Misalnya string $123(tidak diperluas).
2. echo $123 mengembalikan nilai parameter 123, ketika dievaluasi.
3. evalhanya memperluas $123ke nilai parameter, mis last_arg. Ini ditafsirkan sebagai string dan dikembalikan.

Bekerja dengan Bash pada pertengahan 2015.

#! /bin/sh

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

echo $last

Coba skrip di bawah ini untuk menemukan argumen terakhir

 # 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

Keluaran:

 # ./arguments.sh
 No Arguments supplied

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

Terima kasih.

Ada cara yang jauh lebih ringkas untuk melakukan ini. Argumen untuk skrip bash dapat dibawa ke dalam array, yang membuat berurusan dengan elemen lebih sederhana. Skrip di bawah ini akan selalu mencetak argumen terakhir yang dilewatkan ke skrip.

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

Output sampel

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

Menggunakan ekspansi parameter (hapus awal yang cocok):

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

Juga mudah untuk mendapatkan semua sebelum yang terakhir:

prelast=${args% *}

Untuk mengembalikan argumen terakhir dari perintah yang terakhir digunakan, gunakan parameter khusus:

$_

Dalam hal ini, ini akan berfungsi jika digunakan dalam skrip sebelum perintah lain dipanggil.

Gunakan saja !$.

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