Зробити псевдонім Bash, який приймає параметр?

Раніше я використовував CShell (csh), що дозволяє зробити псевдонім, який приймає параметр. Позначення було щось подібне

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

У Баша це, здається, не працює. Зважаючи на те, що 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`

До речі, функції Bash, визначені у ваших .bashrcта інших файлах, доступні як команди в межах вашої оболонки. Так, наприклад, ви можете викликати попередню функцію на зразок цієї

$ myfunction original.conf my.conf

Уточнюючи відповідь вище, ви можете отримати однорядковий синтаксис, як можна для псевдонімів, що зручніше для спеціальних визначень у оболонці або .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просто додає друге ім’я для чогось, що вже існує. Функціонал, який хоче ОП, - це functionкоманда створити нову функцію. Вам не потрібно псевдонім функції, оскільки функція вже має ім'я.

Я думаю, ти хочеш щось подібне:

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

Це воно! Ви можете використовувати параметри $ 1, $ 2, $ 3 і т.д., або просто заповнити їх усі $ @

TL; DR: Зробіть це замість цього

Набагато простіше і зрозуміліше використовувати функцію, ніж псевдонім, щоб ставити аргументи в середину команди.

$ 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дійсно можливо, але це стає некрасивим.

Не спробуйте цього вдома, дітки!

Якщо вам подобається обійти обмеження і робити те, що говорять інші, неможливо, ось рецепт. Тільки не звинувачуйте мене, якщо волосся зачарували, а обличчя закінчилося покритим у саду шаленому вченому.

Вирішення завдання полягає в тому, щоб передати аргументи, які 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
}

Список літератури:

• Обрізка пробілів з рядків: Як обрізати пробіл із змінної Bash?
• Фактичні розриви рядків: https://stackoverflow.com/a/4296147/2736496
• Псевдонім з парам: 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
• Чи є рядок null / empty: http://tldp.org/LDP/abs/html/comppare-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 "$@"'

зауважте: "$ @" приймає передані параметри типу "create my-new-app"

Збережіть та закрийте наноредактор

ctrl + o to to write (натисніть Enter); ctrl + x для виходу

Скажіть терміналу використовувати нові псевдоніми у .bash_profile

source /.bash_profile

Це воно! Тепер ви можете використовувати свої нові псевдоніми

Примітка: Якщо ідея не очевидна, погана ідея використовувати псевдоніми для будь-якого, крім псевдонімів, перший - "функція в псевдонімі", а другий - "важко читати переспрямування / джерело". Крім того, є недоліки (які, я думав , будуть очевидними, але на всякий випадок, коли ви плутаєтесь: я не маю на увазі, що вони насправді використовуються ... де завгодно!)

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

Я відповідав на це раніше, і це було завжди в минулому:

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

що добре і добре, якщо ви не уникаєте використання функцій разом. в такому випадку ви можете скористатися величезною здатністю bash для перенаправлення тексту:

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 результатів, зроблених з випадковими інтервалами. Здається, що створення / знищення функції вимагає більше часу, ніж перенаправлення. Сподіваємось, це допоможе майбутнім відвідувачам цього питання (не хотів його тримати перед собою).

Якщо ви шукаєте загальний спосіб застосувати всі параметри до функції, а не лише одну чи дві чи якусь іншу жорстко кодовану суму, ви можете зробити це таким чином:

#!/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 mycommand = "python3" $ 1 "script.py --folderoutput РЕЗУЛЬТАТИ"

коли я запустив команду foobar, він працював точно так, ніби я набрав команду з долоні.

Є обґрунтовані технічні причини, щоб хотіти узагальненого вирішення проблеми баш-псевдоніму, який не має механізму прийняття довільних аргументів. Однією з причин є те, якщо на команду, яку ви хочете виконати, негативно впливатимуть зміни в середовищі, які є результатом виконання функції. У всіх інших випадках слід використовувати функції.

Що нещодавно змусило мене спробувати вирішити це те, що я хотів створити кілька скорочених команд для друку визначень змінних та функцій. Тому я написав для цього деякі функції. Однак є певні змінні, які (або можуть бути) змінені самим викликом функції. Серед них:

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)) <<<'

Що дає правильний вихід (немає) та статус результату (помилковий):

> asv FUNCNAME
> echo $?
1

Однак я все ж відчував вимушеність знайти рішення, яке працює для довільної кількості аргументів.

Загальне рішення для передачі довільних аргументів команді Bash Aliased:

# (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 [@]}".

І т.д.

Одного разу я зробив якийсь цікавий проект, і я все ще використовую його. Він показує деяку анімацію, в той час як я копіюю файли за допомогою 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

Це виглядає приблизно так

Велосипедна анімація)

Для отримання параметрів слід використовувати функції!

Однак $ @ отримують інтерпретацію при створенні псевдоніму, а не під час виконання псевдоніма та втечі $, також не працює. Як вирішити цю проблему?

Щоб позбутися цієї проблеми, вам потрібно використовувати функцію оболонки замість псевдоніма. Ви можете визначити foo таким чином:

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

АБО

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

Нарешті, зателефонуйте до свого foo (), використовуючи наступний синтаксис:

foo arg1 arg2 argN

Переконайтеся, що ви додали foo () у файл ~/.bash_profileчи ~/.zshrcфайл.

У вашому випадку це спрацює

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

Функції насправді майже завжди є відповіддю, як це вже багато в чому сприяє і підтверджується цією цитатою зі сторінки man: "Для майже всіх цілей псевдоніми витісняються функціями оболонки".

Для повноти і тому, що це може бути корисним (незначно ситнішим синтаксисом), можна зазначити, що коли параметр (и) слідують за псевдонімом, вони все одно можуть бути використані (хоча це не відповідає вимозі ОП). Це, мабуть, найпростіше продемонструвати на прикладі:

alias ssh_disc='ssh -O stop'

дозволяє мені набрати smth like ssh_disc myhost, який розширюється, як очікувалося, як:ssh -O stop myhost

Це може бути корисно для команд, які беруть складні аргументи (моя пам’ять вже не така, якою вона використовується, t не буде ...)

І функції, і псевдоніми можуть використовувати параметри, як показали інші. Додатково хочу зазначити ще кілька аспектів:

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) функція більше не видно. Тож, коли ви сумніваєтесь, скрипт для обгортки - це завжди найнадійніше і портативне рішення.

Ось приклад:

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

Дуже важливо:

1. Існує простір після {і перед }.
2. Існує ;після кожної команди послідовно. Якщо ви забудете це після останньої команди, >замість цього з’явиться підказка!
3. Аргумент укладений у лапки як "$1"

Як вже вказували інші, використання функції слід вважати найкращою практикою.

Однак, ось ще один підхід, що використовує xargs:

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

Зауважте, що це має побічні ефекти щодо перенаправлення потоків.

Вам нічого не потрібно робити, псевдонім це робить автоматично.

Наприклад, якщо я хочу зробити git pull master master параметром, я можу просто створити псевдонім таким чином:

alias gpull = 'git pull origin '

і, фактично називаючи його, ви можете передавати "master" (назва гілки) як параметр, наприклад:

gpull master
//or any other branch
gpull mybranch