Introduktion till funktioner i Unix
I den här artikeln kommer vi att lära oss om några grundläggande funktioner i Unix. Många av oss kanske redan visste vad funktioner är, men låt mig ge en kort introduktion om det. En funktion innehåller en uppsättning instruktioner som ska köras med en kod skriven i ett intryckt block. Dessa är användbara när vi har en viss uppgift som ett program måste göra upprepade gånger under regelbundna tidsintervaller. Att skriva samma kod varje gång rekommenderas uppenbarligen inte, så genom att använda funktioner kan vi enkelt återanvända koden och ringa den när det behövs. Låt oss nu se hur vi kan definiera och implementera dessa funktioner genom Unix Shell-skript.
Syntax av funktioner i Unix
Skapandet av funktioner följer den grundläggande syntaxkoden enligt följande. Exempel på en funktion.
Koda
First()
(
echo “ First Program for defining functions ”;
echo “ Yayyy! “;
)
Här har vi skrivit två ekouttalanden i vår första funktion. För att ringa funktionen, kan vi bara ringa på funktionens namn.
Produktion
Vidarebefordra parametrar till funktion i Unix
Vi har framgångsrikt gjort en enkel funktion, kallat den och genomfört de kommandon som vi krävde. Vad händer nu om jag behöver lägga till två siffror genom användarinmatade värden? Så här skulle vi se hur vi kan skriva en funktion med argument. Grundsyntaxen skulle vara densamma. Exempel på parametrerad funktion
Koda
Second()
(
echo “Enter your name: “;
read name;
echo “Hi $name, have a good day”;
)
Produktion
Det kommer att uppmana oss att ange ett namn och önskar dem
På samma sätt kan vi till och med skapa en skriptfil. Låt oss skriva en tilläggsfunktion i ett skalskript och se hur det fungerar.
Koda
vi add.sh
echo “enter first number: “;
read a;
echo “enter the second number: “;
read b;
sum=$((a+b));
echo “ Result is $sum”;
*********************
Save the file with : wq!
Produktion
Obs: Ibland får vi felet när vi kör sh-skriptet som:
Det enda som måste göra här är genom att uppdatera filbehörigheterna.
Vi kan till och med köra sh-filen med kommandot av. /add.sh
På samma sätt kan vi till och med utföra en funktion genom att tillhandahålla kommandoradsargument. Så låt oss se hur vi kan göra detta genom att lägga till tre siffror.
Koda
(
number1=$1;
number2=$2;
number3=$3;
sum=$((number1+number2+number3));
echo “Sum is $sum”;
)
Nu kan vi överföra våra siffror som kommandoradsargument och sedan få vår önskade produktion.
Tänk om vi inte överför några argument till funktionen?
Och om vi bara ger två argument?
Annars, kan vi passera strängar?
Vi kan till och med ha vår kod på ett sådant sätt att den kan upprepa ett fel när ogiltiga argument skickas. Nedan här, låt oss se hur vi kan be användaren att mata in argument om det inte fanns några kommandoradsargument.
Koda
Add()
(
number1=$1;
number2=$2;
if ( $# -ne 2 ); then
echo “ Enter two numbers to add “;
fi
sum=$((number1+number2));
echo “ Sum is : $sum “;
)
Produktion
Om vi inte överför några argument till vår funktion, ger det vårt eko där vi har bett om att ge två kommandoradsnummer och sedan ge summan. Det gör det, eftersom vi inte sa till funktionen att sluta om vi stöter på felet. I det andra fallet kan vi se den utgång som ger summan ordentligt utan mellanliggande eko. Vi kan till och med använda returkommandon för att returnera värden för dessa Unix-funktioner. Värdet i returrättet lagras i $?
Produktion
Kan du som en övning försöka skriva en funktion som bryter ut om vi inte klarar argumenten?
Kapslade funktioner i Unix
Genom att namnge kan vi räkna ut att kapslade funktioner handlar om att definiera en funktion i en funktion. Låt oss se hur vi kan göra det nu. Vi skriver detta i ett skalskript för enklare förståelse.
Koda
vi Nested_Function.sh
***** Code Inside the sh Function*******
#!/bin/sh
First()
(
echo “ Inside First Function “;
echo “ Calling the second function below “;
echo “**********”;
Second
echo “**********”;
echo “ After calling Second function “;
)
Second()
(
echo “ Inside Second Function”;
echo “ Done “;
)
First
************************
Save the file with : wq!
Produktion
I exemplet ovan kallade vi bara den andra funktionen i den första. Låt oss nu bara skriva en funktion i den första funktionen.
Koda
vi Nest_Func1.sh
***** Code Inside the sh Function*******
First_One()
(
echo “ Inside the function First_One”;
echo “ Below is the inner function “;
Second_One()
(
echo “ ********** “;
echo “ Inside Inner function”;
echo “ Completed Second Function”;
echo “ ********** “;
)
echo “Done with second example too”;
)
First_One
Second_one
************************
Save the file with : wq!
Nu, vilken produktion förväntar du dig? Tror du att både detaljerna i den första och den andra funktionen skulle visas?
Produktion
Vi kan tydligt se att funktionen inte kallade den inre funktionen inuti den. Så vad är problemet här?
Inuti vårt manus har vi bara kallat den första funktionen. Försök nu genom att ringa den andra funktionen också. Som observerats kommer vi här inte att kunna kalla funktionen av sig själv. I ovanstående kod har vi markerat den tillagda koden.
Produktion
Lägg märke till att ekot som vi har skrivit efter genomförandet av den andra funktionen har kommit framför sig själv. Om vi försöker ringa den andra funktionen först, följt av den första?
Produktion
Vi kan tydligt förstå att den inre funktionen inte kallas tills huvud / första funktionen kallas. Kan du prova att lägga till två nummer med kapslade funktioner som en övning? (En för att mata in användarvärden och andra för att lägga till siffrorna)
Slutsats
Så här kan vi definiera funktioner i Unix. Och en viktig fördel i Unix som jag hittade var att felet i utgången lätt kan förstås och kan hjälpa till att korrigera vår kod i enlighet därmed. Prova att utföra dessa funktioner och använd återkommandot också. Ha lyckligt lärande i Unix.
Rekommenderad artikel
Detta har varit en guide till funktioner i Unix. Här diskuterar vi en introduktion till funktioner i Unix och olika typer av funktioner tillsammans med syntax och detaljförklaring. Du kan också gå igenom våra andra föreslagna artiklar för att lära dig mer -
- Unix Architecture
- Unix-kommandon
- Användningar av Unix
- UNIX intervjufrågor
- Guide till Unix-operatörer