Сделать псевдоним Bash, который принимает параметр?
Я использовал CShell ( csh), который позволяет создавать псевдоним, который принимает параметр. Запись была что-то вроде
alias junk="mv \\!* ~/.Trash"
В Bash это не похоже на работу. Учитывая, что Bash обладает множеством полезных функций, я предполагаю, что эта функция была реализована, но мне интересно, как это сделать.
27 ответов
Псевдоним 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
Уточняя ответ выше, вы можете получить 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 просто добавляет второе имя для того, что уже существует. Функциональность, которую хочет ОП - это 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='function _mkcd(){mkdir "$1"; cd "$1"}; _mkcd'
Вы должны поместить двойные кавычки вокруг "1 $", потому что одинарные кавычки не будут работать.
Однажды я сделал забавный проект и до сих пор им пользуюсь. Пока я копирую файлы через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
Это похоже на это
Циклическая анимация)
Вот ссылка на упомянутый выше цветной скрипт. И новый цикл анимации)
Альтернативное решение состоит в том, чтобы использовать маркер, инструмент, который я недавно создал, который позволяет вам "закладывать" шаблоны команд и легко размещать курсор на заполнителях команд:
Я обнаружил, что большую часть времени я использую функции оболочки, поэтому мне не нужно снова и снова писать часто используемые команды в командной строке. Проблема использования функций для этого варианта использования заключается в добавлении новых терминов в мой командный словарь и необходимости запоминать, на какие параметры функций ссылаются в реальной команде. Цель маркера - устранить это умственное бремя.
Синтаксис:
alias shortName="your custom command here"
Пример:
alias tlogs='_t_logs() { tail -f ../path/$1/to/project/logs.txt ;}; _t_logs'
Псевдоним Bash абсолютно не принимает параметры. Я просто добавил псевдоним для создания нового приложения для реагирования, которое принимает имя приложения в качестве параметра. Вот мой процесс:
Откройте bash_profile для редактирования в nano
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"
Сохраните и выйдите из редактора nano
ctrl+o для записи (нажмите Enter); ctrl+x для выхода
Сообщите терминалу, что нужно использовать новые псевдонимы в.bash_profile
source /.bash_profile
Это оно! Теперь вы можете использовать свои новые псевдонимы
Вот три примера функций, которые у меня есть в моем ~/.bashrc это псевдонимы, которые принимают параметр:
#Utility required by all below functions.
#https://stackru.com/questions/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://stackru.com/a/3232082/2736496
- Alias w/param: https://stackru.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://stackru.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?
- Фактические разрывы строк: /questions/13076445/kak-dobavit-razryiv-stroki-dlya-komandyi-chteniya/13076458#13076458
- Псевдоним с параметром: /questions/35813232/sdelat-psevdonim-bash-kotoryij-prinimaet-parametr/35813252#35813252 (еще один ответ на этот вопрос)
- ИСТОРИЯ: https://superuser.com/questions/232885/can-you-share-wisdom-on-using-histignore-in-bash
- Да / нет: /questions/8502530/v-bash-kak-dobavit-vyi-uverenyi-yn-v-lyubuyu-komandu-ili-psevdonim/8502561#8502561
- Удалить все соответствующие элементы из истории: https://unix.stackexchange.com/questions/57924/how-to-delete-commands-in-history-matching-a-given-string
- Нулевая / пустая строка: http://tldp.org/LDP/abs/html/comparison-ops.html
С уважением ко всем, кто говорит, что нельзя вставлять параметр в середину псевдонима, я только что протестировал его и обнаружил, что он действительно работает.
псевдоним mycommand = "python3 "$1" script.py --folderoutput РЕЗУЛЬТАТЫ /"
когда я затем запустил mycommand foobar, он работал так же, как если бы я набрал команду от руки.
NB: В случае, если идея не очевидна, плохая идея использовать псевдонимы для чего-либо, кроме псевдонимов, первый из которых - "функция в псевдониме", а второй - "трудно читаемый редирект / источник". Кроме того, есть недостатки (которые, я думал, будут очевидны, но на случай, если вы запутаетесь: я не имею в виду, что они действительно будут использоваться... где угодно!)
................................................................................................................................................
Я отвечал на это раньше, и всегда было так в прошлом:
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 <name_of_your_alias>_$argname="<command> $argname"
и использовать его:
$<name_of_your_alias>_$argname
например, псевдоним
cat файл под названием
hello.txt:
- (псевдоним
CAT_FILE_) - и
$f(это$argname, который в этом примере является файлом)
$ alias CAT_FILE_$f="cat $f"
$ echo " " >> hello.txt
$ echo "hello there!" >> hello.txt
$ echo " " >> hello.txt
$ cat hello.txt
hello there!
Контрольная работа:
CAT_FILE_ hello.txt
Существуют законные технические причины, чтобы хотеть обобщенного решения проблемы псевдонима bash, не имеющего механизма для принятия произвольных аргументов. Одна из причин заключается в том, что на команду, которую вы хотите выполнить, негативно повлияют изменения в среде, возникшие в результате выполнения функции. Во всех остальных случаях следует использовать функции.
Что недавно заставило меня попытаться решить эту проблему, так это то, что я хотел создать несколько сокращенных команд для печати определений переменных и функций. Поэтому я написал несколько функций для этой цели. Однако существуют определенные переменные, которые (или могут быть) изменены самим вызовом функции. Среди них:
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:
# (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[@]}".
И т.п.
Вы можете создать анонимную функцию внутри своего псевдонима:
alias mkcd='(){mkdir "$1";cd "$1";}'
Вам нужно вокруг$1для обработки имен с пробелами в них. Внешний'избежать необходимости побега и$. Вы также можете использовать все"с кучей побегов:
alias mkcd="(){mkdir \"\$1\";cd \"\$1\";}"
Я думаю, что это чище, чем несколько других ответов, создающих именованную функцию.
Любой из них имеет одинаковое использование.mkcd fooволяmkdir "foo"с последующимcd "foo"
Решение с подкомандами:
d () {
if [ $# -eq 0 ] ; then
docker
return 0
fi
CMD=$1
shift
case $CMD in
p)
docker ps --all $@
;;
r)
docker run --interactive --tty $@
;;
rma)
docker container prune
docker image prune --filter "dangling=true"
;;
*)
docker $CMD $@
;;
esac
return $?
}
С использованием:
$ d r my_image ...
Называется:
docker run --interactive --tty my_image ...
Чтобы дать конкретный ответ на вопрос о создании псевдонима для перемещения файлов в корзину вместо их удаления:
alias rm="mv "$1" -t ~/.Trash/"
Конечно, сначала вам нужно создать каталог ~/.Trash.
Затем просто дайте следующую команду:
$rm <filename>
$rm <dirname>
Как уже отмечалось другими, использование функции следует рассматривать как лучшую практику.
Однако есть другой подход, использующий xargs:
alias junk="xargs -I "{}" -- mv "{}" "~/.Trash" <<< "
Обратите внимание, что это имеет побочные эффекты в отношении перенаправления потоков.
Вот пример:
alias gcommit='function _f() { git add -A; git commit -m "$1"; } ; _f'
Очень важный:
- После
{и раньше}. - E сть
;после каждой команды по порядку. Если вы забудете это после последней команды, вы увидите>подскажите вместо этого! - Аргумент заключен в кавычки как
"$1"
Вот еще один подход с использованием
read. Я использую это для грубого поиска файла по фрагменту его имени, игнорируя сообщения «доступ запрещен».
alias loc0='{ IFS= read -r x; find . -iname "*" -print 2>/dev/null | grep $x;} <<<'
Простой пример:
$ { IFS= read -r x; echo "1 $x 2 ";} <<< "a b"
1 a b 2
Обратите внимание, что это преобразует аргумент как строку в переменную (и). Для этого можно использовать несколько параметров в кавычках, разделенных пробелами:
$ { read -r x0 x1; echo "1 ${x0} 2 ${x1} 3 ";} <<< "a b"
1 a 2 b 3
На самом деле, функции почти всегда являются ответом, который уже достаточно подробно описан в цитате из справочной страницы: "Практически для любых целей псевдонимы заменяются функциями оболочки".
Для полноты и потому, что это может быть полезно (немного более легкий синтаксис), можно отметить, что, когда параметр (и) следуют за псевдонимом, они все еще могут использоваться (хотя это не будет соответствовать требованию OP). Это, вероятно, проще всего продемонстрировать на примере:
alias ssh_disc='ssh -O stop'
позволяет мне печатать что-то вроде ssh_disc myhost, который расширяется, как ожидается, как: ssh -O stop myhost
Это может быть полезно для команд, которые принимают сложные аргументы (моя память уже не та, что используется)...
Для получения параметров, вы должны использовать функции!
Однако $@ интерпретируется при создании псевдонима, а не во время выполнения псевдонима, и экранирование $ также не работает. Как мне решить эту проблему?
Вам нужно использовать функцию оболочки вместо псевдонима, чтобы избавиться от этой проблемы. Вы можете определить foo следующим образом:
function foo() { /path/to/command "$@" ;}
ИЛИ ЖЕ
foo() { /path/to/command "$@" ;}
Наконец, вызовите вашу функцию foo(), используя следующий синтаксис:
foo arg1 arg2 argN
Убедитесь, что вы добавили свой foo() в ~/.bash_profile или же ~/.zshrc файл.
В вашем случае это будет работать
function trash() { mv $@ ~/.Trash; }
Хотя функция обычно является хорошим выбором, как говорили другие. Но я хотел бы отметить, что есть случаи, когда функция не работает, а псевдоним делает, или другие случаи, сценарий-обертка - лучший выбор.
псевдоним работает, функция - нет, и все же можно передавать параметры.
Например: я хочу сделать ярлык для активации conda и источник среды conda в одной команде. Было бы соблазн сделать это:
function conda_activate(){
export PATH="$PATH:/path/to/conda"
envname=$1
if [ "x$envname" -ne "x" ]; then
source activate "$envname"
fi
}
Это не работает, как задумано. Если один побежал conda_activate myenv, source Команда выполняет поиск, но немедленно завершает работу, и у запущенной оболочки нет среды.
Рабочее решение выглядит так:
function conda_activate(){
export PATH="$PATH:/path/to/conda"
# do some other things
}
alias conda_env='conda_activate; source activate'
# usage example
conda_env myenv
скрипт-обёртка - лучший выбор
Несколько раз со мной случалось, что псевдоним или функция не могут быть найдены при входе через ssh или с включением переключения имен пользователей или многопользовательской среды. Существуют советы и рекомендации по работе с файлами точек поиска, например, этот интересный: alias sd='sudo ' позволяет это alias install='sd apt-get install' работать как положено Обратите внимание на дополнительное место в sd='sudo ', Но когда вы сомневаетесь, скрипт-обертка всегда является наиболее надежным и переносимым решением.
Вам не нужно ничего делать, псевдоним делает это автоматически.
Например, если я хочу сделать параметр git pull origin master параметризованным, я могу просто создать псевдоним следующим образом:
alias gpull = 'git pull origin '
и при его вызове вы можете передать master (имя ветки) в качестве параметра, например:
gpull master
//or any other branch
gpull mybranch
alias junk="delay-arguments mv _ ~/.Trash"
delay-arguments сценарий:
#!/bin/bash
# Example:
# > delay-arguments echo 1 _ 3 4 2
# 1 2 3 4
# > delay-arguments echo "| o n e" _ "| t h r e e" "| f o u r" "| t w o"
# | o n e | t w o | t h r e e | f o u r
RAW_ARGS=("$@")
ARGS=()
ARG_DELAY_MARKER="_"
SKIPPED_ARGS=0
SKIPPED_ARG_NUM=0
RAW_ARGS_COUNT="$#"
for ARG in "$@"; do
#echo $ARG
if [[ "$ARG" == "$ARG_DELAY_MARKER" ]]; then
SKIPPED_ARGS=$((SKIPPED_ARGS+1))
fi
done
for ((I=0; I<$RAW_ARGS_COUNT-$SKIPPED_ARGS; I++)); do
ARG="${RAW_ARGS[$I]}"
if [[ "$ARG" == "$ARG_DELAY_MARKER" ]]; then
MOVE_SOURCE_ARG_NUM=$(($RAW_ARGS_COUNT-$SKIPPED_ARGS+$SKIPPED_ARG_NUM))
MOVING_ARG="${RAW_ARGS[$MOVE_SOURCE_ARG_NUM]}"
#echo "Moving arg: $MOVING_ARG"
ARGS+=("$MOVING_ARG")
SKIPPED_ARG_NUM=$(($SKIPPED_ARG_NUM+1))
else
ARGS+=("$ARG")
fi
done
#for ARG in "${ARGS[@]}"; do
#echo "ARGN: $ARG"
#done
#echo "RAW_ARGS_COUNT: $RAW_ARGS_COUNT"
#echo "SKIPPED_ARGS: $SKIPPED_ARGS"
#echo "${ARGS[@]}"
QUOTED_ARGS=$(printf ' %q' "${ARGS[@]}")
eval "${QUOTED_ARGS[@]}"
Однако вам не нужны функции при создании псевдонимов в .bashrc файл. Например
# create an alias that takes port-number by the user
alias serve="python -m SimpleHTTPServer $1"
После внесения изменений в файл.bashrc обязательно введите следующую команду.
~$ source .bashrc
Вы должны быть в состоянии использовать это так
~$ serve 8998