Hur hanterar man kommandoradsargument i Bash?

Hur Hanterar Man Kommandoradsargument I Bash



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/bash

Medan 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/bash

på 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/bash

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