Son argümanın kabuk betiğine geçirilmesi

$1ilk argüman.
$@hepsi.

Kabuk betiğine geçirilen son argümanı nasıl bulabilirim?

Bu biraz hack:

for last; do true; done
echo $last

Bu da oldukça taşınabilir (yine bash, ksh ve sh ile çalışmalı) ve güzel olabilecek argümanları değiştirmiyor.

Ne fordöngü yapacağını söylemezseniz, bağımsız değişkenler üzerinde dolaylı olarak döngü yapan ve döngü değişkenleri için kapsam bulunmadığı gerçeğini kullanır: ayarlandıkları son değeri korurlar.

Bu yalnızca 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

Boşluk, varsayılan değer olarak yorumlanmaması için gereklidir .

Bunun sadece bash olduğunu unutmayın.

Bash 3.0 veya üstü için en basit cevap

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

Bu kadar.

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

Çıktı:

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

Endekslemeyi aşağıdakilerle birlikte kullanın:

echo ${@:${#@}} 

Bunun sadece bash olduğunu unutmayın.

Aşağıdakiler sizin için çalışacaktır. @ Argüman dizisi içindir. : anlamına gelir. $ #, argüman dizisinin uzunluğudur. Sonuç, son öğedir:

${@:$#} 

Misal:

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

Bunun sadece bash olduğunu unutmayın.

Son argümanı öncekilerden ayırmak için bunu buldum. Bazı cevaplar son argümanı alırken, diğer tüm argümanlara da ihtiyacınız varsa çok fazla yardımcı olmazlar. Bu çok daha iyi çalışır:

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

Bunun sadece bash olduğunu unutmayın.

Bu, POSIX uyumlu tüm kabuklarda çalışır:

eval last=\${$#}

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

İşte benim çözüm:

• oldukça taşınabilir (tüm POSIX sh, bash, ksh, zsh) çalışmalı
• orijinal bağımsız değişkenleri kaydırmaz (bir kopyasını kaydırır).
• kötülük kullanmaz eval
• tüm liste boyunca yineleme yapmaz
• harici araçlar kullanmaz

Kod:

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

En eskiden daha yeni çözümlere:

Daha da eski en taşınabilir çözüm sh(boşluklar ve glob karakterlerle çalışır) (döngü yok, daha hızlı):

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

Bash 2.01 sürümünden beri

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

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

Ksh, zsh ve bash için:

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

Ve "sondan diğerine" için:

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

Bir tire işareti ile başlayan bağımsız değişkenlerle ilgili sorunları gidermek için printf kullanma -n ) .

Tüm mermiler ve daha yaşlılar için sh(boşluklar ve glob karakterlerle çalışır):

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

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

Veya bir lastvar ayarlamak istiyorsanız :

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

Ve "sondan diğerine" için:

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

Bash kullanıyorsanız = = 3.0

echo ${BASH_ARGV[0]}

Çünkü bash, bu yorum çok zarifti:

echo "${@:$#}"

Bir bonus olarak, bu da işe yarıyor zsh.

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

Bu, bağımsız değişkenleri eksi 1 bağımsız değişken sayısına göre kaydırır ve sonuncu olan ilk (ve yalnızca) kalan bağımsız değişkeni döndürür.

Sadece bashta test ettim, ama sh ve ksh'da da çalışmalı.

Bunu yıkıcı olmayan bir şekilde yapmak istiyorsanız, bir yol tüm argümanları bir işleve iletmek ve sonuncuyu döndürmektir:

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

Aslında umursamıyorsan diğer argümanlar tutma konusunda, bir işlevde buna ihtiyacı yoktur ama onlar zaten işlendikten sonra sürece diğer argümanlar tutmak istiyorum asla nerede bir durumun zor zamanlar düşünme var, bu durumda bunları sırayla işleme koymak için process / shift / process / shift / ...

Ben size, çünkü bunları tutmak istiyorsanız burada tahmin ediyorum değil sıralı yöntem izledi. Bu yöntem, "" döndüren bağımsız değişken olmayan durumu da ele alır. Açıklanan elseyan tümcesini ekleyerek bu davranışı kolayca ayarlayabilirsiniz .

Tcsh için:

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

Bu görev dışında taşınabilir bir çözüm olacağından eminim.

@ AgileZebra'nın cevabını (artı @ starfry'nin yorumu) en yararlı buldum, ancak headsbir skaler olarak ayarlandı . Bir dizi muhtemelen daha kullanışlıdır:

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

Bunun sadece bash olduğunu unutmayın.

Kullanarak bir çözüm eval:

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

echo $last

Yukarıdaki cevapları okuduktan sonra çalıştırılabilir görüntü PGM üretmek için PGM.cpp üzerinde g ++ çalıştırmak için bir Q & D kabuk betiği (sh ve bash üzerinde çalışması gerekir) yazdı. Komut satırındaki son bağımsız değişkenin dosya adı (.cpp isteğe bağlıdır) ve diğer tüm bağımsız değişkenlerin seçenek olduğunu varsayar.

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

Aşağıdakiler, LASTmevcut ortamı değiştirmeden son argüman olarak ayarlanacaktır :

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

Başka argümanlara artık ihtiyaç duyulmuyorsa ve kaydırılabilirse, basitleştirilebilir:

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

Taşınabilirlik nedeniyle aşağıdaki nedenlerle:

shift $(($#-1));

ile değiştirilebilir:

shift `expr $# - 1`

$()Backquotes ile de değiştiririz :

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

echo $argv[$#argv]

Şimdi sadece bazı metinler eklemem gerekiyor çünkü cevabım yayınlamak için çok kısa. Düzenlemek için daha fazla metin eklemem gerekiyor.

Bu benim kopyalama fonksiyonumun bir parçası:

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

Komut dosyalarında kullanmak için şunu yapın:

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

Açıklama (en içteki ilk):

1. $(echo '$'"$#")döner $[nr]nerede [nr]parametrelerin sayısıdır. Ör. Dize$123 (genişletilmemiş).
2. echo $123 değerlendirildiğinde 123 parametresinin değerini döndürür.
3. evalsadece $123parametrenin değerine genişler , örn last_arg. Bu bir dize olarak yorumlanır ve döndürülür.

Bash ile 2015 ortasından itibaren çalışıyor.

#! /bin/sh

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

echo $last

Son argümanı bulmak için aşağıdaki komut dosyasını deneyin

 # 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

Çıktı:

 # ./arguments.sh
 No Arguments supplied

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

Teşekkürler.

Bunu yapmanın çok daha özlü bir yolu var. Bir bash betiğinin bağımsız değişkenleri, bir dizi haline getirilebilir, bu da öğelerle başa çıkmayı çok daha basit hale getirir. Aşağıdaki komut dosyası her zaman bir komut dosyasına geçirilen son argümanı yazdırır.

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

Örnek çıktı

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

Parametre genişletmeyi kullanma (eşleşen başlangıcı sil):

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

Sondan önce hepsini almak da kolaydır:

prelast=${args% *}

En son kullanılan komutun son bağımsız değişkenini döndürmek için özel parametreyi kullanın:

$_

Bu durumda, başka bir komut çağrılmadan önce kod içinde kullanılırsa çalışır.

Sadece kullan !$.

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