एक बैश उर्फ ​​बनाओ जो एक पैरामीटर लेता है?

1270

मैं CShell का उपयोग करता था (csh), जो आपको एक पैरामीटर बनाने वाला उपनाम देता है। अंकन कुछ इस तरह था

alias junk="mv \\!* ~/.Trash"

बैश में, यह काम नहीं करता है। यह देखते हुए कि बैश में उपयोगी सुविधाओं की एक भीड़ है, मैं मानूंगा कि यह एक लागू किया गया है लेकिन मैं सोच रहा हूं कि कैसे।

bash  alias 
— हैलो
स्रोत
2
— जीवांश
2
सुनिश्चित करें कि आप आर्ग के चारों ओर उद्धरण का उपयोग करते हैं"$1"
— क्रिस्टोफ रूसो
यह सवाल एसओ के लिए ऑफ टॉपिक है। यह था UNIX.SE पर जवाब है, और जवाब है कि आप भी परेशान करने के लिए की जरूरत नहीं है यह है: "अगर आप उर्फ रहे थे, उदाहरण के लिए lsकरने के लिए ls -la, तो टाइपिंग ls foo barहैं वास्तव में अमल ls -la foo bar। कमांड लाइन पर"
— Dan Dascalescu
7
कि एक चर के बीच में एक चर interpolating के साथ मदद नहीं करेगा
— फ्रांज Sittampalam
1
यहाँ lil परीक्षण उर्फ ​​मैं इस alias test_args="echo PREFIX --$1-- SUFFIX"test_args ABCDPREFIX ---- SUFFIX ABCD
— गिरावट

जवाबों:

2122

बैश उर्फ ​​मापदंडों को सीधे स्वीकार नहीं करता है। आपको एक फंक्शन बनाना होगा।

aliasमापदंडों को स्वीकार नहीं करता है, लेकिन एक फ़ंक्शन को केवल एक उपनाम की तरह कहा जा सकता है। उदाहरण के लिए:

myfunction() {
    #do things with parameters like $1 such as
    mv "$1" "$1.bak"
    cp "$2" "$1"
}


myfunction old.conf new.conf #calls `myfunction`

वैसे, आपके .bashrcऔर अन्य फ़ाइलों में परिभाषित बैश फ़ंक्शन आपके शेल के भीतर कमांड के रूप में उपलब्ध हैं। उदाहरण के लिए, आप इस तरह के पहले फ़ंक्शन को कॉल कर सकते हैं

$ myfunction original.conf my.conf
— अरुण कुमार
स्रोत
48
क्या मुझे $1उद्धरणों में लपेटना चाहिए ?
— जुरगेन पॉल
263
आपको उपनाम भी घोषित करने की आवश्यकता नहीं है। बस फ़ंक्शन को परिभाषित करेगा।
— दिनागो
206
यदि आप किसी फ़ंक्शन में उपनाम बदल रहे हैं, तो sourceअपने .bashrc फ़ंक्शन को जोड़ दें, लेकिन यह पुराने उपनाम को अनलिअस नहीं करेगा। चूंकि उपनाम कार्यों की तुलना में उच्च मिसाल हैं, इसलिए यह उपनाम का उपयोग करने का प्रयास करेगा। आपको अपने शेल को या तो बंद करना होगा और फिर से खोलना होगा, या फिर कॉल करना होगा unalias <name>। शायद मैं किसी को बचा सकता हूँ 5 मिनट मैं बस बर्बाद।
— मार्टी नील
55
@MartinNeal: सन में मैंने जो एक समय की बचत की तरकीब सीखी, वह है बस एक exec bash: यह एक नया शेल शुरू करेगा, जिससे आप अपने कॉन्फिग को साफ-सुथरा पढ़ सकेंगे, जैसे कि आप बंद हो गए और फिर से खुल गए, लेकिन उस सत्र का वातावरण परिवर्तनशील है । इसके अलावा, निष्पादन के bashबिना निष्पादित करना तब उपयोगी हो सकता है जब आप एक स्टैक की तरह सोच को संभालना चाहते हैं।
— १६
21
@ मिच - हां, हमेशा उद्धरणों में बैश चर डालते हैं। उदा mv "$1" "$1.bak"। उद्धरण के बिना, यदि $ 1 "हैलो वर्ल्ड" था, तो आप mv hello world hello world.bakइसके बजाय निष्पादित करेंगे mv "hello world" "hello world.bak"।
— ओरियन एल्जेनिल
208

उपरोक्त उत्तर को परिष्कृत करते हुए, आप एलियासेस के लिए 1-लाइन सिंटैक्स प्राप्त कर सकते हैं, जो शेल या .bashrc फ़ाइलों में तदर्थ परिभाषाओं के लिए अधिक सुविधाजनक है:

bash$ myfunction() { mv "$1" "$1.bak" && cp -i "$2" "$1"; }

bash$ myfunction original.conf my.conf

दाएं-कोष्ठ को बंद करने से पहले अर्ध-बृहदान्त्र को मत भूलना। इसी तरह, वास्तविक प्रश्न के लिए:

csh% alias junk="mv \\!* ~/.Trash"

bash$ junk() { mv "$@" ~/.Trash/; }

या:

bash$ junk() { for item in "$@" ; do echo "Trashing: $item" ; mv "$item" ~/.Trash/; done; }
— माइक ग्लीसन
स्रोत
3
मैं इस उत्तर को पसंद करता हूं, क्योंकि यह तर्कों के सरणी के माध्यम से पुनरावृति दिखाता है जो $ 1 और $ 2 में आ सकते हैं, केवल विशेष मामले हैं, जो इस उत्तर में भी चित्रित किया गया है।
— फिलो विवरो
16
बदलें mv "$1" "$1.bak"; cp "$2" "$1" में mv "$1" "$1.bak" && cp "$2" "$1"करने के लिए अपने डेटा नहीं खो देते हैं जब mvमुसीबत में चलाता है (जैसे, फाइल सिस्टम पूर्ण)।
— हेनक लैंगवेल्ड
3
"दाएं-कोष्ठ के समापन से पहले अर्ध-बृहदान्त्र को मत भूलना।" कई बार यह! धन्यवाद :)
— कौशल मोदी
और पहले ब्रैकेट के बाद और आखिरी ब्रैकेट से पहले रिक्त स्थान की आवश्यकता होती है।
— ब्रायन चैपल
1
@HenkLangeveld हालांकि आपकी टिप्पणी पूरी तरह से सही है, यह दर्शाता है कि आप कुछ समय के लिए आस-पास रहे हैं - मुझे नहीं पता होगा कि मैंने आखिरी बार "डिवाइस पर कोई स्थान नहीं छोड़ा" त्रुटि ;-)। (मैं इसे नियमित रूप से उपयोग करता हूं, हालांकि जब मुझे रसोई काउंटर पर जगह नहीं मिलती है!) इन दिनों बहुत बार ऐसा नहीं होता है।
— पीटर -
124

सवाल बस गलत पूछा गया है। आप एक ऐसा उपनाम नहीं बनाते हैं जो पैरामीटर लेता है क्योंकि aliasसिर्फ उस चीज़ के लिए एक दूसरा नाम जोड़ता है जो पहले से मौजूद है। ओपी चाहता है कि functionकार्यक्षमता एक नया फ़ंक्शन बनाने के लिए है। आपको फ़ंक्शन को अन्य नाम देने की आवश्यकता नहीं है क्योंकि फ़ंक्शन में पहले से ही एक नाम है।

मुझे लगता है कि आप कुछ इस तरह चाहते हैं:

function trash() { mv "$@" ~/.Trash; }

बस! आप पैरामीटर $ 1, $ 2, $ 3, आदि का उपयोग कर सकते हैं, या बस उन सभी को $ @ से भर सकते हैं

— इवान लैंग्लिस
स्रोत
7
यह उत्तर कहता है यह सब। यदि मैं इस पृष्ठ के नीचे से पढ़ता, तो मैं कुछ समय बचा सकता था।
— जो
-1 एक उपनाम और एक फंक्शन समतुल्य नहीं हैं ...echo -e '#!/bin/bash\nshopt -s expand_aliases\nalias asrc='\''echo "${BASH_SOURCE[0]}"'\'' # note the '\''s\nfunction fsrc(){ echo "${BASH_SOURCE[0]}";}'>>file2&&echo -e '#!/bin/bash\n. file2\nalias rl='\''readlink -f'\''\nrl $(asrc)\nrl $(fsrc)'>>file1&&chmod +x file1&&./file1;rm -f file1 file2
— फजी लॉजिक
आपको वास्तव में $@रिक्त स्थान, आदि के साथ फ़ाइल नामों का समर्थन करने के लिए उद्धरण देना चाहिए
— टॉम हेल
यह एक सामान्य स्पष्टीकरण माना जाता था कि आपके पास अन्य उपनाम नहीं हैं, आप इसके बजाय एक फ़ंक्शन का उपयोग करते हैं। दिए गए फ़ंक्शन मूल उदाहरण का मुकाबला करने के लिए सिर्फ एक उदाहरण था। मुझे नहीं लगता कि व्यक्ति एक सामान्य उद्देश्य कचरा समारोह की तलाश में था। हालांकि, बेहतर कोड पेश करने के हित में, मैंने जवाब अपडेट कर दिया है।
— इवान लैंग्लोइस
1
@FuzzyLogic - मैंने आपकी टिप्पणी में कोड को अनपैक करने के लिए कुछ मिनट बिताए। कुछ कोड को एक टिप्पणी में पैक करने के लिए (दिलचस्प) प्रयास का एक बहुत कुछ है जहां आप इसे ठीक से प्रारूपित नहीं कर सकते हैं। मुझे अभी भी यह पता नहीं चला है कि यह क्या करता है या इससे भी महत्वपूर्ण बात यह है कि यह आपके (सही) दावे का समर्थन क्यों करता है।
— जो
110

टीएल; डीआर: इसके बजाय ऐसा करें

एक कमांड के बीच में तर्क रखने के लिए एक उपनाम की तुलना में एक फ़ंक्शन का उपयोग करने के लिए इसका सबसे आसान और अधिक पठनीय है। 

$ wrap_args() { echo "before $@ after"; }
$ wrap_args 1 2 3
before 1 2 3 after

यदि आप पढ़ते हैं, तो आप ऐसी चीजें सीखेंगे जिन्हें आपको शेल तर्क प्रसंस्करण के बारे में जानने की आवश्यकता नहीं है। ज्ञान खतरनाक है। बस इच्छित परिणाम प्राप्त करें, इससे पहले कि अंधेरे पक्ष हमेशा के लिए आपके भाग्य को नियंत्रित करे।

स्पष्टीकरण

bashउपनाम करना तर्क स्वीकार करते हैं, लेकिन केवल पर अंत :

$ alias speak=echo
$ speak hello world
hello world

के माध्यम से कमांड के बीच में तर्क देना aliasवास्तव में संभव है लेकिन यह बदसूरत हो जाता है।

घर पर यह कोशिश मत करो, kiddies!

यदि आप सीमाओं को दरकिनार करते हैं और ऐसा करना चाहते हैं जो दूसरों को कहना असंभव है, तो यहां नुस्खा है। बस मुझे दोष मत देना अगर आपके बाल frazzled हो जाता है और आपका चेहरा कालिख पागल-वैज्ञानिक-शैली में कवर किया जाता है।

वर्कअराउंड उन तर्कों को पारित करना है जो aliasकेवल एक आवरण के अंत में स्वीकार करता है जो उन्हें बीच में सम्मिलित करेगा और फिर उनकी कमांड निष्पादित करेगा।

समाधान 1

यदि आप वास्तव में प्रति से किसी फ़ंक्शन का उपयोग करने के खिलाफ हैं, तो आप उपयोग कर सकते हैं:

$ alias wrap_args='f(){ echo before "$@" after;  unset -f f; }; f'
$ wrap_args x y z
before x y z after

आप बदल सकते हैं $@साथ $1ही आप केवल पहला तर्क चाहते हैं।

व्याख्या १

यह एक अस्थायी फ़ंक्शन बनाता है f, जो तर्कों को पारित किया जाता है (ध्यान दें कि fबहुत अंत में कहा जाता है)। unset -fको हटा उपनाम के रूप में समारोह परिभाषा निष्पादित किया जाता है तो यह चारों ओर बाद में लटका नहीं करता है।

समाधान २

आप एक सबशेल का भी उपयोग कर सकते हैं:

$ alias wrap_args='sh -c '\''echo before "$@" after'\'' _'

व्याख्या २

उपनाम जैसा आदेश बनाता है:

sh -c 'echo before "$@" after' _

टिप्पणियाँ:

  • प्लेसहोल्डर _की आवश्यकता है, लेकिन यह कुछ भी हो सकता है। यह करने के लिए सेट हो जाता है shकी $0है, और इसलिए आवश्यक है कि उपयोगकर्ता के दिए गए तर्कों के पहले का सेवन नहीं मिलता। प्रदर्शन:

    sh -c 'echo Consumed: "$0" Printing: "$@"' alcohol drunken babble
Consumed: alcohol Printing: drunken babble

  • सिंगल-कोट्स के अंदर सिंगल-कोट्स की आवश्यकता होती है। यहाँ इसका एक उदाहरण दोहरे उद्धरण चिह्नों के साथ काम नहीं कर रहा है:

    $ sh -c "echo Consumed: $0 Printing: $@" alcohol drunken babble
Consumed: -bash Printing:

    यहां इंटरेक्टिव शेल के मूल्य $0और इसे पारित होने से पहले$@ दोहरे उद्धरण में बदल दिए जाते हैं । यहाँ सबूत है:sh

    echo "Consumed: $0 Printing: $@"
Consumed: -bash Printing:

    एकल उद्धरण यह सुनिश्चित करते हैं कि इन चरों को इंटरएक्टिव शेल द्वारा व्याख्या नहीं किया गया है, और शाब्दिक रूप से पारित किया जाता है sh -c।

    आप दोहरे उद्धरण चिह्नों का उपयोग कर सकते हैं \$@, लेकिन सबसे अच्छा अभ्यास है अपने तर्कों को उद्धृत करना (जैसा कि वे रिक्त स्थान शामिल कर सकते हैं), और \"\$@\"यहां तक ​​कि बदसूरत भी दिखते हैं, लेकिन आप एक मोटापे से लड़ने की प्रतियोगिता जीतने में मदद कर सकते हैं जहां frazzled बाल प्रवेश के लिए एक शर्त है।

— टॉम हेल
स्रोत
2
समाधान 1 के लिए, सुनिश्चित करें कि आप एकल उद्धरण का उपयोग करते हैं, और $ @ के आसपास \ "से बचते हैं। यदि आपको इसकी आवश्यकता है तो एक बहुत ही उपयोगी तकनीक है। ty।
— sgtz
समाधान 1 ने मेरे लिए प्रत्येक सर्वर के लिए तर्क के साथ rdesktop-vrdp को लपेटने का काम किया।
— हसद्दर
अंत में तर्कों को स्वीकार करना वास्तव में वही है जो मुझे एक सरल "जीसी {ब्रांचेनम}" के साथ "गिट चेकआउट {ब्रांचनाम}" को बदलने की आवश्यकता थी। .Bash_profile में मुझे बस जोड़ना थाalias gc='git checkout'
— AbstractVoid
@sgtz आप क्यों उद्धरणों को निकालना चाहेंगे $@? वे आवश्यक हैं यदि आपके पास है, जैसे, उनमें रिक्त स्थान वाली फाइलें।
— टॉम हेल
@TomHale यह कुछ हद तक भाषाविज्ञान है, लेकिन समाधान 1 वास्तव में उपयोगी नहीं है यदि कोई व्यक्ति वास्तव में एक फ़ंक्शन (जो भी कारण हो सकता है) का उपयोग करने के खिलाफ है क्योंकि आप सीधे अपने आप को स्वीकार करते हैं कि आप केवल एक फ़ंक्शन की परिभाषा को क्रियान्वित कर रहे हैं उपनाम। दूसरी बात, "बैश अलायस तर्कों को स्वीकार करते हैं, लेकिन केवल अंत में" अधिक शब्दार्थ है: उपनाम स्ट्रिंग्स द्वारा शब्दों की परिभाषा प्रतिस्थापन के अनुसार हैं। उन्हें तर्कों को स्वीकार करने की आवश्यकता नहीं है, जो आदेश प्रतिस्थापन के माध्यम से निष्पादित हो सकते हैं। उपनाम एक चरित्र प्रतिस्थापन है, अधिक कुछ नहीं, कुछ भी कम नहीं। नहीं?
— BUFU
39

मार्कर का उपयोग करने के लिए एक वैकल्पिक समाधान है , एक उपकरण जो मैंने हाल ही में बनाया है जो आपको कमांड टेम्पलेट पर "बुकमार्क" करने और आसानी से कर्सर रखने की अनुमति देता है:

कमांड लाइन मार्कर

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

— अमीन हज़ौसेफ़
स्रोत
14

आपको बस एक उपनाम के अंदर एक समारोह करना है:

$ alias mkcd='_mkcd(){ mkdir "$1"; cd "$1";}; _mkcd'

आप चाहिए चारों ओर "$ 1" डबल कोट्स डाल क्योंकि एकल उद्धरण नहीं होगा काम।

— केन ट्रान
स्रोत
5
यह चतुर है, लेकिन इस तथ्य के अलावा कि प्रश्न ने एक उपनाम बनाने के लिए निर्दिष्ट किया है, क्या केवल अलियास के समान नाम के साथ फ़ंक्शन नहीं बनाने का कोई कारण है?
— xaxxon
1
@xaxxon वास्तव में नहीं है, लेकिन यह सबसे आसान तरीका है जो मैं एक उपनाम का उपयोग करना जानता हूं, फ़ंक्शन नहीं।
— केन ट्रान
1
यह काम नहीं करता। उबंटू 18 पर, मुझे त्रुटि मिल रही है bash: syntax error near unexpected token '{mkdir'।
— शीतल शाह
;फ़ंक्शन के अंदर एक अनुगामी गायब करना _mkcdसंभवतः सबसे अधिक त्रुटि है।
— जेटीसेल
पहले और बाद में खाली जगह छोड़ें {और}
— hesham_EE
10

यहां मेरे द्वारा किए गए कार्यों के तीन उदाहरण दिए गए हैं ~/.bashrc, जो अनिवार्य रूप से उपनाम हैं जो एक पैरामीटर को स्वीकार करते हैं:

#Utility required by all below functions.
#/programming/369758/how-to-trim-whitespace-from-bash-variable#comment21953456_3232433
alias trim="sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*\$//g'"

।

:<<COMMENT
    Alias function for recursive deletion, with are-you-sure prompt.

    Example:
        srf /home/myusername/django_files/rest_tutorial/rest_venv/

    Parameter is required, and must be at least one non-whitespace character.

    Short description: Stored in SRF_DESC

    With the following setting, this is *not* added to the history:
        export HISTIGNORE="*rm -r*:srf *"
    - https://superuser.com/questions/232885/can-you-share-wisdom-on-using-histignore-in-bash

    See:
    - y/n prompt: https://stackoverflow.com/a/3232082/2736496
    - Alias w/param: https://stackoverflow.com/a/7131683/2736496
COMMENT
#SRF_DESC: For "aliaf" command (with an 'f'). Must end with a newline.
SRF_DESC="srf [path]: Recursive deletion, with y/n prompt\n"
srf()  {
    #Exit if no parameter is provided (if it's the empty string)
        param=$(echo "$1" | trim)
        echo "$param"
        if [ -z "$param" ]  #http://tldp.org/LDP/abs/html/comparison-ops.html
        then
          echo "Required parameter missing. Cancelled"; return
        fi

    #Actual line-breaks required in order to expand the variable.
    #- https://stackoverflow.com/a/4296147/2736496
    read -r -p "About to
    sudo rm -rf \"$param\"
Are you sure? [y/N] " response
    response=${response,,}    # tolower
    if [[ $response =~ ^(yes|y)$ ]]
    then
        sudo rm -rf "$param"
    else
        echo "Cancelled."
    fi
}

।

:<<COMMENT
    Delete item from history based on its line number. No prompt.

    Short description: Stored in HX_DESC

    Examples
        hx 112
        hx 3

    See:
    - https://unix.stackexchange.com/questions/57924/how-to-delete-commands-in-history-matching-a-given-string
COMMENT
#HX_DESC: For "aliaf" command (with an 'f'). Must end with a newline.
HX_DESC="hx [linenum]: Delete history item at line number\n"
hx()  {
    history -d "$1"
}

।

:<<COMMENT
    Deletes all lines from the history that match a search string, with a
    prompt. The history file is then reloaded into memory.

    Short description: Stored in HXF_DESC

    Examples
        hxf "rm -rf"
        hxf ^source

    Parameter is required, and must be at least one non-whitespace character.

    With the following setting, this is *not* added to the history:
        export HISTIGNORE="*hxf *"
    - https://superuser.com/questions/232885/can-you-share-wisdom-on-using-histignore-in-bash

    See:
    - https://unix.stackexchange.com/questions/57924/how-to-delete-commands-in-history-matching-a-given-string
COMMENT
#HXF_DESC: For "aliaf" command (with an 'f'). Must end with a newline.
HXF_DESC="hxf [searchterm]: Delete all history items matching search term, with y/n prompt\n"
hxf()  {
    #Exit if no parameter is provided (if it's the empty string)
        param=$(echo "$1" | trim)
        echo "$param"
        if [ -z "$param" ]  #http://tldp.org/LDP/abs/html/comparison-ops.html
        then
          echo "Required parameter missing. Cancelled"; return
        fi

    read -r -p "About to delete all items from history that match \"$param\". Are you sure? [y/N] " response
    response=${response,,}    # tolower
    if [[ $response =~ ^(yes|y)$ ]]
    then
        #Delete all matched items from the file, and duplicate it to a temp
        #location.
        grep -v "$param" "$HISTFILE" > /tmp/history

        #Clear all items in the current sessions history (in memory). This
        #empties out $HISTFILE.
        history -c

        #Overwrite the actual history file with the temp one.
        mv /tmp/history "$HISTFILE"

        #Now reload it.
        history -r "$HISTFILE"     #Alternative: exec bash
    else
        echo "Cancelled."
    fi
}

संदर्भ:

— aliteralmind
स्रोत
है ना? यह एक समारोह है, एक उपनाम नहीं है। और आपका एक संदर्भ यह बहुत ही प्रश्न है।
— ट्रिपलआई
2
नहीं, यह बिल्कुल एक फंक्शन की तरह काम करता है। यहां दिए गए कई जवाबों की तरह, आप एक ऐसा उपनाम नहीं बना सकते जो एक पैरामीटर लेता है। आप जो कर सकते हैं, वह एक फ़ंक्शन है, जो आपने किया है।
— त्रिवेणी १३'१५
1
@tripleee मेरे बैश नौसिखिया दृष्टिकोण से, आपकी टिप्पणी को पढ़ने से पहले, मैंने सोचा कि यह एक उपनाम (एक बनाने का एक वैकल्पिक तरीका) था। यह बिल्कुल एक जैसा काम करता है, जहाँ तक मैं बता सकता हूँ। यह अनिवार्य रूप से एक उपनाम है जो एक पैरामीटर को स्वीकार करता है, भले ही मैं शब्दावली पर बंद हूं। मुझे समस्या नहीं दिख रही है। मैंने इस समस्या के अन्य उत्तर के लिंक को स्पष्ट किया है। इसने मुझे इसे बनाने में मदद की।
— अल्टेराल्मिंड
1
शायद यह विशेष रूप से "एक बैश उर्फ ​​के सवाल का जवाब नहीं देता है जो एक पैरामीटर को स्वीकार करता है", क्योंकि मैं अब समझता हूं कि यह संभव नहीं है, लेकिन यह निश्चित रूप से प्रभावी रूप से इसका जवाब देता है। मुझे यहां क्या समझ नहीं आ रहा है?
— अल्टेराल्मिंड
2
कुछ बहुत अच्छे उदाहरण यहाँ हैं, और अच्छी तरह से टिप्पणी की गई कोड। इस पेज पर आने वाले लोगों के लिए एक बड़ी मदद।
— चिम
9

बैश उर्फ ​​बिल्कुल मापदंडों को स्वीकार करता है। मैंने सिर्फ एक नया रिएक्शन ऐप बनाने के लिए एक उपनाम जोड़ा है जो एक पैरामीटर के रूप में ऐप नाम को स्वीकार करता है। यहाँ मेरी प्रक्रिया है:

नैनो में संपादन के लिए bash_profile खोलें

nano /.bash_profile

अपने उपनाम जोड़ें, प्रति पंक्ति एक:

alias gita='git add .'
alias gitc='git commit -m "$@"'
alias gitpom='git push origin master'
alias creact='npx create-react-app "$@"'

ध्यान दें: "$ @" मापदंडों को स्वीकार करता है जैसे "creact my-new-app"

सहेजें और नैनो संपादक से बाहर निकलें

ctrl + o लिखने के लिए (हिट दर्ज करें); बाहर निकलने के लिए ctrl + x

टर्मिनल को .bash_profile में नए उपनामों का उपयोग करने के लिए कहें

source /.bash_profile

बस! अब आप अपने नए उपनाम का उपयोग कर सकते हैं

— Billeh
स्रोत
6

नायब: यदि यह विचार स्पष्ट नहीं है, तो यह किसी भी चीज़ के लिए उपनाम का उपयोग करने के लिए एक बुरा विचार है, लेकिन उपनाम, पहला 'अलियास में कार्य' और दूसरा 'रीडायरेक्ट / स्रोत पढ़ने में कठिन' होने के नाते। इसके अलावा, खामियां हैं (जो मुझे लगा कि यह स्पष्ट होगा, लेकिन सिर्फ मामले में आप भ्रमित हैं: मेरा मतलब यह नहीं है कि उन्हें वास्तव में इस्तेमाल किया जाना चाहिए ... कहीं भी!)

.................................................. .................................................. ............................................

मैंने पहले भी इसका उत्तर दिया है, और यह हमेशा अतीत में ऐसा रहा है:

alias foo='__foo() { unset -f $0; echo "arg1 for foo=$1"; }; __foo()'

जब तक आप सभी कार्यों को एक साथ करने से बच रहे हैं, जो ठीक और अच्छा है। किस मामले में आप पाठ को रीडायरेक्ट करने के लिए बैश की विशाल क्षमता का लाभ उठा सकते हैं:

alias bar='cat <<< '\''echo arg1 for bar=$1'\'' | source /dev/stdin'

वे दोनों एक ही लंबाई के बारे में हैं या कुछ पात्रों को लेते हैं।

असली किकर समय का अंतर है, शीर्ष 'समारोह विधि' और नीचे 'रीडायरेक्ट स्रोत' विधि से किया जा रहा जा रहा है। इस सिद्धांत को सिद्ध करने के लिए, समय स्वयं बोलता है:

arg1 for foo=FOOVALUE
 real 0m0.011s user 0m0.004s sys 0m0.008s  # <--time spent in foo
 real 0m0.000s user 0m0.000s sys 0m0.000s  # <--time spent in bar
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.010s user 0m0.004s sys 0m0.004s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.011s user 0m0.000s sys 0m0.012s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.012s user 0m0.004s sys 0m0.004s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.010s user 0m0.008s sys 0m0.004s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE

यह लगभग 200 परिणामों का निचला हिस्सा है, जो यादृच्छिक अंतराल पर किया जाता है। ऐसा लगता है कि कार्य निर्माण / विनाश पुनर्निर्देशन की तुलना में अधिक समय लेता है। उम्मीद है कि यह भविष्य के आगंतुकों को इस सवाल में मदद करेगा (इसे अपने पास नहीं रखना चाहता)।

— osirisgothra
स्रोत
2
एक उपनाम जो एक फ़ंक्शन को परिभाषित करता है, तो उस फ़ंक्शन को केवल मूर्खतापूर्ण तरीके से चलाएं। बस एक फ़ंक्शन लिखें। लगभग हर उद्देश्य के लिए, शेल कार्य द्वारा उपनामों को अलग कर दिया जाता है।
— जिरह
अगर आपने पूरी बात नहीं पढ़ी है, जो आप आजमा सकते हैं, तो मुझे निराशा हुई कि फ़ंक्शन विधि का उपयोग करना पहली जगह में उतना अच्छा क्यों नहीं था, और इसके अलावा, यह बिल्कुल भी मूर्खतापूर्ण नहीं है। पोस्टिंग और डाउनवोटिंग को सिर्फ इसलिए रोकें क्योंकि आप व्यक्तिगत रूप से इसे पसंद नहीं करते ... या कम से कम एक वैध स्पष्टीकरण दें। नेम कॉलिंग पहला साइन क्लोज
— माइंडनेस है
1
दूसरे एक (बार उर्फ) के कई दुष्प्रभाव हैं। सबसे पहले कमांड स्टड का उपयोग नहीं कर सकता है। दूसरे, अगर उपनाम के बाद कोई तर्क नहीं दिया जाता है, तो जो भी तर्क होता है वह बदले में पारित हो जाता है। एक फ़ंक्शन का उपयोग करने से इन सभी दुष्प्रभावों से बचा जाता है। (बिल्ली का बेकार उपयोग भी)।
— जिरह
2
हे, मैंने कभी नहीं कहा कि यह किसी भी करने के लिए अच्छा विचार था, मैंने कहा कि इसके बारे में जाने के अन्य तरीके भी थे - यहां मुख्य विचार यह है कि आपको उपनामों में कार्यों का उपयोग नहीं करना चाहिए क्योंकि वे एक जटिल से भी धीमी हैं पुनर्निर्देशित, मुझे लगा कि यह स्पष्ट होगा, लेकिन मुझे लगता है कि मुझे इसे हर किसी के लिए वर्तनी में
— बदलना होगा
1
चूंकि बार की टाइमिंग सभी 0 हैं, मुझे संदेह होगा कि शेल इसे सही तरीके से टाइम नहीं कर रहा है। ध्यान दें कि कमांड चलाने से पहले समय संदेश मुद्रित किया जाता है? एर्गो, यह बार कुछ भी नहीं है और फिर बार करता है, इसलिए आप बार को माप नहीं रहे हैं। कुछ अधिक जटिल, या बार में एक बड़ा लूप करें ताकि आप इसे और अधिक स्पष्ट कर सकें कि आप कुछ भी नहीं
— इवान लैंग्लिस
6

यदि आप एक फ़ंक्शन के सभी पैरामिक्स को लागू करने का एक सामान्य तरीका खोज रहे हैं, न कि केवल एक या दो या कुछ अन्य हार्डकोड राशि, तो आप इस तरह से कर सकते हैं:

#!/usr/bin/env bash

# you would want to `source` this file, maybe in your .bash_profile?
function runjar_fn(){
    java -jar myjar.jar "$@";
}

alias runjar=runjar_fn;

इसलिए ऊपर दिए गए उदाहरण में, मैं सभी मापदंडों को पास करता हूं जब मैं runjarउर्फ को चलाता हूं ।

उदाहरण के लिए, अगर मैंने किया तो runjar hi thereयह वास्तव में चल रहा है java -jar myjar.jar hi there। अगर मैं runjar one two threeकरता तो चलता java -jar myjar.jar one two three।

मुझे यह $@आधारित समाधान पसंद है क्योंकि यह किसी भी संख्या में परम के साथ काम करता है।

— मीका
स्रोत
4
केवल फ़ंक्शन runjarको उपनाम बनाने के बजाय फ़ंक्शन का नाम क्यों नहीं है ? अनावश्यक रूप से जटिल लगता है!
— इवान लैंग्लोइस
बैश फ़ाइलों में @EvanLanglois फ़ंक्शंस स्वचालित रूप से- aliasया (पास की गई चीज़ों के गुण होने alias) हैं? अगर हाँ, तो इसका सिर्फ इतना ही पता नहीं है
— मीका
तुम क्या मतलब समझ में नहीं आता। एक उपनाम दूसरा नाम है, यह एक व्यक्ति या एक समारोह है। तो, आपने एक फ़ंक्शन बनाया, फिर आपने फ़ंक्शन का दूसरा नाम बनाया। उपनाम के बारे में कुछ खास नहीं है, इसका सिर्फ एक दूसरा नाम है और इसकी आवश्यकता नहीं है। आप कमांड लाइन पर जो टाइप करते हैं वह आंतरिक या बाहरी कार्य हो सकता है, इसलिए "फ़ंक्शन" एक नया कमांड बनाता है, न कि अन्य।
— इवान लैंग्लिस
4
यह निराधार है। यह वैसा ही है alias runjar='java -jar myjar.jar'। उपनाम तर्क स्वीकार करते हैं, लेकिन केवल अंत में।
— टॉम हेल
6

उन सभी का सम्मान करते हुए कहा कि आप एक उपनाम के बीच में एक पैरामीटर नहीं डाल सकते हैं, मैंने अभी इसका परीक्षण किया और पाया कि यह काम करता है।

अन्य नाम mycommand = "python3" $ 1 "script.py --folderoutput परिणाम /"

जब मैंने तब mycommand foobar चलाया तो यह ठीक उसी तरह काम कर रहा था जैसे मैंने कमांड को longhand टाइप किया था।

— नथानिएल
स्रोत
बिल्कुल, उर्फ ​​मापदंडों को प्राप्त कर सकते हैं, मैं इस एक का उपयोग कर उम्र कर रहा हूँ जैसे: उर्फ ​​प्रतिबद्ध = "कमिट-मी $ 1"
— अगपिटोकांडेमोर
मेरे लिए काम नहीं करता है: alias myalias="echo 1 "$1" 3"; myalias 2मुझे देता है:1 3 2
— dirdi
4

बैश उर्फ ​​की समस्या का सामान्यीकृत समाधान चाहने के लिए वैध तकनीकी कारण हैं, जिसमें मनमाना तर्क देने के लिए कोई तंत्र नहीं है। एक कारण यह है कि यदि आप जिस कमांड को निष्पादित करना चाहते हैं, वह पर्यावरण के उन परिवर्तनों से प्रतिकूल रूप से प्रभावित होगा जो किसी फ़ंक्शन को निष्पादित करने के परिणामस्वरूप होते हैं। अन्य सभी मामलों में, कार्यों का उपयोग किया जाना चाहिए।

हाल ही में मुझे इसके समाधान के लिए प्रयास करने के लिए मजबूर किया गया है कि मैं चर और कार्यों की परिभाषा को मुद्रित करने के लिए कुछ संक्षिप्त कमांड बनाना चाहता था। इसलिए मैंने उस उद्देश्य के लिए कुछ कार्य लिखे। हालांकि, कुछ चर हैं जो एक फ़ंक्शन कॉल द्वारा ही बदल दिए जाते हैं (या हो सकते हैं)। उनमें से हैं:

FUNCNAME BASH_SOURCE BASH_LINENO BASH_ARGC BASH_ARGV

वैरिएबल डिफेंस को प्रिंट करने के लिए मैं (एक फ़ंक्शन में) मूल कमांड का उपयोग कर रहा था। सेट कमांड द्वारा फॉर्म आउटपुट में था:

sv () { set | grep --color=never -- "^$1=.*"; }

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

> V=voodoo
sv V
V=voodoo

समस्या: यह ऊपर उल्लिखित चर की परिभाषाओं को मुद्रित नहीं करेगा क्योंकि वे वर्तमान संदर्भ में हैं , उदाहरण के लिए, यदि एक इंटरैक्टिव शेल प्रॉम्प्ट में (या किसी फ़ंक्शन कॉल में नहीं), FUNCNAME परिभाषित नहीं है। लेकिन मेरा कार्य मुझे गलत जानकारी बताता है:

> sv FUNCNAME
FUNCNAME=([0]="sv")

इस विषय पर अन्य पोस्ट में अन्य लोगों द्वारा उल्लिखित एक समाधान का उल्लेख किया गया है। इस विशेष कमांड के लिए वेरिएबल डिफेंस को प्रिंट करना। और जिसके लिए केवल एक तर्क की आवश्यकता है, मैंने यह किया:

alias asv='(grep -- "^$(cat -)=.*" <(set)) <<<'

जो सही आउटपुट (कोई नहीं) देता है, और परिणाम की स्थिति (झूठी):

> asv FUNCNAME
> echo $?
1

हालाँकि, मैं अभी भी एक समाधान खोजने के लिए मजबूर महसूस कर रहा था जो मनमानी संख्या के लिए काम करता है।

एक बैश अलियास कमांड के लिए मनमाना तर्क पारित करने के लिए एक सामान्य समाधान:

# (I put this code in a file "alias-arg.sh"):

# cmd [arg1 ...] – an experimental command that optionally takes args,
# which are printed as "cmd(arg1 ...)"
#
# Also sets global variable "CMD_DONE" to "true".
#
cmd () { echo "cmd($@)"; declare -g CMD_DONE=true; }

# Now set up an alias "ac2" that passes to cmd two arguments placed
# after the alias, but passes them to cmd with their order reversed:
#
# ac2 cmd_arg2 cmd_arg1 – calls "cmd" as: "cmd cmd_arg1 cmd_arg2"
#
alias ac2='
    # Set up cmd to be execed after f() finishes:
    #
    trap '\''cmd "${CMD_ARGV[1]}" "${CMD_ARGV[0]}"'\'' SIGUSR1;
    #        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    #       (^This is the actually execed command^)
    #
    # f [arg0 arg1 ...] – acquires args and sets up trap to run cmd:
    f () {
        declare -ag CMD_ARGV=("$@");  # array to give args to cmd
        kill -SIGUSR1 $$;             # this causes cmd to be run
        trap SIGUSR1;                 # unset the trap for SIGUSR1
        unset CMD_ARGV;               # clean up env...
        unset f;                      # incl. this function!
    };
    f'  # Finally, exec f, which will receive the args following "ac2".

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

> . alias-arg.sh
> ac2 one two
cmd(two one)
>
> # Check to see that command run via trap affects this environment:
> asv CMD_DONE
CMD_DONE=true

इस समाधान के बारे में एक अच्छी बात यह है कि ट्रैप्ड कमांड को कंपोज करते समय कमांड कमांड को काम करने के लिए इस्तेमाल किए जाने वाले सभी विशेष ट्रिक्स काम करेंगे। एकमात्र अंतर यह है कि सरणी सिंटैक्स का उपयोग किया जाना चाहिए।

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

यदि आप "$ @" चाहते हैं, तो "$ {CMD_ARGV [@]}" का उपयोग करें।

यदि आप "$ #" चाहते हैं, तो "$ {# CMD_ARGV [@]}" का उपयोग करें।

आदि।

— crobc1
स्रोत
3

एक बार मैंने कुछ मजेदार प्रोजेक्ट किया और मैं अभी भी इसका उपयोग करता हूं। यह कुछ एनीमेशन दिखा रहा है, जबकि मैं cpकमांड coz के माध्यम से फ़ाइलों की नकल cpकुछ भी नहीं दिखाते हैं और यह निराशा की तरह है। इसलिए मैंने यह उर्फ ​​बनाया

alias cp="~/SCR/spiner cp"

और यह स्पिनर स्क्रिप्ट है

#!/bin/bash

#Set timer
T=$(date +%s)

#Add some color
. ~/SCR/color

#Animation sprites
sprite=( "(* )  ( *)" " (* )( *) " " ( *)(* ) " "( *)  (* )" "(* )  ( *)" )

#Print empty line and hide cursor
printf "\n${COF}"

#Exit function
function bye { printf "${CON}"; [ -e /proc/$pid ] && kill -9 $pid; exit; }; trap bye INT

#Run our command and get its pid
"$@" & pid=$!

#Waiting animation
i=0; while [ -e /proc/$pid ]; do sleep 0.1

    printf "\r${GRN}Please wait... ${YLW}${sprite[$i]}${DEF}"
    ((i++)); [[ $i = ${#sprite[@]} ]] && i=0

done

#Print time and exit
T=$(($(date +%s)-$T))
printf "\n\nTime taken: $(date -u -d @${T} +'%T')\n"

bye

ऐसा दिख रहा है

यहां छवि विवरण दर्ज करें

चक्रीय एनीमेशन)

यहां छवि विवरण दर्ज करें

— इवान
स्रोत
2

पैरामीटर लेने के लिए, आपको फ़ंक्शन का उपयोग करना चाहिए!

हालाँकि $ @ की व्याख्या तब की जाती है जब उपनाम के निष्पादन के दौरान उपनाम बनाने और $ भागने से भी काम नहीं होता है। मैं इस समस्या का समाधान कैसे कर सकता हूं।

इस समस्या से छुटकारा पाने के लिए आपको एक उपनाम के बजाय शेल फ़ंक्शन का उपयोग करने की आवश्यकता है। आप फू को इस प्रकार परिभाषित कर सकते हैं:

function foo() { /path/to/command "$@" ;}

या

foo() { /path/to/command "$@" ;}

अंत में, निम्नलिखित सिंटैक्स का उपयोग करके अपने foo () को कॉल करें:

foo arg1 arg2 argN

सुनिश्चित करें कि आप अपना फू () ~/.bash_profileया ~/.zshrcफ़ाइल जोड़ रहे हैं ।

आपके मामले में, यह काम करेगा

function trash() { mv $@ ~/.Trash; }
— अहमद आवा
स्रोत
मुझे आपका आइडिया समझ नहीं आ रहा है। मुझे लगता है कि यह महत्वपूर्ण नहीं है जब तर्कों की व्याख्या हो। एलियसे अंत में जितना चाहें उतना पैरामीटर स्वीकार करें।
— टिमो
लेकिन कार्यों के साथ ऐसा करना बेहतर है। उपनाम उस के लिए नहीं हैं।
— अहमद आवा
1

कार्य वास्तव में लगभग हमेशा उत्तर के रूप में पहले से ही योगदान दिया और मैन पेज से इस उद्धरण द्वारा पुष्टि की है: "लगभग हर उद्देश्य के लिए, उपनामों के कार्यों द्वारा उपनामित हैं।"

पूर्णता के लिए और क्योंकि यह उपयोगी हो सकता है (मामूली अधिक हल्के वाक्यविन्यास) यह ध्यान दिया जा सकता है कि जब पैरामीटर (ओं) उपनाम का पालन करते हैं, तब भी उनका उपयोग किया जा सकता है (हालांकि यह ओपी की आवश्यकता को संबोधित नहीं करेगा)। उदाहरण के साथ प्रदर्शित करना सबसे आसान है:

alias ssh_disc='ssh -O stop'

मुझे smth टाइप करने की अनुमति देता है ssh_disc myhost, जो उम्मीद के मुताबिक विस्तारित हो जाता है:ssh -O stop myhost

यह उन तर्कों के लिए उपयोगी हो सकता है जो जटिल तर्क लेते हैं (मेरी स्मृति यह नहीं है कि इसका उपयोग अब और न हो ...)

— sxc731
स्रोत
1

दोनों फ़ंक्शन और उपनाम पैरामीटर का उपयोग कर सकते हैं जैसा कि अन्य ने यहां दिखाया है। इसके अतिरिक्त, मैं अन्य पहलुओं के एक जोड़े को इंगित करना चाहूंगा:

1. फ़ंक्शन अपने स्वयं के दायरे में चलता है, उर्फ ​​शेयर गुंजाइश

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

function tfunc(){
    GlobalFromFunc="Global From Func" # Function set global variable by default
    local FromFunc="onetwothree from func" # Set a local variable

}

alias talias='local LocalFromAlias="Local from Alias";  GlobalFromAlias="Global From Alias" # Cant hide a variable with local here '
# Test variables set by tfunc
tfunc # call tfunc
echo $GlobalFromFunc # This is visible
echo $LocalFromFunc # This is not visible
# Test variables set by talias
# call talias
talias
echo $GlobalFromAlias # This is invisible
echo $LocalFromAlias # This variable is unset and unusable

आउटपुट:

bash-3.2$     # Test variables set by tfunc
bash-3.2$     tfunc # call tfunc
bash-3.2$     echo $GlobalFromFunc # This is visible
Global From Func
bash-3.2$     echo $LocalFromFunc # This is not visible

bash-3.2$     # Test variables set by talias
bash-3.2$     # call talias
bash-3.2$     talias
bash: local: can only be used in a function
bash-3.2$     echo $GlobalFromAlias # This is invisible
Global From Alias
bash-3.2$ echo $LocalFromAlias # This variable is unset and unusable

2. रैपर स्क्रिप्ट एक बेहतर विकल्प है

यह मेरे साथ कई बार हुआ है कि उपयोगकर्ता नाम या मल्टी-उपयोगकर्ता वातावरण को स्विच करने या शामिल करने के दौरानssh एक उपनाम या फ़ंक्शन नहीं मिल सकता है। सोर्सिंग डॉट फाइल्स के साथ टिप्स या ट्रिक्स हैं, या यह दिलचस्प है, उपनाम के साथ: alias sd='sudo 'यह बाद के अन्य उपनामों alias install='sd apt-get install'को अपेक्षा के अनुसार काम करने देता है (अतिरिक्त स्थान को नोटिस करें sd='sudo ')। हालाँकि, एक रैपर स्क्रिप्ट इस तरह के मामलों में फ़ंक्शन या उपनाम से बेहतर काम करता है। एक आवरण लिपि के साथ मुख्य लाभ यह है कि यह दृश्यमान पथ के लिए दृश्यमान / निष्पादन योग्य है (यानी / usr / loca / bin /) जहां एक फ़ंक्शन / उपनाम के रूप में उपयोग करने से पहले इसे सॉर्ट किया जाना चाहिए। उदाहरण के लिए, आप एक फ़ंक्शन ~ / .bash_profile या ~ / .bashrc में डालते हैंbash , लेकिन बाद में दूसरे शेल पर स्विच करते हैं (अर्थातzsh) तो फ़ंक्शन अब दिखाई नहीं दे रहा है। इसलिए, जब आप संदेह में होते हैं, तो एक आवरण स्क्रिप्ट हमेशा सबसे विश्वसनीय और पोर्टेबल समाधान होता है।

— biocyberman
स्रोत
1
आपको क्या लगता है कि फ़ंक्शन संस्करण काम नहीं करता है?
— ट्रिपल जूल 28'19
@tripleee। मैंने इसे और अधिक पठनीय बनाने के लिए पोस्ट को संपादित किया है। शीर्षक के तहत "1. उपनाम काम करता है, फ़ंक्शन ..." मैंने उदाहरण दिया कि फ़ंक्शन संस्करण क्यों काम नहीं करता है। और शायद सीधे सवाल का जवाब देने के लिए, फ़ंक्शन एक नया स्कोप पेश करता है जहां अलियास नहीं है।
— बायोकैबरमैन
आप कहते हैं कि यह काम नहीं करता है, लेकिन मुझे आप पर विश्वास नहीं है। sourceएक समारोह में बस ठीक काम करता है।
— ट्रिपलए
1
f () { source /tmp/nst; }जैसा मैं उम्मीद करता हूँ वैसा ही करता है। हो सकता है कि आपका PATHगलत है इसलिए यह गलत activateया कुछ और चलाता है; लेकिन sourceएक समारोह से चल रहा है ठीक काम करता है।
— ट्रिपलए
1
BTW, पुनः: functionअपनी परिभाषा में कीवर्ड का उपयोग करते हुए , wiki.bash-hackers.org/scripting/obirect देखें - function funcname {प्राचीन ksh सिंटैक्स बैश है, जो प्री-पोसिक्स गोले के साथ बैकवर्ड संगतता के लिए समर्थन करता है, जबकि funcname() {आधिकारिक पॉस-मानकीकृत सिंटैक्स है। function funcname() {दो का एक बेमेल है जो प्राचीन ksh के साथ संगत नहीं है या POSIX श के साथ संगत है, और इस प्रकार सबसे अच्छा बचा जाता है।
— चार्ल्स डफी
1

यहाँ उदाहरण है:

alias gcommit='function _f() { git add -A; git commit -m "$1"; } ; _f'

बहोत महत्वपूर्ण:

  1. {पहले और बाद में एक जगह है }।
  2. वहाँ एक है ;क्रम में प्रत्येक आदेश के बाद। यदि आप अंतिम आदेश के बाद इसे भूल जाते हैं, तो आप >इसके बजाय शीघ्र देखेंगे !
  3. तर्क को उद्धरणों में संलग्न किया गया है "$1"
— शीतल शाह
स्रोत
2
किसी फ़ंक्शन के लिए उपनाम बनाने की आवश्यकता नहीं है, बस फ़ंक्शन का सीधे उपयोग करें।
— user3439894
1

जैसा कि पहले से ही दूसरों द्वारा बताया गया है, फ़ंक्शन का उपयोग करना सबसे अच्छा अभ्यास माना जाना चाहिए।

हालांकि, यहाँ एक और दृष्टिकोण है, लाभ xargs:

alias junk="xargs -I "{}" -- mv "{}" "~/.Trash" <<< "

ध्यान दें कि यह धाराओं के पुनर्निर्देशन से संबंधित दुष्प्रभाव हैं।

— dirdi
स्रोत
0

आपको कुछ भी करने की ज़रूरत नहीं है, उर्फ ​​स्वचालित रूप से ऐसा करता है।

उदाहरण के लिए, अगर मैं git पुल ओरिजिनल मास्टर पैरामीटर बनाना चाहता हूं, तो मैं बस एक उपनाम बना सकता हूं:

alias gpull = 'git pull origin '

और जब वास्तव में इसे फोन किया जाता है, तो आप 'मास्टर' (शाखा का नाम) को एक पैरामीटर के रूप में पास कर सकते हैं, जैसे:

gpull master
//or any other branch
gpull mybranch
— KayV
स्रोत
यह सवाल का जवाब नहीं देता है, क्योंकि तर्क को स्वतंत्र रूप से नहीं रखा जा सकता है, लेकिन केवल अंत में।
— dirdi
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.