अंतिम तर्क को शेल स्क्रिप्ट में पास करना

272

$1 पहला तर्क है।
$@उन सभी को है।

शेल स्क्रिप्ट को अंतिम तर्क कैसे दिया जा सकता है?

shell  arguments 
— थॉमस
स्रोत
मैं बैश का उपयोग कर रहा था, लेकिन अधिक पोर्टेबल समाधान बेहतर है।
— थॉमस
7
— इंशाअल्लाह
10
उपयोग $ {!} का भी उपयोग कर सकते हैं
— Prateek Joshi
11
केवल बैश के लिए , केविन लिटिल का जवाब सरल का प्रस्ताव है ${!#}। इसका उपयोग करके परीक्षण करें bash -c 'echo ${!#}' arg1 arg2 arg3। के लिए पार्टी , ksh और zsh , डेनिस विलियमसन के जवाब का प्रस्ताव ${@: -1}। इसके अलावा ${*: -1}भी इस्तेमाल किया जा सकता है। इसका उपयोग करके परीक्षण करें zsh -c 'echo ${*: -1}' arg1 arg2 arg3। लेकिन यह डैश , csh और tsh के लिए काम नहीं करता है ।
— ओलिबर
2
${!#}, इसके विपरीत ${@: -1}, पैरामीटर विस्तार के साथ भी काम करता है। आप इसके साथ परीक्षण कर सकते हैं bash -c 'echo ${!#%.*}' arg1.out arg2.out arg3.out।
— आर्क स्टैंटन

जवाबों:

177

यह एक हैक का एक सा है:

for last; do true; done
echo $last

यह भी बहुत पोर्टेबल है (फिर से, बैश, ksh और श के साथ काम करना चाहिए) और यह तर्कों को स्थानांतरित नहीं करता है, जो अच्छा हो सकता है।

यह इस तथ्य का उपयोग करता है कि forयदि आप यह नहीं बताते हैं कि लूप ओवर क्या है, और यह तथ्य कि लूप वेरिएबल के लिए स्कूप नहीं किया गया है: वे अंतिम मान रखते हैं जो उन्होंने सेट किया था।

— लॉरेंस गोंसाल्वेस
स्रोत
10
@ माइकल, मुझे लगता है कि आप बृहदान्त्र और कॉमा नहीं थे;)
— पवेल नाडोलस्की
2
— रफ़लविंड
4
एक पुराने सोलारिस के साथ, पुराने बोर्न शेल (पॉसिक्स नहीं) के साथ, मुझे "अंतिम रूप से" $ @ "में लिखना है; सच करो; किया"
— mcoolive
8
अधिक पोर्टेबल होने के साथ @mcoolive @LaurenceGolsalves for last in "$@"; do :; doneभी इरादे को बहुत स्पष्ट करता है।
— एड्रियन गुंटर
1
@mcoolive: यह 1979 से यूनिक्स v7 बॉर्न शेल में भी काम करता है। यदि आप v7 sh और POSIX sh दोनों पर चलते हैं तो आपको अधिक पोर्टेबल नहीं मिल सकता है
— डोमिनिक R
291

यह केवल बैश है:

echo "${@: -1}"
— अगली सूचना तक रोक दिया गया।
स्रोत
43
उन लोगों के लिए (जैसे मैं) सोच रहा था कि अंतरिक्ष की आवश्यकता क्यों है, आदमी बैश इस बारे में कहने के लिए है:> ध्यान दें कि एक नकारात्मक ऑफसेट को बृहदान्त्र से अलग किया जाना चाहिए: - विस्तार के साथ भ्रमित होने से बचने के लिए कम से कम एक स्थान।
— foo
1
मैं इस का उपयोग कर रहा हूँ और यह केवल विंडोज़ में MSYS2 बैश में टूट जाता है। विचित्र।
— स्टीवन लू
2
नोट: यह उत्तर सभी बैश सरणियों के लिए काम करता है , ${@:$#}जिसके विपरीत केवल काम करता है $@। यदि आप $@एक नई सरणी के साथ कॉपी करना चाहते हैं arr=("$@"), ${arr[@]:$#}तो अपरिभाषित होगा। इसका कारण यह है कि $@एक 0 तत्व है जो "$@"विस्तार में शामिल नहीं है ।
— श्री लामा
@ Mr.Llama: बचने के लिए एक और जगह $#है, जब बैश में, के बाद से सरणियों से पुनरावृत्ति होती है, सरणियाँ विरल होती हैं, और $#सरणी में तत्वों की संख्या को दिखाएगी, जो कि आवश्यक रूप से अंतिम तत्व (या तत्व + 1) की ओर इशारा नहीं करता है। दूसरे शब्दों में, किसी को सूचकांकों पर नहीं करना चाहिए या for ((i = 0; i++; i < $#)); do something "${array[$i]}"; doneइसके बजाय करना चाहिए for element in "${array[@]}"; do something "$element"; done: for index in "${!array[@]}"; do something "$index" "${array[$index]}"; doneयदि आपको सूचकांकों के मूल्यों के साथ कुछ करने की आवश्यकता है।
— अगली सूचना तक रोक दिया गया।
80 
$ set quick brown fox jumps

$ echo ${*: -1:1} # last argument
jumps

$ echo ${*: -1} # or simply
jumps

$ echo ${*: -2:1} # next to last
fox

स्थान आवश्यक है ताकि यह डिफ़ॉल्ट मान के रूप में व्याख्या न करे ।

ध्यान दें कि यह केवल बैश है।

— स्टीवन पेनी
स्रोत
9
सबसे अच्छा जवाब, क्योंकि इसमें अगला से आखिरी arg भी शामिल है। धन्यवाद!
— e40
1
स्टीवन, मुझे नहीं पता कि आपने पेनल्टी बॉक्स में उतरने के लिए क्या किया, लेकिन मैं यहां आपके काम से प्यार कर रहा हूं।
— ब्रूनो ब्रोंस्की
4
हाँ। केवल सबसे अच्छा। सभी लेकिन आदेश और अंतिम तर्क ${@: 1:$#-1}
— दीनो फू
1
@DynoFu इसके लिए धन्यवाद, आपने मेरे अगले सवाल का जवाब दिया। तो एक बदलाव की तरह लग सकता है: echo ${@: -1} ${@: 1:$#-1}जहां अंतिम पहले बन जाता है और बाकी नीचे गिर जाता है
— माइक
73

बैश 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
— केविन लिटिल
स्रोत
1
$BASH_ARGVएक बश फ़ंक्शन के अंदर काम नहीं करता है (जब तक कि मैं कुछ गलत नहीं कर रहा हूं)।
— बजे बिग मैकलेरज्यूज
1
Bash_ARGV में तर्क होते हैं जब bash को (या किसी फ़ंक्शन को) स्थितीय तर्कों की वर्तमान सूची नहीं थी।
— इसहाक
यह भी नोट करें कि BASH_ARGVआपको क्या मिलेगा वह मूल्य है जो कि अंतिम आर्ग दिया गया था, केवल "अंतिम मान" के बजाय। उदाहरण के लिए !: यदि आप एक एकल तर्क प्रदान करते हैं, तो आप शिफ्ट कहते हैं, ${@:$#}कुछ भी उत्पन्न नहीं करेगा (क्योंकि आपने एक और केवल तर्क को स्थानांतरित कर दिया है!), हालांकि, BASH_ARGVअभी भी आपको वह (पूर्व में) अंतिम तर्क देगा।
— स्टीवन लू
29

निम्नलिखित आपके लिए काम करेंगे। @ दलील सरणी के लिए है। : का मतलब है। $ # तर्क की सरणी की लंबाई है। तो परिणाम अंतिम तत्व है:

${@:$#}

उदाहरण:

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

ध्यान दें कि यह केवल बैश है।

— तहसीन तुर्कोज़
स्रोत
जबकि उदाहरण एक फ़ंक्शन के लिए है, स्क्रिप्ट भी उसी तरह काम करती हैं। मुझे यह उत्तर पसंद है क्योंकि यह स्पष्ट और संक्षिप्त है।
— योना ब्रौन
1
और यह हैक नहीं है। यह भाषा की स्पष्ट विशेषताओं का उपयोग करता है, साइड इफेक्ट्स या विशेष qwerks का नहीं। यह स्वीकृत उत्तर होना चाहिए।
— म्यूजिकिन
25

पिछले सभी से अंतिम तर्क को अलग करने की तलाश में यह मिला। जब तक कि कुछ उत्तरों को अंतिम तर्क नहीं मिल जाता है, तब तक वे बहुत मदद नहीं करते हैं यदि आपको अन्य सभी args की आवश्यकता होती है। यह बेहतर काम करता है:

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

ध्यान दें कि यह केवल बैश है।

— AgileZebra
स्रोत
3
स्टीवन पैसा का जवाब उपयोग: थोड़ा अच्छे है ${@: -1}के लिए पिछले और ${@: -2:1}के लिए दूसरा पिछले (और इतने पर ...)। उदाहरण: bash -c 'echo ${@: -1}' prog 0 1 2 3 4 5 6प्रिंट 6। इस वर्तमान एग्जेलबेबर के दृष्टिकोण के साथ रहने के ${@:$#-1:1}लिए, दूसरा अंतिम प्राप्त करने के लिए उपयोग करें । उदाहरण: bash -c 'echo ${@:$#-1:1}' prog 0 1 2 3 4 5 6प्रिंट 5। (और तीसरा अंतिम और इतने पर ${@:$#-2:1}पाने के लिए ...)
— ओलिवर
4
AgileZebra का उत्तर सभी प्राप्त करने का एक तरीका प्रदान करता है, लेकिन अंतिम तर्क तो मैं नहीं कहूंगा कि स्टीवन का उत्तर इसे उलट देता है। हालांकि, $((...))1 को घटाने के लिए उपयोग करने का कोई कारण नहीं लगता है , आप बस उपयोग कर सकते हैं ${@:1:$# - 1}।
— dkasak 20
धन्यवाद dakasak आपके सरलीकरण को दर्शाने के लिए अद्यतन किया गया।
— एजिलेज़ेब्रा
22

यह सभी POSIX- संगत गोले में काम करता है:

eval last=\${$#}

स्रोत: http://www.faqs.org/faqs/unix-faq/faq/part2/section-12.html

— poiuz
स्रोत
2
इस टिप्पणी को पुराने समान उत्तर से संलग्न देखें ।
— अगली सूचना तक रोक दिया गया।
1
सबसे सरल पोर्टेबल समाधान जो मैं यहां देख रहा हूं। यह कोई सुरक्षा समस्या नहीं है, @ डेनिसविलियम्सन, उद्धृत करते हुए अनुभवजन्य रूप से सही किया जाता है, जब तक कि $#एक मनमाना स्ट्रिंग स्थापित करने का कोई तरीका नहीं है (मुझे ऐसा नहीं लगता)। eval last=\"\${$#}\"यह भी काम करता है और स्पष्ट रूप से सही है। यह न देखें कि उद्धरणों की आवश्यकता क्यों नहीं है।
— पलक
1
के लिए पार्टी , zsh , पानी का छींटा और ksh eval last=\"\${$#}\" ठीक है। लेकिन csh और tsh के उपयोग के लिए eval set last=\"\${$#}\"। इस उदाहरण देखें: tcsh -c 'eval set last=\"\${$#}\"; echo "$last"' arg1 arg2 arg3।
— ओलिबर
12

यहाँ मेरा समाधान है:

  • सुंदर पोर्टेबल (सभी POSIX sh, bash, ksh, zsh) को काम करना चाहिए
  • मूल तर्कों को शिफ्ट नहीं करता है (एक कॉपी को स्थानांतरित करता है)।
  • बुराई का उपयोग नहीं करता है eval
  • पूरी सूची के माध्यम से पुनरावृति नहीं करता है
  • बाहरी उपकरणों का उपयोग नहीं करता है

कोड:

ntharg() {
    shift $1
    printf '%s\n' "$1"
}
LAST_ARG=`ntharg $# "$@"`
— मिशैल harajer
स्रोत
1
शानदार जवाब - छोटा, पोर्टेबल, सुरक्षित। धन्यवाद!
— जाॅन लालिंस्की
2
यह एक महान विचार है, लेकिन मेरे पास कुछ सुझाव हैं: सबसे पहले उद्धरण को चारों ओर जोड़ा जाना चाहिए "$1"और "$#"(इस महान उत्तर को देखें unix.stackexchange.com/a/171347 )। दूसरे, echoदुख की बात है गैर-पोर्टेबल (विशेषकर के लिए -n), इसलिए printf '%s\n' "$1"इसके बजाय उपयोग किया जाना चाहिए।
— जोकी
धन्यवाद @ जोकी मैंने कई अलग-अलग यूनिक्स सिस्टम के साथ काम किया है और मुझे भरोसा echo -nभी नहीं होगा , हालांकि मैं किसी भी पॉसिक्स सिस्टम पर अवगत नहीं हूं जहां echo "$1"असफल हो जाएगा। किसी भी तरह, printfवास्तव में अधिक अनुमानित है - अद्यतन।
— मिशैल Janrajer
@ माइकेलजर उस मामले पर विचार करते हैं जहां "$ 1" "-n" या "-" है, इसलिए उदाहरण के लिए ntharg 1 -nया ntharg 1 --विभिन्न प्रणालियों पर अलग-अलग परिणाम प्राप्त कर सकते हैं। अब आपके पास जो कोड है वह सुरक्षित है!
— जॉकी
10

सबसे पुराने से नए समाधान:

सबसे पोर्टेबल समाधान, यहां तक ​​कि पुराने sh(रिक्त स्थान और ग्लोब वर्णों के साथ काम करता है) (कोई लूप, तेज नहीं):

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

संस्करण 2 के बाद से

$ 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

किसी डैश के साथ शुरू होने वाले तर्कों के साथ किसी भी समस्या को हल करने के लिए प्रिंटफ़ का उपयोग करना (जैसे) -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
— इसहाक
स्रोत
3 
shift `expr $# - 1`
echo "$1"

यह तर्कों को माइनस 1 की संख्या से बदल देता है, और पहले (और केवल) शेष तर्क देता है, जो अंतिम होगा।

मैंने केवल बैश में परीक्षण किया है, लेकिन इसे श और क्श में भी काम करना चाहिए।

— लॉरेंस गोंसाल्वेस
स्रोत
11
shift $(($# - 1))- बाहरी उपयोगिता की जरूरत नहीं। बाश, ksh, zsh और पानी का छींटा में काम करता है।
— अगली सूचना तक रोक दिया गया।
@ डेनिस: अच्छा! मैं $((...))वाक्य रचना के बारे में नहीं जानता था ।
— लोरेंस गोंसाल्वेस
आप (जैसे के लिए ) printf '%s\n' "$1"से अनपेक्षित व्यवहार से बचने के लिए उपयोग करना चाहते हैं । echo-n
— जोकी
2

यदि आप इसे गैर-विनाशकारी तरीके से करना चाहते हैं, तो एक तरीका यह है कि आप किसी समारोह में सभी तर्कों को पास करें और अंतिम विवरण लौटाएं:

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

यदि आप वास्तव में परवाह नहीं करते हैं में अन्य तर्कों को रखने के बारे , तो आपको किसी फ़ंक्शन में इसकी आवश्यकता नहीं है, लेकिन मेरे पास एक ऐसी स्थिति के बारे में सोचने का कठिन समय है जहां आप कभी भी अन्य तर्कों को रखना नहीं चाहेंगे, जब तक कि वे पहले से ही संसाधित न हों, जिस स्थिति में मैं प्रक्रिया / शिफ्ट / प्रोसेस / शिफ्ट / ... का उपयोग करता हूँ, क्रमिक रूप से उन्हें संसाधित करने की विधि।

मैं यहाँ मान रहा हूँ कि आप उन्हें रखना चाहते हैं क्योंकि आपने क्रमिक विधि का पालन नहीं किया है। यह विधि उस मामले को भी संभालती है जहां कोई तर्क नहीं है, "" लौटना। आप टिप्पणी-किए गए elseखंड को सम्मिलित करके आसानी से उस व्यवहार को समायोजित कर सकते हैं ।

— paxdiablo
स्रोत
2

Tsh के लिए:

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

मुझे पूरा यकीन है कि यह एक पोर्टेबल समाधान होगा, असाइनमेंट को छोड़कर।

— Perfect64
स्रोत
मुझे पता है कि आपने इसे हमेशा के लिए पोस्ट किया था, लेकिन यह समाधान बहुत अच्छा है - खुशी है कि किसी ने एक tcsh पोस्ट किया है!
— user3295674
2

मैंने @ एजिलेज़ेब्रा का जवाब (प्लस @ स्टारफ्री की टिप्पणी) को सबसे उपयोगी पाया, लेकिन यह headsएक स्केलर पर सेट है। एक सरणी शायद अधिक उपयोगी है:

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

ध्यान दें कि यह केवल बैश है।

— EndlosSchleife
स्रोत
आप सिर को एक सरणी में कैसे बदलेंगे?
— स्टीफन
मैंने पहले ही कोष्ठकों को जोड़कर किया था, उदाहरण के echo "${heads[-1]}"लिए अंतिम तत्व को प्रिंट करता है heads। या क्या मैं कुछ न कुछ भूल रहा हूं?
— एंडलोस स्क्लेफ़ाइफ़
1

एक समाधान का उपयोग कर eval:

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

echo $last
— मिकेल एस
स्रोत
7
अप्रत्यक्ष संदर्भ के लिए eval overkill है, बुरा अभ्यास का उल्लेख नहीं करने के लिए, और एक बड़ी सुरक्षा चिंता (मूल्य गूंज में या $ बाहर बोली नहीं है) () किसी भी संस्करण के लिए अप्रत्यक्ष संदर्भों के लिए बैश में एक अंतर्निहित वाक्यविन्यास है: !इसलिए last="${!#}"उसी का उपयोग करेगा दृष्टिकोण (अप्रत्यक्ष संदर्भ $ #) बहुत सुरक्षित, कॉम्पैक्ट,
— बिलियन, सेंस
उसी में प्रदर्शन करने के लिए एक क्लीनर तरीका देखें अन्य उत्तर ।
— पलक
@MestreLion उद्धरण RHS पर की आवश्यकता नहीं है =।
— टॉम हेल
1
@TomHale: के विशेष मामले के लिए सच है ${!#}, लेकिन सामान्य रूप से नहीं: उद्धरण अभी भी आवश्यक हैं यदि सामग्री में शाब्दिक व्हाट्सएप शामिल है, जैसे कि last='two words'। केवल$() सामग्री की परवाह किए बिना व्हाट्सएप-सुरक्षित है।
— मेस्ट्रेलियन
1

ऊपर दिए गए उत्तरों को पढ़ने के बाद, मैंने निष्पादन योग्य छवि PGM का उत्पादन करने के लिए PGM.cpp पर g ++ चलाने के लिए Q & D शेल स्क्रिप्ट (sh और bash पर काम करना चाहिए) लिखा। यह मानता है कि कमांड लाइन पर अंतिम तर्क फ़ाइल नाम (.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
— डेविड ई।
स्रोत
1

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
— पावेल नाडोलस्की
स्रोत
1 
echo $argv[$#argv]

अब मुझे केवल कुछ पाठ जोड़ने की आवश्यकता है क्योंकि मेरा उत्तर पोस्ट करने के लिए बहुत छोटा था। मुझे संपादित करने के लिए और पाठ जोड़ने की आवश्यकता है।

— frank1rizzo
स्रोत
यह किस शेल में काम करने के लिए माना जाता है? बैश नहीं। मछली नहीं है ( $argvलेकिन नहीं $#argv- $argv[(count $argv)]मछली में काम करता है)।
— बेनी चेर्नियाव्स्की-पास्किन
1

यह मेरी कॉपी फ़ंक्शन का हिस्सा है:

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

स्क्रिप्ट में उपयोग करने के लिए, यह करें:

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

स्पष्टीकरण (सबसे पहले नेस्टेड):

  1. $(echo '$'"$#")रिटर्न $[nr]जहां [nr]मापदंडों की संख्या है। जैसे कि स्ट्रिंग $123(unexpanded)।
  2. echo $123 मूल्यांकन किए जाने पर 123 वें पैरामीटर का मान लौटाता है।
  3. evalबस $123पैरामीटर के मूल्य में विस्तार करता है, जैसे last_arg। यह एक स्ट्रिंग के रूप में व्याख्या की गई है और वापस आ गई है।

2015 के मध्य तक बैश के साथ काम करता है।

— Esavier
स्रोत
यहां पहले से ही कई बार स्पष्ट दृष्टिकोण प्रस्तुत किया गया है, लेकिन यह एक व्याख्या है कि यह कैसे काम करता है। आगे सुधार किया जा सकता है, लेकिन अभी भी रखने के लायक है।
— पलक
0 
#! /bin/sh

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

echo $last
— क्रेग ट्रेडर
स्रोत
यह विफल हो जाएगा यदि कोई तर्क रिक्त स्ट्रिंग है, लेकिन 99.9% मामलों में काम करेगा।
— थॉमस
0

अंतिम तर्क खोजने के लिए नीचे दी गई स्क्रिप्ट का प्रयास करें

 # 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

धन्यवाद।

— रंजीथकुमार टी
स्रोत
मुझे संदेह है कि यह विफल रहेगा ।/arguments.sh "अंतिम मान"
— थॉमस
थॉमस की जाँच करने के लिए धन्यवाद, मैंने आपके जैसे # # ./arguments.sh "अंतिम मान" के रूप में स्क्रिप्ट का प्रदर्शन करने की कोशिश की है "अंतिम तर्क: मूल्य अब ठीक काम कर रहा है। # ./arguments.sh "डबल के साथ अंतिम मान चेक" अंतिम तर्क है: डबल
— रंजीथकुमार टी
समस्या यह है कि अंतिम तर्क 'अंतिम मूल्य' था, और मूल्य नहीं। त्रुटि तर्क युक्त स्थान के कारण होती है।
— थॉमस
0

ऐसा करने के लिए बहुत अधिक संक्षिप्त तरीका है। एक बैश स्क्रिप्ट के लिए तर्क एक सरणी में लाया जा सकता है, जो तत्वों के साथ बहुत सरल व्यवहार करता है। नीचे दी गई स्क्रिप्ट हमेशा एक स्क्रिप्ट में दिए गए अंतिम तर्क को प्रिंट करेगी।

  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
— tekbot
स्रोत
0

पैरामीटर विस्तार का उपयोग करना (शुरुआत से हटाएं):

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

अंतिम से पहले सभी प्राप्त करना भी आसान है:

prelast=${args% *}
— जुरिज
स्रोत
के संभावित (गरीब) नकल stackoverflow.com/a/37601842/1446229
— Xerz
यह केवल तभी काम करता है जब अंतिम तर्क में स्थान नहीं होता है।
— पलक
आपका तर्क विफल हो जाता है यदि अंतिम तर्क दोहरे उद्धरणों में संलग्न एक वाक्य है, जिसमें कहा गया है कि वाक्य एक तर्क माना जाता है।
— स्टीफन
0

सबसे हाल ही में प्रयुक्त कमांड के अंतिम तर्क को विशेष पैरामीटर का उपयोग करने के लिए:

$_

इस उदाहरण में यह काम करेगा अगर यह स्क्रिप्ट के भीतर प्रयोग किया जाता है इससे पहले कि एक और आदेश दिया गया है।

— थेन
स्रोत
यह वह नहीं है जो सवाल पूछ रहा है
— रेटनिकट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.