Faire un alias Bash qui prend un paramètre?

J'utilisais CShell (csh), qui vous permet de créer un alias qui accepte un paramètre. La notation était quelque chose comme

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

Dans Bash, cela ne semble pas fonctionner. Étant donné que Bash possède une multitude de fonctionnalités utiles, je suppose que celle-ci a été implémentée, mais je me demande comment.

L'alias Bash n'accepte pas directement les paramètres. Vous devrez créer une fonction.

aliasn'accepte pas les paramètres mais une fonction peut être appelée comme un alias. Par exemple:

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


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

Soit dit en passant, les fonctions Bash définies dans vos .bashrcfichiers et dans d'autres sont disponibles sous forme de commandes dans votre shell. Ainsi, par exemple, vous pouvez appeler la fonction précédente comme celle-ci

$ myfunction original.conf my.conf

En affinant la réponse ci-dessus, vous pouvez obtenir la syntaxe d'une ligne comme vous le pouvez pour les alias, ce qui est plus pratique pour les définitions ad hoc dans un shell ou des fichiers .bashrc:

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

bash$ myfunction original.conf my.conf

N'oubliez pas le point-virgule avant le crochet de fermeture de droite. De même, pour la vraie question:

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

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

Ou:

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

La question est simplement mal posée. Vous ne créez pas d'alias qui accepte des paramètres car il aliassuffit d'ajouter un deuxième nom pour quelque chose qui existe déjà. La fonctionnalité souhaitée par l'OP est la functioncommande pour créer une nouvelle fonction. Vous n'avez pas besoin d'alias la fonction car la fonction a déjà un nom.

Je pense que vous voulez quelque chose comme ça:

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

C'est ça! Vous pouvez utiliser les paramètres $ 1, $ 2, $ 3, etc., ou tout simplement les remplir avec $ @

TL; DR: faites ceci à la place

Il est beaucoup plus facile et plus lisible d'utiliser une fonction qu'un alias pour placer des arguments au milieu d'une commande.

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

Si vous continuez à lire, vous apprendrez des choses que vous n'avez pas besoin de savoir sur le traitement des arguments du shell. La connaissance est dangereuse. Obtenez juste le résultat que vous voulez, avant que le côté obscur ne contrôle à jamais votre destin.

Clarification

bashalias n'acceptent des arguments, mais seulement à la fin :

$ alias speak=echo
$ speak hello world
hello world

Mettre des arguments au milieu de la commande via aliasest en effet possible mais cela devient moche.

N'essayez pas cela à la maison, les enfants!

Si vous aimez contourner les limitations et faire ce que les autres disent est impossible, voici la recette. Ne me blâmez pas si vos cheveux se frottent et que votre visage finit par être couvert de suie.

La solution de contournement consiste à passer les arguments qui aliasn'acceptent qu'à la fin à un wrapper qui les insérera au milieu, puis exécutera votre commande.

Solution 1

Si vous êtes vraiment contre l'utilisation d'une fonction en soi, vous pouvez utiliser:

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

Vous pouvez remplacer $@par $1si vous ne voulez que le premier argument.

Explication 1

Cela crée une fonction temporaire f, à laquelle sont passés les arguments (remarque qui fest appelée à la toute fin). Le unset -fsupprime la définition de la fonction à mesure que l'alias est exécuté afin qu'il ne reste pas après.

Solution 2

Vous pouvez également utiliser un sous-shell:

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

Explication 2

L'alias crée une commande comme:

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

Commentaires:

• L'espace réservé _est obligatoire, mais il peut s'agir de n'importe quoi. Il est défini sur sh's' $0et est requis pour que le premier des arguments donnés par l'utilisateur ne soit pas consommé. Manifestation:

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

• Les guillemets simples à l'intérieur des guillemets simples sont obligatoires. Voici un exemple de non fonctionnement avec des guillemets doubles:

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

  Ici, les valeurs de l'interpréteur de commandes interactif $0et $@sont remplacées par le double entre guillemets avant d' être passées à sh. Voici la preuve:

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

  Les guillemets simples garantissent que ces variables ne sont pas interprétées par un shell interactif et sont transmises littéralement à sh -c.

  Vous pouvez utiliser des guillemets doubles et \$@, mais la meilleure pratique consiste à citer vos arguments (car ils peuvent contenir des espaces), et \"\$@\"semble encore plus laid, mais peut vous aider à gagner un concours d'obscurcissement où les cheveux ébouriffés sont une condition préalable à la participation.

Une autre solution consiste à utiliser le marqueur , un outil que j'ai créé récemment qui vous permet de "mettre en signet" des modèles de commandes et de placer facilement le curseur sur les emplacements de commande:

J'ai constaté que la plupart du temps, j'utilise des fonctions shell, donc je n'ai pas à écrire encore et encore des commandes fréquemment utilisées dans la ligne de commande. Le problème de l'utilisation des fonctions pour ce cas d'utilisation est l'ajout de nouveaux termes à mon vocabulaire de commande et le fait de devoir se souvenir des fonctions auxquelles les paramètres font référence dans la commande réelle. L'objectif principal est d'éliminer ce fardeau mental.

Tout ce que vous avez à faire est de créer une fonction à l'intérieur d'un alias:

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

Vous devez mettre des guillemets doubles autour de "$ 1" car les guillemets simples ne fonctionneront pas.

Voici trois exemples de fonctions que j'ai dans my ~/.bashrc, qui sont essentiellement des alias qui acceptent un paramètre:

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

Références:

• Découper un espace à partir de chaînes: Comment découper un espace à partir d'une variable Bash?
• Sauts de ligne réels: https://stackoverflow.com/a/4296147/2736496
• Alias ​​avec param: https://stackoverflow.com/a/7131683/2736496 (une autre réponse dans cette question)
• HISTIGNORE: /superuser/232885/can-you-share-wisdom-on-using-histignore-in-bash
• Invite Y / N: https://stackoverflow.com/a/3232082/2736496
• Supprimez tous les éléments correspondants de l'historique: /unix/57924/how-to-delete-commands-in-history-matching-a-given-string
• La chaîne est-elle nulle / vide: http://tldp.org/LDP/abs/html/comparison-ops.html

L'alias Bash accepte absolument les paramètres. Je viens d'ajouter un alias pour créer une nouvelle application React qui accepte le nom de l'application comme paramètre. Voici mon processus:

Ouvrez le bash_profile pour le modifier dans nano

nano /.bash_profile

Ajoutez vos alias, un par ligne:

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

note: le "$ @" accepte les paramètres passés comme "creact my-new-app"

Enregistrer et quitter l'éditeur nano

ctrl + o pour écrire (appuyez sur Entrée); ctrl + x pour quitter

Dites au terminal d'utiliser les nouveaux alias dans .bash_profile

source /.bash_profile

C'est ça! Vous pouvez maintenant utiliser vos nouveaux alias

NB: Dans le cas où l'idée n'est pas évidente, c'est une mauvaise idée d'utiliser des alias pour autre chose que des alias, le premier étant la `` fonction dans un alias '' et le second étant la `` redirection / source difficile à lire ''. De plus, il y a des défauts (que je pensais être évidents, mais juste au cas où vous seriez confus: je ne veux pas qu'ils soient réellement utilisés ... n'importe où!)

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

J'ai déjà répondu à cela, et cela a toujours été comme ça dans le passé:

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

ce qui est bien et bon, sauf si vous évitez d'utiliser toutes les fonctions ensemble. dans ce cas, vous pouvez profiter de la grande capacité de bash à rediriger le texte:

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

Ils sont tous les deux de la même longueur, donnent ou prennent quelques caractères.

Le vrai kicker est la différence de temps, le haut étant la «méthode de fonction» et le bas étant la méthode de «redirection-source». Pour prouver cette théorie, le timing parle de lui-même:

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

Il s'agit de la partie inférieure d'environ 200 résultats, effectués à des intervalles aléatoires. Il semble que la création / destruction de fonctions prenne plus de temps que la redirection. J'espère que cela aidera les futurs visiteurs à cette question (je ne voulais pas la garder pour moi).

Si vous cherchez un moyen générique d'appliquer tous les paramètres à une fonction, pas seulement un ou deux ou une autre quantité codée en dur, vous pouvez le faire de cette façon:

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

Donc, dans l'exemple ci-dessus, je passe tous les paramètres à partir du moment où je cours runjarvers l'alias.

Par exemple, si je le faisais, runjar hi therecela finirait par fonctionner java -jar myjar.jar hi there. Si je le faisais, runjar one two threeça irait java -jar myjar.jar one two three.

J'aime cette $@solution basée sur le fait qu'elle fonctionne avec n'importe quel nombre de paramètres.

Respectueusement à tous ceux qui disent que vous ne pouvez pas insérer un paramètre au milieu d'un alias, je viens de le tester et j'ai constaté que cela fonctionnait.

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

lorsque j'ai ensuite exécuté ma commande foobar, cela a fonctionné exactement comme si j'avais tapé la commande à la main.

Il existe des raisons techniques légitimes de vouloir une solution généralisée au problème de l'alias bash n'ayant pas de mécanisme pour prendre un repositionnement des arguments arbitraires. L'une des raisons est que la commande que vous souhaitez exécuter serait affectée par les modifications de l'environnement résultant de l'exécution d'une fonction. Dans tous les autres cas, les fonctions doivent être utilisées.

Ce qui m'a récemment poussé à essayer une solution, c'est que je voulais créer des commandes abrégées pour imprimer les définitions des variables et des fonctions. J'ai donc écrit quelques fonctions à cet effet. Cependant, certaines variables sont (ou peuvent être) modifiées par un appel de fonction lui-même. Parmi eux:

FUNCNAME BASH_SOURCE BASH_LINENO BASH_ARGC BASH_ARGV

La commande de base que j'utilisais (dans une fonction) pour imprimer des defns variables. sous la forme sortie par la commande set était:

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

Par exemple:

> V=voodoo
sv V
V=voodoo

Problème: cela n'imprimera pas les définitions des variables mentionnées ci-dessus car elles sont dans le contexte actuel , par exemple, si dans une invite de shell interactive (ou pas dans les appels de fonction), FUNCNAME n'est pas défini. Mais ma fonction me dit la mauvaise information:

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

Une solution que j'ai trouvée a été mentionnée par d'autres dans d'autres articles sur ce sujet. Pour cette commande spécifique pour imprimer les définitions de variables., Et qui ne nécessite qu'un seul argument, j'ai fait ceci:

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

Ce qui donne la sortie correcte (aucune) et l'état du résultat (faux):

> asv FUNCNAME
> echo $?
1

Cependant, je me sentais toujours obligé de trouver une solution qui fonctionne pour un nombre arbitraire d'arguments.

Une solution générale pour passer des arguments arbitraires à une commande alias 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".

Par exemple:

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

Une bonne chose à propos de cette solution est que toutes les astuces spéciales utilisées pour gérer les paramètres de position (arguments) des commandes fonctionneront lors de la composition de la commande capturée. La seule différence est que la syntaxe du tableau doit être utilisée.

Par exemple,

Si vous voulez "$ @", utilisez "$ {CMD_ARGV [@]}".

Si vous voulez "$ #", utilisez "$ {# CMD_ARGV [@]}".

Etc.

Une fois que j'ai fait un projet amusant et je l'utilise toujours. Cela montre de l'animation alors que je copie des fichiers via la cpcommande coz cpne montre rien et c'est un peu frustrant. J'ai donc fait cet alias

alias cp="~/SCR/spiner cp"

Et c'est le script 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

C'est comme ça

Animation à vélo)

Pour prendre des paramètres, vous devez utiliser des fonctions!

Cependant $ @ est interprété lors de la création de l'alias au lieu de pendant l'exécution de l'alias et l'échappement de $ ne fonctionne pas non plus. Comment résoudre ce problème?

Vous devez utiliser la fonction shell au lieu d'un alias pour vous débarrasser de ce problème. Vous pouvez définir foo comme suit:

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

OU

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

Enfin, appelez votre foo () en utilisant la syntaxe suivante:

foo arg1 arg2 argN

Assurez-vous d'ajouter votre foo () à ~/.bash_profileou ~/.zshrcfichier.

Dans votre cas, cela fonctionnera

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

Les fonctions sont en effet presque toujours la réponse comme déjà largement contribué et confirmé par cette citation de la page de manuel: "Pour presque tous les usages, les alias sont remplacés par les fonctions shell."

Pour être complet et parce que cela peut être utile (syntaxe légèrement plus légère), on peut noter que lorsque le ou les paramètres suivent l'alias, ils peuvent toujours être utilisés (bien que cela ne répondrait pas aux exigences de l'OP). C'est probablement plus facile à démontrer avec un exemple:

alias ssh_disc='ssh -O stop'

me permet de taper smth like ssh_disc myhost, qui est développé comme prévu:ssh -O stop myhost

Cela peut être utile pour les commandes qui prennent des arguments complexes (ma mémoire n'est plus ce qu'elle est ...)

Les fonctions et les alias peuvent utiliser des paramètres comme d'autres l'ont montré ici. De plus, je voudrais souligner quelques autres aspects:

1. la fonction s'exécute dans sa propre portée, alias partage la portée

Il peut être utile de connaître cette différence dans les cas où vous devez cacher ou exposer quelque chose. Cela suggère également qu'une fonction est le meilleur choix pour l'encapsulation.

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 

Production:

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. le script wrapper est un meilleur choix

Il m'est arrivé plusieurs fois qu'un alias ou une fonction ne soit pas trouvé lors de la connexion viassh ou impliquant la commutation de noms d'utilisateurs ou d'un environnement multi-utilisateurs. Il y a des trucs et astuces avec le sourcing de fichiers dot, ou celui-ci avec l'alias: permet à cet alias suivant de fonctionner comme prévu (notez l'espace supplémentaire dedans ). Cependant, un script wrapper fonctionne mieux qu'une fonction ou un alias dans des cas comme celui-ci. Le principal avantage d'un script wrapper est qu'il est visible / exécutable pour le chemin prévu (c'est-à-dire / usr / loca / bin /) où en tant que fonction / alias doit être obtenu avant de pouvoir être utilisé. Par exemple, vous placez une fonction dans un ~ / .bash_profile ou ~ / .bashrc pour , mais passez ensuite à un autre shell (c'est-à-dire ) alors la fonction n'est plus visible. Ainsi, en cas de doute, un script wrapper est toujours la solution la plus fiable et portable.alias sd='sudo 'alias install='sd apt-get install'sd='sudo 'bashzsh

Voici l'exemple:

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

Très important:

1. Il y a un espace après {et avant }.
2. Il y a un ;après chaque commande dans l'ordre. Si vous oubliez cela après la dernière commande, vous verrez à >la place une invite!
3. L'argument est placé entre guillemets comme "$1"

Comme cela a déjà été souligné par d'autres, l'utilisation d'une fonction doit être considérée comme la meilleure pratique.

Cependant, voici une autre approche, en tirant parti xargs:

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

Notez que cela a des effets secondaires concernant la redirection des flux.

Vous n'avez rien à faire, alias le fait automatiquement.

Par exemple, si je veux paramétrer git pull origin master, je peux simplement créer un alias comme suit:

alias gpull = 'git pull origin '

et lorsque vous l'appelez, vous pouvez passer 'master' (le nom de la branche) comme paramètre, comme ceci:

gpull master
//or any other branch
gpull mybranch