Membuat alias Bash yang menggunakan parameter?

Saya dulu menggunakan CShell (csh), yang memungkinkan Anda membuat alias yang mengambil parameter. Notasi itu seperti sesuatu

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

Di Bash, ini sepertinya tidak berhasil. Mengingat bahwa Bash memiliki banyak fitur yang berguna, saya akan berasumsi bahwa yang ini telah diterapkan tetapi saya bertanya-tanya bagaimana caranya.

Bash alias tidak langsung menerima parameter. Anda harus membuat fungsi.

aliastidak menerima parameter tetapi fungsi dapat dipanggil seperti alias. Sebagai contoh:

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


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

Omong-omong, fungsi Bash yang ditentukan dalam .bashrcfile Anda dan lainnya tersedia sebagai perintah di dalam shell Anda. Jadi misalnya Anda dapat memanggil fungsi sebelumnya seperti ini

$ myfunction original.conf my.conf

Menyempurnakan jawaban di atas, Anda bisa mendapatkan sintaks 1 baris seperti yang Anda bisa untuk alias, yang lebih nyaman untuk definisi ad-hoc dalam file shell atau .bashrc:

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

bash$ myfunction original.conf my.conf

Jangan lupa tanda titik koma sebelum tanda kurung tutup. Demikian pula, untuk pertanyaan aktual:

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

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

Atau:

bash$ junk() { for item in "$@" ; do echo "Trashing: $item" ; mv "$item" ~/.Trash/; done; }

Pertanyaannya adalah salah. Anda tidak membuat alias yang mengambil parameter karena aliashanya menambahkan nama kedua untuk sesuatu yang sudah ada. Fungsionalitas yang diinginkan OP adalah functionperintah untuk membuat fungsi baru. Anda tidak perlu alias fungsi karena fungsi sudah memiliki nama.

Saya pikir Anda menginginkan sesuatu seperti ini:

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

Itu dia! Anda dapat menggunakan parameter $ 1, $ 2, $ 3, dll, atau isi semuanya dengan $ @

TL; DR: Lakukan ini sebagai gantinya

Jauh lebih mudah dan lebih mudah dibaca untuk menggunakan fungsi daripada alias untuk meletakkan argumen di tengah-tengah perintah.

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

Jika Anda terus membaca, Anda akan mempelajari hal-hal yang tidak perlu Anda ketahui tentang pemrosesan argumen shell. Pengetahuan itu berbahaya. Dapatkan saja hasil yang Anda inginkan, sebelum sisi gelap selamanya mengendalikan nasib Anda.

Klarifikasi

bashalias melakukan menerima argumen, tetapi hanya pada akhir :

$ alias speak=echo
$ speak hello world
hello world

Menempatkan argumen ke tengah - tengah komando via aliasmemang mungkin tetapi itu menjadi jelek.

Jangan coba ini di rumah, anak-anak!

Jika Anda suka menghindari batasan dan melakukan apa yang orang lain katakan tidak mungkin, inilah resepnya. Hanya saja, jangan salahkan saya jika rambut Anda menjadi kusut dan wajah Anda berakhir dengan jelaga-gaya ilmuwan gila.

Solusinya adalah meneruskan argumen yang aliashanya menerima di akhir ke pembungkus yang akan memasukkannya di tengah dan kemudian jalankan perintah Anda.

Solusi 1

Jika Anda benar-benar menentang penggunaan fungsi, Anda dapat menggunakan:

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

Anda dapat mengganti $@dengan $1jika Anda hanya menginginkan argumen pertama.

Penjelasan 1

Ini menciptakan fungsi sementara f, yang meneruskan argumen (catatan yang fdisebut di bagian paling akhir). The unset -fmenghilangkan definisi fungsi sebagai alias dijalankan sehingga tidak berkeliaran setelah itu.

Solusi 2

Anda juga dapat menggunakan subkulit:

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

Penjelasan 2

Alias ​​membangun perintah seperti:

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

Komentar:

• Pengganti _diperlukan, tetapi bisa berupa apa saja. Ini akan diatur ke sh's $0, dan diperlukan sehingga pertama dari argumen yang diberikan pengguna tidak bisa dikonsumsi. Demonstrasi:

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

• Kutipan tunggal di dalam tanda kutip tunggal diperlukan. Berikut ini contohnya yang tidak bekerja dengan tanda kutip ganda:

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

  Di sini nilai-nilai shell interaktif $0dan $@diganti menjadi dua kali dikutip sebelum diteruskan sh. Inilah buktinya:

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

  Kutipan tunggal memastikan bahwa variabel-variabel ini tidak ditafsirkan oleh shell interaktif, dan diteruskan secara harfiah sh -c.

  Anda dapat menggunakan tanda kutip ganda dan \$@, tetapi praktik terbaik adalah mengutip argumen Anda (karena mungkin mengandung spasi), dan \"\$@\"terlihat lebih jelek, tetapi dapat membantu Anda memenangkan kontes kebingungan di mana rambut yang kusut adalah prasyarat untuk masuk.

Solusi alternatif adalah dengan menggunakan marker , alat yang saya buat baru-baru ini yang memungkinkan Anda untuk "mem-bookmark" templat perintah dan dengan mudah menempatkan kursor pada penampung perintah:

Saya menemukan bahwa sebagian besar waktu, saya menggunakan fungsi shell jadi saya tidak perlu menulis perintah yang sering digunakan lagi dan lagi di baris perintah. Masalah menggunakan fungsi untuk use case ini, adalah menambahkan istilah baru ke kosakata perintah saya dan harus mengingat parameter fungsi apa yang merujuk pada perintah-nyata. Tujuan penanda adalah untuk menghilangkan beban mental itu.

Yang harus Anda lakukan adalah membuat fungsi di dalam alias:

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

Anda harus menempatkan tanda kutip ganda sekitar "$ 1" karena tanda kutip tunggal tidak akan berfungsi.

Berikut adalah tiga contoh fungsi yang saya miliki di saya ~/.bashrc, yang pada dasarnya alias yang menerima parameter:

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

Referensi:

• Memotong spasi putih dari string: Bagaimana cara memangkas spasi putih dari variabel Bash?
• Jeda baris aktual: https://stackoverflow.com/a/4296147/2736496
• Alias ​​w / param: https://stackoverflow.com/a/7131683/2736496 (jawaban lain dalam pertanyaan ini)
• HISTIGNORE: /superuser/232885/can-you-share-wisdom-on-using-histignore-in-bash
• Y / N prompt: https://stackoverflow.com/a/3232082/2736496
• Hapus semua item yang cocok dari riwayat: /unix/57924/how-to-delete-commands-in-history-matching-a-given-string
• Apakah string nol / kosong: http://tldp.org/LDP/abs/html/comparison-ops.html

Bash alias benar-benar menerima parameter. Saya baru saja menambahkan alias untuk membuat aplikasi reaksi baru yang menerima nama aplikasi sebagai parameter. Inilah proses saya:

Buka bash_profile untuk mengedit di nano

nano /.bash_profile

Tambahkan alias Anda, satu per baris:

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

catatan: "$ @" menerima parameter yang diteruskan seperti "creact my-new-app"

Simpan dan keluar dari editor nano

ctrl + o untuk menulis (tekan enter); ctrl + x untuk keluar

Katakan terminal untuk menggunakan alias baru di .bash_profile

source /.bash_profile

Itu dia! Anda sekarang dapat menggunakan alias baru Anda

NB: Jika idenya tidak jelas, itu ide yang buruk untuk menggunakan alias untuk apa pun kecuali alias, yang pertama adalah 'fungsi dalam alias' dan yang kedua adalah 'sulit dibaca redirect / sumber'. Juga, ada kekurangan (yang saya pikir akan menjadi jelas, tetapi kalau-kalau Anda bingung: Saya tidak bermaksud mereka benar-benar digunakan ... di mana saja!)

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

Saya sudah menjawab ini sebelumnya, dan selalu seperti ini di masa lalu:

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

yang bagus dan bagus, kecuali Anda menghindari penggunaan semua fungsi secara bersamaan. dalam hal ini Anda dapat memanfaatkan kemampuan luas bash untuk mengarahkan ulang teks:

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

Keduanya memiliki panjang yang sama memberi atau mengambil beberapa karakter.

The nyata kicker adalah perbedaan waktu, bagian atas menjadi 'metode fungsi dan bagian bawah menjadi metode 'redirect-sumber'. Untuk membuktikan teori ini, waktunya berbicara untuk dirinya sendiri:

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

Ini adalah bagian bawah dari sekitar 200 hasil, yang dilakukan secara berkala. Tampaknya pembuatan / penghancuran fungsi membutuhkan lebih banyak waktu daripada pengalihan. Semoga ini akan membantu pengunjung masa depan untuk pertanyaan ini (tidak ingin menyimpannya untuk saya sendiri).

Jika Anda mencari cara umum untuk menerapkan semua params ke suatu fungsi, bukan hanya satu atau dua atau beberapa jumlah hardcode lainnya, Anda dapat melakukannya dengan cara ini:

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

Jadi pada contoh di atas, saya meneruskan semua parameter dari saat saya menjalankan runjaralias.

Sebagai contoh, jika saya melakukannya runjar hi thereakan benar-benar berjalan java -jar myjar.jar hi there. Jika saya melakukannya runjar one two threeakan berjalan java -jar myjar.jar one two three.

Saya suka $@solusi berbasis ini karena ia bekerja dengan sejumlah params.

Dengan hormat kepada semua yang mengatakan Anda tidak dapat memasukkan parameter di tengah alias saya baru saja mengujinya dan ternyata itu berhasil.

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

ketika saya menjalankan perintah foobar saya, perintah itu bekerja persis seperti jika saya mengetik perintah itu dengan tangan.

Ada alasan teknis yang sah untuk menginginkan solusi umum untuk masalah bash alias tidak memiliki mekanisme untuk mengambil reposisi argumen sewenang-wenang. Salah satu alasannya adalah jika perintah yang ingin Anda jalankan akan terpengaruh oleh perubahan lingkungan yang dihasilkan dari menjalankan fungsi. Dalam semua kasus lain , fungsi harus digunakan.

Apa yang baru-baru ini memaksa saya untuk mencoba solusi untuk ini adalah bahwa saya ingin membuat beberapa perintah singkat untuk mencetak definisi variabel dan fungsi. Jadi saya menulis beberapa fungsi untuk tujuan itu. Namun, ada variabel tertentu yang (atau mungkin) diubah oleh pemanggilan fungsi itu sendiri. Diantaranya adalah:

FUNCNAME BASH_SOURCE BASH_LINENO BASH_ARGC BASH_ARGV

Perintah dasar yang saya gunakan (dalam suatu fungsi) untuk mencetak variabel defns. dalam bentuk output oleh perintah set adalah:

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

Misalnya:

> V=voodoo
sv V
V=voodoo

Masalah: Ini tidak akan mencetak definisi variabel yang disebutkan di atas karena mereka berada dalam konteks saat ini , misalnya, jika dalam prompt shell interaktif (atau tidak dalam panggilan fungsi apa pun), FUNCNAME tidak didefinisikan. Tetapi fungsi saya memberi tahu saya informasi yang salah:

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

Salah satu solusi yang saya temukan telah disebutkan oleh orang lain di posting lain tentang topik ini. Untuk perintah khusus ini untuk mencetak variabel, dan yang hanya membutuhkan satu argumen, saya melakukan ini:

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

Yang memberikan output yang benar (tidak ada), dan status hasil (salah):

> asv FUNCNAME
> echo $?
1

Namun, saya masih merasa harus menemukan solusi yang berfungsi untuk sejumlah argumen yang berubah-ubah.

Solusi Umum Untuk Melewati Argumen Sewenang-wenang Pada Perintah Bash Alias:

# (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".

Misalnya:

> . 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

Satu hal yang menyenangkan tentang solusi ini adalah bahwa semua trik khusus yang digunakan untuk menangani parameter posisi (argumen) untuk perintah akan bekerja ketika menyusun perintah yang terperangkap. Satu-satunya perbedaan adalah sintaks array harus digunakan.

Misalnya,

Jika Anda ingin "$ @", gunakan "$ {CMD_ARGV [@]}".

Jika Anda ingin "$ #", gunakan "$ {# CMD_ARGV [@]}".

Dll

Setelah saya melakukan beberapa proyek yang menyenangkan dan saya masih menggunakannya. Ini menunjukkan beberapa animasi sementara saya menyalin file melalui cpperintah karena cptidak menunjukkan apa-apa dan itu agak frustasi. Jadi saya membuat alias ini

alias cp="~/SCR/spiner cp"

Dan ini adalah skrip spiner

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

Terlihat seperti ini

Animasi bersepeda)

Untuk mengambil parameter, Anda harus menggunakan fungsi!

Namun $ @ diinterpretasikan ketika membuat alias alih-alih selama eksekusi alias dan melarikan diri $ juga tidak berfungsi. Bagaimana saya mengatasi masalah ini?

Anda perlu menggunakan fungsi shell alih-alih alias untuk menyingkirkan masalah ini. Anda dapat mendefinisikan foo sebagai berikut:

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

ATAU

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

Terakhir, panggil foo Anda () menggunakan sintaks berikut:

foo arg1 arg2 argN

Pastikan Anda menambahkan foo () ke ~/.bash_profileatau ~/.zshrcfile Anda.

Dalam kasus Anda, ini akan berhasil

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

Fungsinya memang hampir selalu merupakan jawaban karena sudah banyak dikontribusikan dan dikonfirmasi oleh kutipan dari halaman manual ini: "Untuk hampir setiap tujuan, alias digantikan oleh fungsi shell."

Untuk kelengkapan dan karena ini dapat berguna (sintaksis sedikit lebih ringan) dapat dicatat bahwa ketika parameter mengikuti alias, mereka masih dapat digunakan (meskipun ini tidak akan memenuhi persyaratan OP). Ini mungkin yang paling mudah ditunjukkan dengan contoh:

alias ssh_disc='ssh -O stop'

memungkinkan saya untuk mengetik seperti ssh_disc myhost, yang akan diperluas seperti yang diharapkan:ssh -O stop myhost

Ini bisa berguna untuk perintah yang membutuhkan argumen kompleks (ingatan saya tidak seperti apa lagi ...)

Baik fungsi dan alias dapat menggunakan parameter seperti yang telah ditunjukkan di sini. Selain itu, saya ingin menunjukkan beberapa aspek lain:

1. fungsi berjalan dalam ruang lingkupnya sendiri, alias ruang lingkup saham

Mungkin berguna untuk mengetahui perbedaan ini jika Anda perlu menyembunyikan atau mengekspos sesuatu. Ini juga menunjukkan bahwa fungsi adalah pilihan yang lebih baik untuk enkapsulasi.

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 

Keluaran:

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. skrip wrapper adalah pilihan yang lebih baik

Telah terjadi pada saya beberapa kali bahwa alias atau fungsi tidak dapat ditemukan ketika masuk melaluissh atau melibatkan beralih nama pengguna atau lingkungan multi-pengguna. Ada tips dan trik dengan sumber file dot, atau yang menarik ini dengan alias: alias sd='sudo 'memungkinkan alias berikutnya ini alias install='sd apt-get install'berfungsi seperti yang diharapkan (perhatikan ruang tambahan di sd='sudo '). Namun, skrip wrapper berfungsi lebih baik daripada fungsi atau alias dalam kasus seperti ini. Keuntungan utama dengan skrip wrapper adalah skrip ini dapat dilihat / dieksekusi untuk di bawah jalur yang dimaksudkan (yaitu / usr / loca / bin /) di mana sebagai fungsi / alias perlu bersumber sebelum dapat digunakan. Misalnya, Anda meletakkan fungsi dalam ~ / .bash_profile atau ~ / .bashrc untuk bash, tetapi kemudian beralih ke shell lain (yaituzsh) maka fungsinya tidak terlihat lagi. Jadi, ketika Anda ragu, skrip wrapper selalu merupakan solusi yang paling andal dan portabel.

Inilah contohnya:

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

Sangat penting:

1. Ada ruang setelah {dan sebelumnya }.
2. Ada ;setelah setiap perintah secara berurutan. Jika Anda lupa ini setelah perintah terakhir, Anda akan melihat >prompt sebagai gantinya!
3. Argumen terlampir dalam tanda kutip sebagai "$1"

Seperti yang telah ditunjukkan oleh orang lain, menggunakan fungsi harus dianggap praktik terbaik.

Namun, berikut adalah pendekatan lain, meningkatkan xargs:

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

Perhatikan bahwa ini memiliki efek samping sehubungan dengan pengalihan aliran.

Anda tidak perlu melakukan apa-apa, alias melakukan ini secara otomatis.

Sebagai contoh, jika saya ingin membuat git pull asal parameter, saya bisa membuat alias sebagai berikut:

alias gpull = 'git pull origin '

dan ketika benar-benar memanggilnya, Anda dapat mengirimkan 'master' (nama cabang) sebagai parameter, seperti ini:

gpull master
//or any other branch
gpull mybranch