I Linux använder vi kommandoradsargument som indata för bash-skriptet. Bash kan ta dessa kommandoradsargument sekventiellt och analysera dem som ett alternativ. Dessa argument låter dig påverka åtgärderna och skriptets utdata dynamiskt.
Du kan konfigurera dessa argument på olika sätt för att påverka in- och utdata. Det är därför det är viktigt att hantera kommandoradsarg i bash, men många nya användare behöver lära sig hur man gör det. Så i den här guiden kommer vi att förklara olika sätt att hantera kommandoradsargument i bash.
Hur hanterar man kommandoradsargument i Bash?
Det finns olika sätt att hantera kommandoradsarg i Bash så låt oss ta en titt på dem för att få kort information:
Getopt-funktionen
Getopt-funktionen är praktisk eftersom den ger alternativen och syntaxen för att definiera och analysera argument i bash. Det är en inbyggd funktion i Linux som du kan använda när du skapar en databasfil eller rapport i ett specifikt format baserat på argumenten. Getopt-funktionen hjälper till att analysera de korta kommandoradsargumenten eftersom det finns två typer av argument:
- Korta argument: Dessa är argumenten med ett tecken följt av ett bindestreck. Till exempel -a, -l, -h, etc., är några exempel på enstaka argument.
- Långa argument: Dessa är argumenten med flera tecken följt av ett dubbelt bindestreck. Det finns olika exempel på långa argument, som –alla, –lista, –hjälp osv.
Låt oss ta ett exempel där vi kommer att hantera kommandoradsargumenten med hjälp av getopt-verktyget. Vi har skapat ett bash-skript som heter 'getopt.sh' som innehåller följande information:
!/ bin / våldsamt slag
medan getopts 'A:B:C:D:' detaljer; do
fall ' $detaljer ' i
A )
eko 'Medborgarens namn är $OPTARG ' ;;
B )
eko 'Medborgarlegitimation är $OPTARG ' ;;
C )
eko 'Födelseplatsen är $OPTARG ' ;;
D )
eko 'Ycka är $OPTARG ' ;;
* )
utgång 1 ;;
esac
Gjort
flytta ' $(($OPTING -1) )'
om [ ! -Med $1 ] ; sedan
eko 'Äktenskapligt status $1'
annan
eko 'Inga poster'
utgång 1
vara
om [ ! -Med $2 ] ; sedan
eko 'Familjemedlemmar $2'
vara
Låt oss nu köra skriptet med de nödvändiga argumenten i ingången:
Som du kan se i bilden ovan kör vi skriptet med enbart getopt-funktioner och lägger sedan till normala argument för att få det fullständiga resultatet.
Använda flaggor
Flaggor är inget annat än enstaka tecken som föregås av bindestreck (-). När vi skickar argumenten med hjälp av getopt-funktionen använder vi flaggor. -a, -b, -c är några exempel på flaggor. Ett manus kräver till exempel en medborgares namn, ID, plats, ålder och yrke. Därför använde vi flaggor j, k, l, m, n, för att definiera medborgarens namn, ID, plats, ålder och yrke samtidigt:
#!/bin/bashMedan getopts j:k:l:m:n: flagga_info
do
fall ' ${flag_info} ' i
< ol >
< den där > j ) medborgarnamn = ${OPTARG} ;; den där >
< den där > k ) legitimation = ${OPTARG} ;; den där >
< den där > l ) plats = ${OPTARG} ;; den där >
< den där > m ) ålder = ${OPTARG} ;; den där >
< den där > n ) ockupation = ${OPTARG} ;; den där >
ol >
esac
Gjort
eko 'Här är de angivna detaljerna:'
eko 'Medborgarens namn: $medborgarnamn ' ;
eko 'Legitimation: $medborgare ' ;
eko 'Plats: $place ' ;
eko 'Ålder: $ålder ' ;
eko 'Ockupation: $ockupation ' ;
Skriptet kommer att ge följande resultat i terminalen:
. /< manus > .sh -j Danny -k 476 -l Toronto -m 25 -n Författare
Använder sig av [e-postskyddad] Med loopar
den ' [e-postskyddad] ” variabel är inget annat än arrayen av alla inmatningsargument. Vi kan skicka valfritt antal ingångar med hjälp av ' [e-postskyddad] ” variabel. Du kan använda denna variabel som en loop för att iterera genom argumenten. den ' [e-postskyddad] ” variabel kommer väl till pass då; du känner inte till indatastorleken och kan inte ta positionsargumenten. Därför kan du använda ' [e-postskyddad] ” istället för att definiera getopt-funktionen om och om igen. Här är ett exempel på att använda loopar och [e-postskyddad] tillsammans i ett manus:
#!/bin/bashpå ett = ( '$ @ ” )
om [ $# -gt 1 ]
sedan
Lägg till =$ ( ( ${num[0]} + ${num[1]} ) )
eko 'Addition av alla siffror är: $add '
subtraktion =$ ( ( ${num[0]} - ${num[1]} - ${num[2]} ) )
eko 'Subtraktion av talen är: $subtraktion '
multiplicera =$ ( ( ${num[0]} * ${num[1]} * ${num[2]} ) )
eko 'Multiplikation av siffrorna är: $multiplicera '
division 1 =$ ( ( ${num[0]} / ${num[1]} ) )
eko 'Division av ${num[0]} och ${num[1]} är: $division1 '
division 2 =$ ( ( ${num[1]} / ${num[2]} ) )
eko 'Indelning av ${num[1]} och ${num[2]} är: $division2 '
division 3 =$ ( ( ${num[0]} / ${num[2]} ) )
eko 'Indelning av ${num[0]} och ${num[2]} är: $division2 '
vara
Ovanstående skript utför olika aritmetiska beräkningar baserat på kommandoradsargumenten. Till exempel har vi angett 50, 35 och 15 som indata:
Använda positionsparametrar
Du kan komma åt positionsparametrarna när de kommer åt $1 först, sedan $2, och så vidare. Låt oss till exempel skapa ett skript som läser ett namn som det första argumentet och sedan en stad som det andra. Men om du passerar staden först och sedan namnet, så betraktar den namnet som staden och vice versa. Låt oss ta en djupare dykning i följande manus för att förstå detta koncept:
#!/bin/basheko 'Här är de angivna uppgifterna'
eko 'namn $1'
eko 'stad $2'
Du måste lägga till namn och stad när du kör skriptet i terminalen:
Avslutar
Detta är allt du behöver veta om metoderna för att hantera kommandoradsargument i bash. Vi har förklarat olika tillvägagångssätt som du kan prova med lämpliga exempel. Det finns olika kommandon om du vill lägga till argument i skriptet. Så se till att du besöker Linuxhint för att lära dig mer om dem.