පරාමිතියක් ගන්නා Bash අන්වර්ථයක් සාදන්න?

මම CShell භාවිතා කළා (csh), එය ඔබට පරාමිතියක් ගන්නා අන්වර්ථයක් සෑදීමට ඉඩ දෙයි. අංකනය වැනි දෙයක් විය

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

Bash හි, මෙය ක්‍රියාත්මක වන බවක් නොපෙනේ. Bash හි ප්‍රයෝජනවත් අංග රාශියක් ඇති බැවින්, මෙය ක්‍රියාත්මක කර ඇතැයි මම සිතමි, නමුත් කෙසේ දැයි මම කල්පනා කරමි.

Bash අන්වර්ථය සෘජුවම පරාමිතීන් පිළිගන්නේ නැත. ඔබට ශ්‍රිතයක් නිර්මාණය කිරීමට සිදුවනු ඇත.

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

ඉහත පිළිතුර පිරිපහදු කිරීමෙන් ඔබට අන්වර්ථ නාම සඳහා 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; }

ප්‍රශ්නය සරලව අසනු ලබන්නේ වැරදිය. ඔබ පරාමිතීන් ගන්නා අන්වර්ථයක් සාදන්නේ නැත, මන්ද aliasදැනටමත් පවතින දෙයකට දෙවන නමක් එක් කරයි. OP ට අවශ්‍ය වන්නේ functionනව ශ්‍රිතයක් නිර්මාණය කිරීමේ විධානයයි. ශ්‍රිතයට දැනටමත් නමක් ඇති බැවින් ඔබට ශ්‍රිතය අන්වර්ථ කිරීමට අවශ්‍ය නොවේ.

මම හිතන්නේ ඔබට මේ වගේ දෙයක් අවශ්‍යයි:

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

ඒක තමයි! ඔබට para 1, $ 2, $ 3, වැනි පරාමිතීන් භාවිතා කළ හැකිය, නැතහොත් ඒවා with with සමඟ පුරවන්න.

ටීඑල්; ඩීආර්: ඒ වෙනුවට මෙය කරන්න

විධානයක් මැද තර්ක ඉදිරිපත් කිරීම සඳහා අන්වර්ථයකට වඩා ශ්‍රිතයක් භාවිතා කිරීම වඩා පහසු සහ කියවිය හැකි ය.

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

ඔබ කියවන්නේ නම්, ෂෙල් තර්ක සැකසීම ගැන ඔබ දැනගත යුතු නැති දේවල් ඔබ ඉගෙන ගනු ඇත. දැනුම භයානක ය. අඳුරු පැත්ත සදහටම ඔබේ ඉරණම පාලනය කිරීමට පෙර ඔබට අවශ්‍ය ප්‍රති come ලය ලබා ගන්න.

පැහැදිලි කිරීම

bashයළි-යොමුවීම් කරන්න තර්ක පිළිගන්න නමුත්, පමණක් අවසන් :

$ alias speak=echo
$ speak hello world
hello world

විධාන මැදට තර්ක ඉදිරිපත් aliasකිරීම සැබවින්ම හැකි නමුත් එය කැත වේ.

නිවසේදී මෙය උත්සාහ නොකරන්න, පැටියෝ!

ඔබ සීමාවන් ඉක්මවා වෙනත් අය කියන දේ කිරීමට කැමති නම්, මෙන්න වට්ටෝරුව. ඔබේ කොණ්ඩය කැළැල් වී ඔබේ මුහුණ පිස්සු-විද්‍යා-ශෛලියකින් වැසී ඇත්නම් මට දොස් නොකියන්න.

මෙහි ප්‍රති ar ලය aliasවනුයේ අවසානයේ පමණක් පිළිගන්නා තර්ක එතීමකට යවා ඒවා මැදට ඇතුළු කර ඔබේ විධානය ක්‍රියාත්මක කිරීමයි.

විසඳුම 1

ඔබ සැබවින්ම ශ්‍රිතයක් භාවිතා කිරීමට විරුද්ධ නම්, ඔබට මෙය භාවිතා කළ හැකිය:

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

ඔබ විස්ථාපනය කල හැකි $@සමග $1පමණක් ඔබ පළමු තර්කය අවශ්ය නම්.

පැහැදිලි කිරීම 1

මෙය තාවකාලික ශ්‍රිතයක් නිර්මාණය කරයි f, එය තර්ක සම්මත කරයි (සටහන fඅවසානයේ කැඳවනු ලැබේ). මෙම unset -fඑය පසුව බැහැලා නැත එසේ යන අන්වර්ථ ක්රියාත්මක වන ලෙස මෙම උත්සවය අර්ථ දැක්වීම ඉවත් කරයි.

විසඳුම 2

ඔබට උපසිරැසියක් ද භාවිතා කළ හැකිය:

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

පැහැදිලි කිරීම 2

අන්වර්ථය මෙවැනි විධානයක් සාදයි:

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

අදහස්:

• ස්ථාන දරන්නා _අවශ්‍යයි, නමුත් එය ඕනෑම දෙයක් විය හැකිය. එය sh's' ලෙස සකසා $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.

  ඔබට ද්විත්ව උපුටා දැක්වීම් භාවිතා කළ හැකි \$@නමුත් හොඳම ක්‍රමය වන්නේ ඔබේ තර්ක උපුටා දැක්වීමයි (ඒවා අවකාශයන් අඩංගු විය හැකි බැවින්), \"\$@\"එය වඩාත් අවලස්සන පෙනුමක් ඇති නමුත්, කෙස් කළඹට ඇතුළුවීම සඳහා පූර්වාවශ්‍යතාවක් වන අපැහැදිලි තරඟයක් ජය ගැනීමට ඔබට උදව් වනු ඇත.

විකල්ප විසඳුමක් නම් මාකර් මෑතකදී භාවිතා කළ මෙවලමක් වන අතර එය විධාන සැකිලි "පිටු සලකුණු" කිරීමට සහ විධාන ස්ථාන දරන්නන්ට පහසුවෙන් කර්සරය තැබීමට ඉඩ සලසයි:

බොහෝ විට මම ෂෙල් ශ්‍රිත භාවිතා කරන බව මට පෙනී ගියේය, එබැවින් නිතර භාවිතා කරන විධාන විධාන රේඛාවේ නැවත නැවතත් ලිවීමට අවශ්‍ය නැත. මෙම භාවිත අවස්ථාව සඳහා ශ්‍රිත භාවිතා කිරීමේ ගැටළුව නම්, මගේ විධාන වචන මාලාවට නව පද එකතු කිරීම සහ තාත්වික විධානයෙහි පරාමිතීන් යොමු කරන ශ්‍රිතයන් මතක තබා ගැනීමයි. මාකර් ඉලක්කය වන්නේ එම මානසික බර ඉවත් කිරීමයි.

ඔබ කළ යුත්තේ අන්වර්ථයක් තුළ ශ්‍රිතයක් කිරීම පමණි:

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

තනි මිල ගණන් ක්‍රියාත්මක නොවන නිසා ඔබ "$ 1" වටා ද්විත්ව මිල ගණන් තැබිය යුතුය .

මෙහි මා සතුව ඇති කාර්යයන් සඳහා උදාහරණ තුනක් ඇත ~/.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
}

යොමුව:

• නූල් වලින් සුදු අවකාශය කප්පාදු කිරීම : බාෂ් විචල්‍යයකින් සුදු අවකාශය කපා ගන්නේ කෙසේද?
• සත්‍ය රේඛා බිඳීම්: https://stackoverflow.com/a/4296147/2736496
• අන්වර්ථය w / param: https://stackoverflow.com/a/7131683/2736496 (මෙම ප්‍රශ්නයේ තවත් පිළිතුරක්)
• ඉතිහාසය: /superuser/232885/can-you-share-wisdom-on-using-histignore-in-bash
• Y / N විමසුම: https://stackoverflow.com/a/3232082/2736496
• ගැලපෙන සියලුම අයිතම ඉතිහාසයෙන් මකන්න: /unix/57924/how-to-delete-commands-in-history-matching-a-given-string
• නූල් හිස් / හිස්: http://tldp.org/LDP/abs/html/comparison-ops.html

Bash අන්වර්ථය නියත වශයෙන්ම පරාමිතීන් පිළිගනී. යෙදුමේ නම පරාමිතියක් ලෙස පිළිගන්නා නව ප්‍රතික්‍රියා යෙදුමක් නිර්මාණය කිරීම සඳහා මම අන්වර්ථයක් එක් කළෙමි. මෙන්න මගේ ක්‍රියාවලිය:

නැනෝ භාෂාවෙන් සංස්කරණය කිරීම සඳහා 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 "$@"'

සටහන: "$ @" "මගේ නව-යෙදුම නිර්මාණය කරන්න" වැනි සම්මතයන් පිළිගනී.

නැනෝ සංස්කාරකය සුරකින්න සහ පිටවන්න

ලිවීමට ctrl + o (Enter යතුර ඔබන්න); පිටවීමට ctrl + x

.Bash_profile හි නව අන්වර්ථයන් භාවිතා කිරීමට පර්යන්තයට කියන්න

source /.bash_profile

ඒක තමයි! ඔබට දැන් ඔබගේ නව අන්වර්ථ නාම භාවිතා කළ හැකිය

අන්වර්ථයක් මධ්‍යයේ ඔබට පරාමිතියක් ඇතුළත් කළ නොහැකි යැයි පවසන සියල්ලන්ටම ගෞරවයෙන් මම එය පරීක්ෂා කර බැලූ විට එය ක්‍රියාත්මක වූ බව සොයා ගත්තා.

alias mycommand = "python3" $ 1 "script.py --folderoutput RESULTS /"

මම පසුව mycommand foobar ධාවනය කරන විට එය හරියටම ක්‍රියා කළේ මම විධානය දිගු වේලාවක් ටයිප් කළාක් මෙනි.

එක් පරාමිතියක් එකක් හෝ දෙකක් හෝ වෙනත් දෘඩ කේත කරන ලද ප්‍රමාණයක් පමණක් නොව, ශ්‍රිතයක් සඳහා සියලු පරාමිතීන් යෙදීම සඳහා ඔබ සාමාන්‍ය ක්‍රමයක් සොයන්නේ නම්, ඔබට එය මේ ආකාරයෙන් කළ හැකිය:

#!/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වේ.

මම මේ $@පදනම් කරගත් විසඳුමට කැමතියි එය ඕනෑම පරාමිති ගණනක් සමඟ ක්‍රියා කරන නිසා.

සැ.යු. එසේම, අඩුපාඩු තිබේ (එය පැහැදිලිව පෙනේ යැයි මම සිතුවෙමි , නමුත් ඔබ ව්‍යාකූල වී ඇත්නම්: ඒවා ඇත්ත වශයෙන්ම භාවිතා කිරීමට අදහස් නොකෙරේ ... ඕනෑම තැනක!)

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

මම මීට පෙර මෙයට පිළිතුරු දී ඇති අතර එය අතීතයේ දී සෑම විටම මේ ආකාරයට විය:

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

ප්‍රති results ල 200 ක පමණ පහළ කොටස මෙයයි, අහඹු ලෙස සිදු කරනු ලැබේ. ක්‍රියාකාරීත්වය නිර්මාණය කිරීම / විනාශ කිරීම යළි හරවා යැවීමට වඩා වැඩි කාලයක් ගත වන බව පෙනේ. මෙම ප්‍රශ්නයට අනාගත අමුත්තන්ට මෙය උපකාරී වනු ඇතැයි අපේක්‍ෂා කරමු (එය මා වෙත තබා ගැනීමට අවශ්‍ය නොවීය).

අත්තනෝමතික තර්ක විස්ථාපනය කිරීමට යාන්ත්‍රණයක් නොමැති බැෂ් අන්වර්ථයේ ගැටලුවට සාමාන්‍ය විසඳුමක් ලබා ගැනීමට නීත්‍යානුකූල තාක්ෂණික හේතු තිබේ. එක් හේතුවක් නම්, ඔබ ක්‍රියාත්මක කිරීමට බලාපොරොත්තු වන විධානය ශ්‍රිතයක් ක්‍රියාත්මක කිරීමෙන් ඇතිවන පරිසරයේ සිදුවන වෙනස්කම් වලට අහිතකර ලෙස බලපානු ඇත. අනෙක් සියලුම අවස්ථාවන්හිදී, කාර්යයන් භාවිතා කළ යුතුය.

මේ සඳහා විසඳුමක් ලබා දීමට මෑතකදී මට බල කෙරුනේ, විචල්‍යයන් සහ ශ්‍රිතයන්ගේ අර්ථ දැක්වීම් මුද්‍රණය කිරීම සඳහා කෙටි විධාන කිහිපයක් නිර්මාණය කිරීමට මට අවශ්‍ය වීමයි. ඒ නිසා මම ඒ සඳහා කාර්යයන් කිහිපයක් ලිව්වා. කෙසේ වෙතත්, සමහර විචල්‍යයන් ඇත, ඒවා ශ්‍රිත ඇමතුමකින්ම වෙනස් වේ (හෝ විය හැකිය). ඒවා අතර:

FUNCNAME BASH_SOURCE BASH_LINENO BASH_ARGC BASH_ARGV

විචල්‍ය defns මුද්‍රණය කිරීම සඳහා මා භාවිතා කළ මූලික විධානය (ශ්‍රිතයක). set විධානය මඟින් ආකෘති ප්‍රතිදානයේදී:

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

උදා:

> V=voodoo
sv V
V=voodoo

ගැටලුව: මෙය ඉහත සඳහන් විචල්‍යයන්ගේ අර්ථකථන වත්මන් සන්දර්භය තුළ මුද්‍රණය නොකෙරේ , උදා: අන්තර්ක්‍රියාකාරී ෂෙල් විමසුමක් තුළ (හෝ කිසිදු ක්‍රියාකාරී ඇමතුමක නොවේ නම්), FUNCNAME අර්ථ දක්වා නැත. නමුත් මගේ ක්‍රියාකාරිත්වය මට වැරදි තොරතුරු කියයි:

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

මා විසින් ඉදිරිපත් කරන ලද එක් විසඳුමක් අනෙක් අය විසින් මෙම මාතෘකාව පිළිබඳ සඳහන් කර ඇත. විචල්ය defns., සහ එක් තර්කයක් පමණක් අවශ්ය වන මෙම නිශ්චිත විධානය සඳහා මම මෙය කළෙමි:

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

එමඟින් නිවැරදි ප්‍රතිදානය (කිසිවක් නැත) සහ ප්‍රති result ල තත්ත්වය (අසත්‍යය) ලබා දෙයි:

> 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 [@] use" භාවිතා කරන්න.

ඔබට "$ #" අවශ්‍ය නම්, "$ {# CMD_ARGV [@] use" භාවිතා කරන්න.

ආදිය.

වරක් මම විනෝදජනක ව්‍යාපෘතියක් කළ අතර මම තවමත් එය භාවිතා කරමි. cpවිධාන කෝස් හරහා ලිපිගොනු පිටපත් කරන අතර එය කිසියම් සජීවීකරණයක් 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

ඒක මේ වගේ

චක්‍රීය සජීවිකරණය)

පරාමිතීන් ගැනීම සඳහා, ඔබ කාර්යයන් භාවිතා කළ යුතුය!

කෙසේ වෙතත් al al අන්වර්ථය ක්‍රියාත්මක කිරීමේදී සහ පැන යාම වෙනුවට අන්වර්ථය නිර්මාණය කිරීමේදී අර්ථ නිරූපණය කරන්න. මෙම ගැටළුව විසඳන්නේ කෙසේද?

මෙම ගැටළුවෙන් මිදීමට ඔබ අන්වර්ථයක් වෙනුවට ෂෙල් ක්‍රියාකාරිත්වය භාවිතා කළ යුතුය. ඔබට පහත පරිදි foo යන්න අර්ථ දැක්විය හැකිය:

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

හෝ

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

අවසාන වශයෙන්, පහත දැක්වෙන වාක්‍ය ඛණ්ඩය භාවිතා කර ඔබේ foo () අමතන්න:

foo arg1 arg2 argN

ඔබගේ foo () ~/.bash_profileහෝ ~/.zshrcගොනුවට එක් කිරීමට වග බලා ගන්න .

ඔබේ නඩුවේදී, මෙය ක්‍රියාත්මක වනු ඇත

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

මෙන්න උදාහරණය:

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

ඉතා වැදගත්:

1. පසු {හා පෙර අවකාශයක් }ඇත.
2. ඒ නිසා එය ;අනුක්රමය එක් එක් විධානයට පසුව. අවසාන විධානයෙන් පසුව ඔබට මෙය අමතක වුවහොත්, >ඒ වෙනුවට ඔබ විමසනු ඇත!
3. තර්කය උපුටා දැක්වීම්වල කොටා ඇත "$1"

මෑන් පිටුවේ මෙම උපුටා දැක්වීම මගින් දැනටමත් ප්‍රමාණවත් ලෙස දායක වී ඇති සහ සනාථ කර ඇති පරිදි කාර්යයන් ඇත්ත වශයෙන්ම සෑම විටම පාහේ පිළිතුරකි: "සෑම අරමුණක් සඳහාම අන්වර්ථයන් ෂෙල් ශ්‍රිත මගින් අභිබවා යයි."

සම්පූර්ණත්වය සඳහා සහ මෙය ප්‍රයෝජනවත් විය හැකි නිසා (තරමක් සැහැල්ලු වාක්‍ය ඛණ්ඩය) පරාමිතිය (අන්වර්ථය) අන්වර්ථය අනුගමනය කරන විට ඒවා තවමත් භාවිතා කළ හැකි බව සටහන් කළ හැකිය (මෙය OP හි අවශ්‍යතාවයට විසඳුම් නොදෙන නමුත්). මෙය උදාහරණයකින් නිරූපණය කිරීම පහසුය:

alias ssh_disc='ssh -O stop'

smth වැනි ටයිප් කිරීමට මට ඉඩ දෙයි ssh_disc myhost, එය අපේක්ෂිත පරිදි පුළුල් වේ:ssh -O stop myhost

සංකීර්ණ තර්ක විධාන සඳහා මෙය ප්‍රයෝජනවත් වේ (මගේ මතකය එය තවදුරටත් භාවිතා නොකරයි ...)

අනෙක් ඒවා මෙහි පෙන්වා ඇති පරිදි ශ්‍රිත සහ අන්වර්ථ යන දෙකටම පරාමිතීන් භාවිතා කළ හැකිය. මීට අමතරව, මම තවත් අංශ කිහිපයක් පෙන්වා දීමට කැමැත්තෙමි:

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 /) දෘශ්‍ය / ක්‍රියාත්මක කළ හැකි වීමයි. එහිදී ශ්‍රිතයක් / අන්වර්ථයක් භාවිතා කිරීමට පෙර එය ලබා ගත යුතුය. උදාහරණයක් ලෙස, ඔබ function / .bash_profile හෝ for / .bashrc සඳහා ශ්‍රිතයක් තබයිbash නමුත් පසුව වෙනත් මාරු වන්න (එනම්zsh) එවිට ශ්‍රිතය තවදුරටත් නොපෙනේ. එබැවින්, ඔබ සැක සහිත විට, එතීමේ පිටපතක් සෑම විටම වඩාත්ම විශ්වාසදායක සහ අතේ ගෙන යා හැකි විසඳුම වේ.

වෙනත් අය විසින් දැනටමත් පෙන්වා දී ඇති පරිදි, ශ්‍රිතයක් භාවිතා කිරීම හොඳම පුහුණුව ලෙස සැලකිය යුතුය.

කෙසේ වෙතත්, මෙන්න තවත් ප්රවේශයක්, උත්තේජනය කිරීම xargs:

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

ධාරාවන් නැවත හරවා යැවීම සම්බන්ධයෙන් මෙය අතුරු ආබාධ ඇති බව සලකන්න.

ලිපිගොනු මකා දැමීම වෙනුවට කුණු කූඩයට ගෙනයාමට අන්වර්ථය නිර්මාණය කිරීම පිළිබඳ ප්‍රශ්නයට නිශ්චිත පිළිතුරක් ලබා දීම සඳහා:

alias rm="mv "$1" -t ~/.Trash/"

ඕෆ්කෝර්ස් ඔබ මුලින්ම නිර්මාණය කළ යුතුයි.

ඉන්පසු පහත විධානය දෙන්න:

$rm <filename>
$rm <dirname>

ඔබට කිසිවක් කිරීමට අවශ්‍ය නැත, අන්වර්ථය මෙය ස්වයංක්‍රීයව කරයි.

උදාහරණයක් ලෙස, මට git pull origin master පරාමිතිකරණය කිරීමට අවශ්‍ය නම්, මට පහත දැක්වෙන පරිදි අන්වර්ථයක් නිර්මාණය කළ හැකිය:

alias gpull = 'git pull origin '

ඇත්ත වශයෙන්ම එය අමතන විට, ඔබට 'මාස්ටර්' (ශාඛා නාමය) පරාමිතියක් ලෙස සම්මත කළ හැකිය,

gpull master
//or any other branch
gpull mybranch