Een Bash-alias maken waaraan een parameter moet worden doorgegeven?

Ik gebruikte CShell (csh) , waarmee u een alias kunt maken waaraan een parameter moet worden doorgegeven. De notatie was zoiets als

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

In Bash lijkt dit niet te werken. Aangezien Bash een groot aantal handige functies heeft, neem ik aan dat deze is geïmplementeerd, maar ik vraag me af hoe.

Antwoord 1, autoriteit 100%

Bash-alias accepteert parameters niet rechtstreeks. U moet een functie maken.

aliasaccepteert geen parameters, maar een functie kan net als een alias worden aangeroepen. Bijvoorbeeld:

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

Trouwens, Bash-functies gedefinieerd in uw .bashrcen andere bestanden zijn beschikbaar als commando’s in uw shell. Dus je kunt bijvoorbeeld de eerdere functie zo aanroepen

$ myfunction original.conf my.conf

Antwoord 2, autoriteit 10%

Als u het bovenstaande antwoord verfijnt, kunt u een syntaxis van één regel krijgen, net als voor aliassen, wat handiger is voor ad-hocdefinities in een shell of .bashrc-bestanden:

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

Vergeet de puntkomma niet voor de rechter haakje sluiten. Evenzo, voor de eigenlijke vraag:

csh% alias junk="mv \\!* ~/.Trash"
bash$ junk() { mv "$@" ~/.Trash/; }

of:

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

3, Autoriteit 6%

De vraag wordt eenvoudigweg gevraagd. U maakt geen alias die parameters gebruikt, omdat aliasgewoon een tweede naam voegt voor iets dat al bestaat. De functionaliteit De OP WERS is de functionopdracht om een ​​nieuwe functie te maken. U hoeft de functie niet te alias als de functie al een naam heeft.

Ik denk dat je zoiets wilt:

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

Dat is het! U kunt parameters $ 1, $ 2, $ 3, enz. Gebruiken, of gewoon alles met $ @

Antwoord 4, autoriteit 2%

Een alternatieve oplossing is om markerte gebruiken, een tool die ik onlangs heb gemaakt waarmee je opdrachtsjablonen kunt “bookmarken” en plaats de cursor eenvoudig op opdrachtplaatsaanduidingen:

Ik ontdekte dat ik meestal shell-functies gebruik, zodat ik vaak gebruikte opdrachten niet steeds opnieuw in de opdrachtregel hoef te schrijven. De kwestie van het gebruik van functies voor deze use case, is het toevoegen van nieuwe termen aan mijn commando-vocabulaire en het onthouden naar welke functieparameters in het real-commando verwijzen. Het doel van de markering is om die mentale last te elimineren.

Antwoord 5, autoriteit 2%

Het enige wat je hoeft te doen is een functie maken binnen een alias:

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

U moetdubbele aanhalingstekens plaatsen rond “$1” omdat enkele aanhalingstekens niet werken. Dit komt omdat het systeem in de war raakt door de aanhalingstekens op de plaatsen die met pijlen zijn gemarkeerd, te verwarren. Ook is er een spatie nodig op de plaats gemarkeerd met een ster voor de functie.

Antwoord 6

Ik heb ooit een leuk projectgedaan en ik gebruik het nog steeds. Het toont wat animatie terwijl ik bestanden kopieer via het cp-commando, want cplaat niets zien en het is nogal frustrerend. Dus ik heb deze alias gemaakt

alias cp="~/SCR/spiner cp"

En dit is het spinerscript

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

Het ziet er zo uit

Gefietste animatie)

Hier is de link naar een hierboven vermeld color-script.
En nieuwe animatiecyclus)

Antwoord 7

Bash-alias accepteert absoluut parameters. Ik heb zojuist een alias toegevoegd om een nieuwe reactie-app te maken die de app-naam als parameter accepteert. Dit is mijn proces:

Open het bash_profile voor bewerking in nano

nano /.bash_profile

Voeg uw aliassen toe, één per regel:

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

opmerking: de “$@” accepteert ingevoerde parameters zoals “creëer mijn-nieuwe-app”

Nano-editor opslaan en afsluiten

ctrl+o om te schrijven (druk op enter); ctrl+x om af te sluiten

Vertel terminal om de nieuwe aliassen in .bash_profile te gebruiken

source /.bash_profile

Dat is het! U kunt nu uw nieuwe aliassen gebruiken

Antwoord 8

Met respect voor iedereen die zegt dat je geen parameter in het midden van een alias kunt invoegen, ik heb het net getest en vastgesteld dat het werkte.

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

toen ik mijn opdracht foobar uitvoerde, werkte het precies alsof ik de opdracht uit de hand had getypt.

Antwoord 9

Hier zijn drie voorbeelden van functies die ik heb in mijn ~/.bashrc, die in wezenaliassen zijn die een parameter accepteren:

#Utility required by all below functions.
#https://stackoverflow.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://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
}

Referenties:

• Witruimte van tekenreeksen bijsnijden:Hoe om witruimte van een Bash-variabele bij te knippen?
• Echte regeleinden:https://stackoverflow.com/a/4296147/2736496
• Alias met param:https://stackoverflow.com/a/7131683/2736496(een ander antwoord op deze vraag)
• HISTIGNORE:https: //superuser.com/questions/232885/can-you-share-wisdom-on-using-histignore-in-bash
• J/N-prompt:https://stackoverflow.com/a/3232082/2736496
• Verwijder alle overeenkomende items uit de geschiedenis:https://unix.stackexchange.com/questions/57924/how-to-delete-commands-in-history-matching-a-given-string
• Is string null/leeg:http:/ /tldp.org/LDP/abs/html/comparison-ops.html

Antwoord 10

Als u op zoek bent naar een generieke manier om alle parameters op een functie toe te passen, niet slechts een of twee of een ander hardgecodeerd bedrag, dan kunt u dat op deze manier doen:

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

Dus in het bovenstaande voorbeeld geef ik alle parameters van het uitvoeren van runjardoor aan de alias.

Als ik bijvoorbeeld runjar hi theredeed, zou het uiteindelijk java -jar myjar.jar hi thereuitvoeren. Als ik runjar one two threedeed, zou het java -jar myjar.jar one two threeuitvoeren.

Ik vind dit leuk $@-gebaseerde oplossing omdat het werkt met een willekeurig aantal params.

11

NB: In het geval dat het idee niet vanzelfsprekend is, is het een slecht idee om aliassen te gebruiken voor allesbehalve aliassen, de eerste is de ‘functie in een alias’ en de tweede is het ‘moeilijk om doorverwijzend / bron’. Ook zijn er gebreken (die ik dacht zou duidelijk zijn, maar voor het geval je in de war bent: ik wil niet dat ze daadwerkelijk worden gebruikt … Anywhere!)

……………………………………….. ………………………………………….. ………………………………………..

Ik heb dit eerder beantwoord en het is in het verleden altijd zo geweest:

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

Wat prima en goed is, tenzij u het gebruik van functies allemaal bij elkaar vermijdt. In welk geval kunt u profiteren van het enorme vermogen van Bash om tekst te omleiden:

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

Ze zijn allebei ongeveer dezelfde lengte geven of nemen een paar personages.

De Real Kicker is het tijdsverschil, de bovenkant is de ‘functie-methode’ en de bodem is de methode ‘Redirect-Source’. Om deze theorie te bewijzen, spreekt de timing voor zichzelf:

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

Dit is het onderste deel van ongeveer 200 resultaten, gedaan op willekeurige intervallen. Het lijkt erop dat functie / vernietiging van functie meer tijd kost dan omleiding. Hopelijk zal dit toekomstige bezoekers aan deze vraag helpen (ik wilde het niet bij mezelf houden).

12

Er zijn legitieme technische redenen om een ​​gegeneraliseerde oplossing te willen voor het probleem van bash alia’s die geen mechanisme hebben om een ​​reputatie willekeurige argumenten te nemen. Eén reden is als het commando dat u wilt uitvoeren, negatief zou worden beïnvloed door de wijzigingen in de omgeving die het gevolg zijn van het uitvoeren van een functie. In alle andere Cases moeten functies worden gebruikt.

Wat de laatste tijd heeft gedwongen om een ​​oplossing voor dit te proberen, is dat ik wat verkorte opdrachten wilde maken voor het afdrukken van de definities van variabelen en functies. Dus ik schreef wat functies voor dat doel. Er zijn echter bepaalde variabelen die (of kunnen zijn) veranderd door een functie-oproep zelf. Onder hen zijn:

Funcname
Bash_source
Bash_lineno
Bash_argc
Bash_argv

De basisopdracht die ik (in een functie) had gebruikt om variabele defns af te drukken. In de vormuitgang door de ingestelde opdracht was:

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

Bijvoorbeeld:

> V=voodoo
sv V
V=voodoo

Probleem: hiermee worden de definities van de hierboven genoemde variabelen niet afgedrukt omdat ze zich in de huidige contextbevinden, bijv. als in een interactieve shell-prompt (of niet in een functie-aanroep), FUNCNAME is niet gedefinieerd. Maar mijn functie vertelt me de verkeerde informatie:

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

Eén oplossing die ik heb bedacht, is genoemd door anderen in andere berichten over dit onderwerp. Voor deze specifieke opdracht om variabele defns af te drukken, en waarvoor slechts één argument nodig is, heb ik dit gedaan:

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

Dat geeft de juiste output (geen) en resultaatstatus (false):

> asv FUNCNAME
> echo $?
1

Ik voelde me echter nog steeds genoodzaakt om een oplossing te vinden die werkt voor een willekeurig aantal argumenten.

Een algemene oplossing voor het doorgeven van willekeurige argumenten aan een Bash Aliased-commando:

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

b.v.:

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

Een leuk ding aan deze oplossing is dat alle speciale trucs die worden gebruikt voor de positieve parameters (argumenten) aan opdrachten zullen werken bij het samenstellen van de ingesloten opdracht. Het enige verschil is dat array-syntaxis moet worden gebruikt.

b.g.,

Als u wilt “$ @”, gebruik “$ {cmd_argv [@]}”.

Als u “$ #” wilt, gebruik dan “$ {# cmd_argv [@]}”.

enz.

13

Om specifiek antwoord te geven op de vraag die de alias heeft gemaakt om de bestanden te verplaatsen naar de map Prullenbak in plaats van ze te verwijderen:

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

Offcourse moet je eerst Dir ~ / .trash maken.

Geef vervolgens de volgende opdracht:

$rm <filename>
$rm <dirname>

14

SYNTAX:

alias shortName="your custom command here"

Voorbeeld:

alias tlogs='_t_logs() { tail -f ../path/$1/to/project/logs.txt ;}; _t_logs'

15

Zoals al door anderen is opgemerkt, moet het gebruik van een functie worden beschouwd als de beste praktijken.

Hier is hier een andere aanpak, gebruikmakend xargs:

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

Merk op dat dit bijwerkingen heeft met betrekking tot de omleiding van streams.

16

Ik zal mijn (hopelijk, oke) oplossing gewoon plaatsen
(voor toekomstige lezers, & amp; meest vitaal; editors).
Dus – bewerken en amp; Verbeter / Verwijder alles in dit bericht.

In de terminal:

$ alias <name_of_your_alias>_$argname="<command> $argname"

en om het te gebruiken:

$<name_of_your_alias>_$argname

Bijvoorbeeld een alias tot cateen bestand met de naam hello.txt:

• (alias naam is CAT_FILE_)
• en de $f(is de $argname, die een bestand in dit voorbeeld is)

$ alias CAT_FILE_$f="cat $f"
$ echo " " >> hello.txt
$ echo "hello there!" >> hello.txt
$ echo " " >> hello.txt
$ cat hello.txt
    hello there!

Test:

CAT_FILE_ hello.txt

17

Voor het gebruik van parameters moet u functies gebruiken!

Echter $ @ worden geïnterpreteerd bij het maken van de alias in plaats van tijdens de uitvoering van de alias en die ontsnappen aan de $ werkt ook niet. Hoe los ik dit probleem op?

U moet Shell-functie gebruiken in plaats van een alias om van dit probleem af te komen. U kunt FOO definiëren als volgt:

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

of

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

Ten slotge, bel uw foo () met behulp van de volgende syntaxis:

foo arg1 arg2 argN

Zorg ervoor dat u uw foo () toevoegen aan ~/.bash_profileof ~/.zshrcbestand.

In uw geval werkt dit

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

18

Hier is het voorbeeld:

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

erg belangrijk:

1. Er is een ruimte na {en vóór }.
2. Er is een ;na elke opdracht in volgorde. Als u dit na de laatste opdracht vergeet, ziet u >Prompt in plaats daarvan!
3. Het argument is ingesloten in aanhalingstekens als "$1"

19

Functies zijn inderdaad bijna altijd het antwoord zoals reeds ruimschoots bijgedragen en bevestigd door deze offerte van de man-pagina: “voor bijna elk doel, aliassen worden vervangen door shell-functies.”

Voor de volledigheid en omdat dit nuttig kan zijn (marginallally lichtere syntaxis) kan worden opgemerkt dat wanneer de parameter (s) de alias volgen, ze nog steeds kunnen worden gebruikt (hoewel dit de eis van de OP niet zou aanpakken). Dit is waarschijnlijk het gemakkelijkst om te demonstreren met een voorbeeld:

alias ssh_disc='ssh -O stop'

stelt me ​​in staat om smth op te typen als ssh_disc myhost, die wordt uitgebreid zoals verwacht als: ssh -O stop myhost

Dit kan handig zijn voor opdrachten die complexe argumenten innemen (mijn geheugen is niet wat het gebruikt is meer …)

20

Beide functies als aliassen kunnen parameters gebruiken zoals die hier hebben aangetoond. Bovendien zou ik graag willen wijzen op een paar andere aspecten:

1. Functie wordt uitgevoerd in zijn eigen bereik, alias-aandelen scope

Het kan handig zijn om dit verschil te weten in de gevallen die u moet verbergen of blootstellen. Het suggereert ook dat een functie de betere keuze is voor inkapseling.

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 

Uitvoer:

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. wrapper-script is een betere keuze

Het is me meerdere keren overkomen dat een alias of functie niet kan worden gevonden wanneer inloggen via sshof waarbij gebruikersnamen worden gewijzigd of een omgeving met meerdere gebruikers wordt gebruikt. Er zijn tips en trucs voor het sourcen van dot-bestanden, of deze interessante met alias: alias sd='sudo 'laat deze volgende alias alias install='sd apt-get install'werk zoals verwacht (let op de extra spatie in sd='sudo '). Een wrapperscript werkt in dit soort gevallen echter beter dan een functie of alias. Het belangrijkste voordeel van een wrapper-script is dat het zichtbaar/uitvoerbaar is voor onder bedoeld pad (d.w.z. /usr/loca/bin/) waar een functie/alias moet worden gesourced voordat het bruikbaar is. U plaatst bijvoorbeeld een functie in een ~/.bash_profile of ~/.bashrc voor bash, maar schakelt u later over naar een andere shell (bijv. zsh) dan is de functie niet niet meer zichtbaar.
Dus bij twijfel is een wrapper-script altijd de meest betrouwbare en draagbare oplossing.

Antwoord 21

Hier is een andere benadering met behulp van read. Ik gebruik dit voor het bruut zoeken van een bestand op zijn naamfragment, waarbij ik de berichten met “toestemming geweigerd” negeer.

alias loc0='{ IFS= read -r x; find . -iname "*" -print 2>/dev/null | grep $x;} <<<'

Een eenvoudig voorbeeld:

$ { IFS= read -r x; echo "1 $x 2 ";} <<< "a b"
1 a b 2 

Merk op dat dit het argument als een string omzet in variabele(n). Je zou hiervoor verschillende parameters tussen aanhalingstekens kunnen gebruiken, gescheiden door spaties:

$ { read -r x0 x1; echo "1 ${x0} 2 ${x1} 3 ";} <<< "a b"
1 a 2 b 3