किसी फ़ंक्शन के अंदर कॉल करने वाले के कमांड लाइन तर्क तक कैसे पहुंचें?

Question

मैं एक फ़ंक्शन को बैश में लिखने का प्रयास कर रहा हूं जो स्क्रिप्ट कमांड लाइन के तर्कों तक पहुंच जाएगा, लेकिन उन्हें फ़ंक्शन के लिए स्थिति संबंधी तर्कों के साथ बदल दिया जाता है। क्या फ़ंक्शन के लिए कमांड लाइन के तर्कों को एक्सेस करने का कोई तरीका है अगर वे स्पष्ट रूप से पारित नहीं हुए हैं?

# Demo function
function stuff {
  echo $0 $*
}

# Echo's the name of the script, but no command line arguments
stuff

# Echo's everything I want, but trying to avoid
stuff $*

Comments

मैं एक तरह से भ्रमित हूं, आप चाहते हैं कि उन्हें पास करने के साथ आर्ग्स क्या हो?

— रवि व्यास

हां, यह है कि फ़ंक्शन के अंदर से कमांड लाइन के तर्कों को कार्यात्मक तर्कों के रूप में पारित किए बिना प्राप्त किया जाए। यह एक त्रुटि हैंडलिंग स्थिति के साथ करना है जिसमें मैं कमांड लाइन तर्कों के आधार पर त्रुटि हैंडलिंग करना चाहता हूं जो फ़ंक्शन में दिए गए तर्कों से स्वतंत्र रूप से जुड़ा हुआ है।

— डॉनगर

FYI करें, $*अत्यंत गाड़ी है - यह बदल देंगे ./yourScript "first argument" "second argument"करने के लिए ./yourscript "first" "argument" "second" "argument", परिवर्तन या ./yourscript '*.txt'की तरह कुछ करने के लिए ./yourscript one.txt two.txtउद्धरण के बावजूद।

— चार्ल्स डफी

Answer 1

बाश रेफ मैनुअल का मेरा पढ़ना कहता है कि यह सामान BASH_ARGV में कैप्चर किया गया है, हालांकि यह "स्टैक" के बारे में बहुत कुछ बताता है।

#!/bin/bash

function argv {
    for a in ${BASH_ARGV[*]} ; do
      echo -n "$a "
    done
    echo
}

function f {
    echo f $1 $2 $3
    echo -n f ; argv
}

function g {
    echo g $1 $2 $3
    echo -n g; argv
    f
}

f boo bar baz
g goo gar gaz

F.sh में सहेजें

$ ./f.sh arg0 arg1 arg2
f boo bar baz
farg2 arg1 arg0 
g goo gar gaz
garg2 arg1 arg0 
f
farg2 arg1 arg0 

Comments

ध्यान दें कि इस तरह सरणी को कमांड लाइन से रिवर्स ऑर्डर में होने का कारण बनता है।

— एंड्रयू बैकर

Answer 2

यदि आप अपने तर्क C शैली (तर्कों की संख्या + तर्कों की संख्या) चाहते हैं, तो आप उपयोग कर सकते हैं $@और $#।

$#आपको तर्कों की संख्या देता है।
$@आप सभी को तर्क देता है। आप इसे एक सरणी में बदल सकते हैं args=("$@")।

उदाहरण के लिए:

args=("$@")
echo $# arguments passed
echo ${args[0]} ${args[1]} ${args[2]}

ध्यान दें कि यहां ${args[0]}वास्तव में 1 तर्क है और आपकी स्क्रिप्ट का नाम नहीं है।

Comments

यह प्रश्न को संबोधित नहीं करता है - यह कमांड-लाइन तर्कों को शेल फ़ंक्शन के साथ पारित करने के बारे में पूछ रहा है।

— कैस्केबेल

@ जेफ्रोमी, वास्तव में, यह पूरी तरह से सवाल का जवाब देता है। आप argsकिसी फ़ंक्शन के अंदर से ऐरे का उपयोग कर सकते हैं , यदि आप इसे पहले से बताए अनुसार शुरू करते हैं।

— vadipp

मुझे यह बहुत साफ लगता है कि आर्गन पर चलने से।

— फेलिक्स गगनोन-ग्रेनियर

यह सरल और आसान है। बहुत बढ़िया जवाब। आपने इसे 7 साल पहले पोस्ट किया था, इसलिए भविष्य से नमस्कार: जुलाई 2017

— SDSolar

और भी बेहतर जैसे उद्धृत किया जाएगा echo "${args[0]} ${args[1]} ${args[2]}", या तर्क फ़ाइल नाम के विस्तार के अधीन हैं।

— बेंजामिन डब्ल्यू।

Answer 3

#!/usr/bin/env bash

echo name of script is $0
echo first argument is $1
echo second argument is $2
echo seventeenth argument is $17
echo number of arguments is $#

संपादित करें: कृपया प्रश्न पर मेरी टिप्पणी देखें

Answer 4

रवि की टिप्पणी अनिवार्य रूप से उत्तर है। कार्य अपने स्वयं के तर्क लेते हैं। यदि आप चाहते हैं कि वे कमांड-लाइन तर्कों के समान हों, तो आपको उन्हें पास करना होगा। अन्यथा, आप स्पष्ट रूप से तर्कों के बिना एक फ़ंक्शन कह रहे हैं।

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

my_function() {
    echo "stored arguments:"
    for arg in "${commandline_args[@]}"; do
        echo "    $arg"
    done
}

commandline_args=("$@")

my_function

आप के माध्यम से कमांड लाइन तर्क का उपयोग करने के लिए है commandline_argsचर, नहीं $@, $1, $2, आदि, लेकिन वे उपलब्ध हैं। मैं सीधे किसी भी तरह से अनभिज्ञ हूँ तर्क सरणी में असाइन करने के लिए, लेकिन अगर कोई जानता है तो कृपया मुझे बताएं!

इसके अलावा, जिस तरह से मैंने प्रयोग किया है और उद्धृत किया है, उस पर ध्यान दें $@- यह है कि आप कैसे विशेष वर्ण (व्हाट्सएप) सुनिश्चित करते हैं कि कहीं गड़बड़ न हो जाए।

Answer 5

# Save the script arguments
SCRIPT_NAME=$0
ARG_1=$1
ARGS_ALL=$*

function stuff {
  # use script args via the variables you saved
  # or the function args via $
  echo $0 $*
} 


# Call the function with arguments
stuff 1 2 3 4

Answer 6

कोई इसे इस तरह भी कर सकता है

#!/bin/bash
# script_name function_test.sh
function argument(){
for i in $@;do
    echo $i
done;
}
argument $@

अब अपनी स्क्रिप्ट को कॉल करें

./function_test.sh argument1 argument2

Comments

function print() {दो अलग-अलग फ़ंक्शन घोषणा रूपों के बीच एक समामेलन है - function print {जो कि विरासत ksh वाक्यविन्यास है जो bash पूर्व POSIX (जो कहना है, 1991 से पूर्व) के साथ बैकवर्ड संगतता के लिए समर्थन करता है, और print() {, जो POSIX- मानकीकृत है। अन्य गोले के साथ व्यापक संगतता के लिए एक या दूसरे का उपयोग करने पर विचार करें; यह भी देखें wiki.bash-hackers.org/scripting/obsolete

— चार्ल्स डफी

Answer 7

आप उनके माध्यम से पुनरावृत्ति करने के लिए शिफ्ट कीवर्ड (ऑपरेटर?) का उपयोग कर सकते हैं। उदाहरण:

#!/bin/bash
function print()
{
    while [ $# -gt 0 ]
    do
        echo $1;
        shift 1;
    done
}
print $*;

Comments

function print() {दो अलग-अलग फ़ंक्शन घोषणा रूपों के बीच एक समामेलन है - function print {जो कि विरासत ksh वाक्यविन्यास है जो bash पूर्व POSIX (जो कहना है, 1991 से पूर्व) के साथ बैकवर्ड संगतता के लिए समर्थन करता है, और print() {, जो POSIX- मानकीकृत है। अन्य गोले के साथ व्यापक संगतता के लिए एक या दूसरे का उपयोग करने पर विचार करें; यह भी देखें wiki.bash-hackers.org/scripting/obsolete

— चार्ल्स डफी

Answer 8

मेरा समाधान:

एक फ़ंक्शन स्क्रिप्ट बनाएं, जो किसी भी तरह के तर्क को पारित किए बिना अन्य सभी कार्यों से पहले कहा जाता है, जैसे:

! / Bin / bash

समारोह init () {ORIGOPT = "- $ @ -"}

Afer कि, आप init को कॉल कर सकते हैं और आवश्यकता के अनुसार ORIGOPT var का उपयोग कर सकते हैं, प्लस के रूप में, मैं हमेशा एक नया var असाइन करता हूं और ORIGOPT की सामग्री को अपने नए कार्यों में कॉपी करता हूं, इस तरह से आप खुद को आश्वस्त रख सकते हैं कि कोई भी आपको छूने नहीं जा रहा है या नहीं। बदल दें।

मैंने रिक्त स्थान और डैश जोड़े, इसे 'सीड-ई' के साथ पार्स करना आसान बना दिया, बैश भी इसे संदर्भ के रूप में पारित नहीं करेगा और ORIGOPT को विकसित करेगा क्योंकि फ़ंक्शन को अधिक तर्कों के साथ कहा जाता है।