Att analysera och överföra argument till bash-skript/skalskript är ganska likt det sätt på vilket vi skickar argument till funktionerna i Bash-skript. Vi kommer att se den faktiska processen att vidarebefordra argumenten till ett skript och även titta på sättet att komma åt dessa argument inuti skriptet.
Passera argument innan körning
Vi kan skicka parametrar precis efter namnet på skriptet medan vi kör kommandot bash-tolk. Du kan skicka parametrar eller argument till filen. Bara kommandot för att köra skriptet normalt genom att lägga till värdet på parametrarna direkt till skriptet. Varje parameter är ett mellanslagsseparerat värde som ska skickas till skalskriptet.
bash scriptname.sh>
Ovanstående kommando kommer bara att köra skriptet utan att skicka parametrarna.
Medan kommandot nedan skickar argumenten till skriptet.
bash scriptname.sh parameter1 parameter2 parameter3 nth-parameter>
Kör bash script med passerande parametrar
Ovanstående skärmdump visar parametrarna som skickas till skriptet, hur vi gör det, vilket vi kommer att förklara i nästa avsnitt. Men just nu kan vi se att vi har skickat in parametrarna från utsidan av skriptet med bash miljövariabler. Du kan till och med använda strängar och andra datatyper men akta dig för eventuella blanksteg. Vitt utrymme kommer att göra variabeln till en separat parameter. Så, särskilt för strängar, var noga med att strikt omge dem med citattecken.
Upptäcka kommandoradsargument
Nu ska vi se hur vi kommer åt dessa parametrar inuti skriptet. Vi kommer att använda antalet parametrar som skickas i ordningen, dvs. för de första parametrarna som skickas, kommer vi att analysera (åtkomst) parametern genom att använda som variabel. Den första parametern lagras i variabeln . Dessutom kan du tilldela denna variabel till vilken annan användardefinierad variabel du vill. För den n:te parametern som skickas kan du använda $n för att komma åt den specifika parametern. Här börjar variabelnamnet med 1 eftersom filnamnet/skriptnamnet är den 0:e parametern. Om du har fler än 9 parametrar, se till att använda { } runt numret som utan parentes, bash kommer bara att se som och exkludera 0:an, så använd och så vidare istället för bara .
#!/bin/bash echo '1st parameter = ' echo '2nd Parameter = '>
Skriptet ovan kan komma åt parametrarna från kommandoraden/skalet med hjälp av positionsparametrarna, som är 1, 2, 3 och så vidare.
Åtkomst till argumenten från skriptet.
Som du kan se har vi använt {} för att komma åt parametervariabelnumren från 10 och framåt. Skriptet kan användas för loopar och while-loopar för att iterera över parametrarna, men vi kommer att diskutera det i ytterligare avsnitt.
char till heltal java
Tilldela tillhandahållna argument till Bash-variabel
Vi kan också tilldela det till andra anpassade variabler för att göra skriptet mer dynamiskt och forma det efter behoven. Även om skriptet ovan endast kommer att skriva ut två parametrar när det körs, kan du säkert komma åt fler parametrar genom att använda variabeln som parametrarnas ordning i siffror. Skriptet kan komma åt positionsvariablerna från kommandoraden och använda dem på önskade platser varhelst det behövs i skriptet.
#!/bin/bash a= b= p=$(($a*$b)) echo 'The product of $a and $b = $p'>
Tilldela tillhandahållna argument till Bash-variabel
Ovanstående skript får åtkomst till positionsparametrarna, dvs och som skickas in i skriptet och lagrar de användardefinierade variablerna för att komma åt dem senare och modifiera dem därefter. Vi kan också komma åt fler parametrar med iterativa metoder som vi kommer att se i de kommande avsnitten.
Vi har också möjlighet att kontrollera om det finns några NULL- eller tomma parametrar som skickas med -z- eller -n-flaggorna. Utifrån detta kan vi verifiera om parametrarna passerades eller inte.
#!/bin/bash if [[ -z ]]; then echo 'No parameter passed.' else echo 'Parameter passed = ' fi>
Kontrollera om positionsparametrar har skickats in eller inte.
sharwanand
Med det här skriptet kan vi upptäcka om några positionsparametrar har skickats in eller inget har skickats. Flaggan -z letar efter eventuella NULL eller oinitierade variabler i BASH. Flaggan -z returnerar true om variabeln som skickas är NULL eller oinitierad. Därför kan vi använda grundläggande If-else-satser för att upptäcka parametrarna som passerats.
Vi kan också använda flaggan -n som returnerar true om inga parametrar skickas, så vi måste använda ! för att vända tillståndet.
Så här:
#!/bin/bash if [[ ! -n ]]; then echo 'No parameter passed.' else echo 'Parameter passed = ' fi>
Detta skript kommer också att ge samma utdata också, men vi använder -n flagga istället för -z.
Läsa flera argument med For eller While loop
Vi kan använda @ variabel för att komma åt varje parameter som skickas till skriptet via kommandoraden. Det är en speciell variabel som innehåller arrayen av variabler i BASH. I det här fallet använder vi den ensam, så den innehåller arrayen av positionsparametrar som skickas in. Vi kan använda den för att iterera över parametrarna som skickas med loopar eller medan loop också.
#!/bin/bash for i in $@ do echo -e '$i ' done>
Använder loopar och @ variabel för att komma åt parametrarna som arrayelement.
Vi använde en intervallbaserad for-loop för att iterera över tills det finns element i @-arrayen. Vi itererar helt enkelt över arrayen och skriver ut elementet. Vi kan helt enkelt tilldela det, modifiera värdena och göra de nödvändiga ändringarna av parametrarna och argumenten för att uppnå önskat resultat från skriptet.
ELLER
java bruksdatum
Vi kan också skriva ut argumenten genom att använda while-loopen och miljövariablerna i BASH.
#!/bin/bash i=$(($#-1)) while [ $i -ge 0 ]; do echo ${BASH_ARGV[$i]} i=$((i-1)) done> 
Använd while-loop för att iterera över de passerade parametrarna.
Vi använder variabeln ' # ' eftersom det innehåller antalet parametrar som skickas in. Vi initierar antalet parametrar och tar bort en eftersom vi ska använda en array för att iterera över den. Så, som vanligt, startar arrayens index från 0. Eftersom denna array initieras från det sista elementet eller parametern som passerats, måste vi minska räknaren till 0 för att skriva ut varje parameter i den ordning den skickas. Vi använder helt enkelt BASH_ARGV-matrisen för att komma åt parametrarna och skriva ut dess värde. Vid varje iteration minskar vi också värdet på i- iteratorn eller räknaren med ett med hjälp av aritmetiska dubbla klammerparenteser. Från detta skriver vi helt enkelt ut varje parameter som skickas till skriptet med hjälp av en while-loop som visas på skärmdumpen.
Läsning med parameternamn
Använda getopts för att analysera argument och parametrar
Vi kan använda getopts-programmet/kommandot för att analysera argumenten som skickas till skriptet på kommandoraden/terminalen genom att använda loopar och switch-case-satser.
#!/bin/bash while getopts n:c: option do case '${option}' in n)nation=${OPTARG};; c)code=${OPTARG};; esac done echo 'Nation : $nation' echo 'code : $code'> 
Använda getopts för att analysera argument och parametrar
Med hjälp av getopts kan vi tilldela positionsargumenten/parametrarna från kommandoraden till bashvariablerna direkt. Detta gör att vi kan hantera parametrarna snyggt och på ett systematiskt sätt. I skriptet ovan har vi använt två argument för att lagra bash-variablerna med hjälp av getopts-syntaxen, medan loopar och switch-case-satser.
Skriva ut värden för alla argument
Vi kan skriva ut argumenten som skickas till skriptet med en enkel kraftfull variabel '@' som lagrar alla parametrar som skickas.
#!/bin/bash echo 'The arguments passed in are : $@'>
Skriva ut värden för alla argument
Åtkomst till antalet parametrar som passerats
Vi kan också använda variabeln '#' för att komma åt antalet parametrar som skickas från kommandoraden. Variabeln # innehåller i princip antalet parametrar/argument som skickas in i skriptet.
#!/bin/bash echo 'The number of arguments passed in are : $#'>
Åtkomst till antalet parametrar som passerats
Följande var processen och specifikationen för att skicka och analysera variablerna i bash-skriptet. Logiken med att ändra och göra ändringar i variablerna ligger i användarens händer. Detta var bara en demonstration av att gå in och analysera argumenten från kommandoraden till skriptet för att göra dem mer dynamiska.