Linux-operatörer - Omfattande guide till de flesta Linux-operatörer

Innehållsförteckning:

Anonim

Introduktion till Linux-operatörer

Ett av de mest använda och rekommenderade datoroperativsystemet för utvecklingsändamål, "Linux", har ett brett utbud av exekveringskommandon. Dessa kommandon är instruktioner på en rad som utförs på terminalen. Det finns ett brett utbud av dessa kommandon, utmärkta för en specifik användning. Dessa kommandon körs på Linux CLI (Command Line Interface). I det här ämnet kommer vi att lära oss om Linux-operatörer.

Om du är ny med Linux CLI och inte har någon aning om dessa operatörer eller hur du använder dem, öppnar du bara terminalen och avfyrar "hjälp" -kommandot, som listar upp Linux Shells inbyggda kommandon med syntax.

En av en så kraftfull operatör är '&&' (dubbelampersand), som är en typ av Chain Command och när den används, kör det andra inline-kommandot, efter det framgångsrika exekveringen av det första kommandot.

Exempel: "apt-get update && apt-get upgrade", härmed framgångsrikt utförande av uppdateringskommandot, uppgraderingskommando körs.

Låt oss dyka in i världen av obegränsade Linux-operatörer. Till att börja med har Linux, som alla programmeringsspråk ett grundläggande sortiment av operatörer.

Följande är den grundläggande klassificeringen eller operatörerna:

  • Aritmetiska operatörer: används för att utföra matematiska operationer.
  • Relationsoperatörer: definierar helt enkelt förhållandet mellan två operander.
  • Booleanoperatörer: även känd som logiska operatörer, dessa används för att utföra logiska operationer.
  • Bitvisa operatörer: “&, |, <>”, används för enkla bitvisa operationer.
  • Filtestoperatörer: spelar med en fils egenskaper.

Lista över Linux-operatörer

Detta är några av kategorierna för operatörer. Utöver detta erbjuder Linux ett brett utbud av kommandon. Dessa operatörer körs i princip på en Bourne Shell. Bourne Shell är UNIX: s ursprungliga program för exekvering av kommandot, utvecklat på AT&T, av Stephen Bourne, och därmed namnet. Låt oss nu förstå var och en av dessa operatörer ingående med exempel. För ytterligare exempel antar vi två variabler X och Y, med värdena 5 och 10.

1. Aritmetiska operatörer

I grund och botten används dessa operatörer i enkla matematiska beräkningar som tillägg och multiplikationer.

Vi har 7 aritmetiska operatörer enligt följande:

  • Tillägg (+): Lägg bara till värden för de två givna variablerna. Ex. X + Y kommer att resultera i 15.
  • Subtraktion (-): Subtraherar värdet på en variabel med den andra. Ex. Y - X kommer att resultera i 5.
  • Division (/): Delar de två variablerna. Ex. X / Y ger oss 0, 5.
  • Multiplikation (*): Multiplicerar de två variablerna. Ex. X * Y kommer att resultera i 50.
  • Inkrement Operator (++): Lägg bara till en till värdet. Inkrementoperatören fungerar på två sätt, som ett prefix och som ett postfix, och baserat på operatörens position kan resultaten variera.
  • För prefix: med operatören före variabel, Y ++, kommer det att returnera värdet innan du ökar, Ex. Y ++ = 5
  • För postfix: med variabel före operatören, ++ Y, kommer det att ge det ökade värdet, Ex. ++ Y = 6.
  • Decrement Operator (-): Liknar inkrement, förutom att den raderar ett enda värde. Fungerar på två sätt.
  • För prefix: ger först värdet på Y och gör sedan minskningen, Ex. Y - kommer att resultera i 5.
  • För postfix: sänker initialt värdet med en ger sedan resultatet, Ex. –Y kommer att returnera 4.

Ovan är de aritmetiska operatörerna som används allmänt, och nu börjar vi med den andra listan över operatörer, dvs Relationsoperatörer.

2. Relationsoperatörer

Returnerar helt enkelt antingen "sant eller falskt", beroende på förhållandet mellan variablerna och stöds av Bourne Shell.

Nedan visas totalt 6 typer av relationella operatörer:

  • Lika med (==): Jämför de två variablerna och returnerar sant om de är lika och falska om annat. Ex. X == Y kommer att leda till falskt.
  • Inte lika med (! =): Liknar lika med, förutom att det returnerar sant om värdena inte är desamma och falska om annat. Ex. X! = Y kommer att återkomma.
  • Mindre än (<): om det vänstra värdet är mindre än det högra värdet returnerar det sant annars falskt. Ex. X <Y kommer att återkomma.
  • Större än (>): returnerar sant om det vänstra värdet är större än det högra värdet, annars falskt. Ex. X> Y kommer att returnera falskt.
  • Mindre än eller lika med (<=): sant om det vänstra värdet är mindre än eller lika med det högra värdet.
  • Större än eller lika med (> =): sant om det vänstra värdet är större än eller lika med det högra värdet.

Nu när vi har förstått relationella och aritmetiska operatörer, låt oss studera de booleska och bitvisa operatörerna.

3. Booleska operatörer

Boolean Operators används helt och hållet på Bourne Shell och används i kombination för bättre sökresultat. OCH, ELLER och INTE är de booleska operatörerna och användningen av dessa operatörs resultat är tidsbesparande.

  • OCH: för att begränsa sökningen. Ex. Testmärken OCH slutbetyg.
  • ELLER: bredda sökningen. Ex. Gratis kurser ELLER under Rs.499.
  • INTE: för att eliminera nyckelord. Ex. Senaste tillägg INTE över Rs.499.

4. Bitvisa operatörer

Något som liknar logiska operatörer, förutom att Bitvis-operatörer arbetar på den lägre nivån vid binär representation av data. Här måste både variablerna (höger och vänster) vara heltal.

Nedan visas de 6 bitvisa operatörerna.

  • OCH (&): jämförelse mellan två bitar. Returnerar 1 om båda bitarna är 1, annars 0.
  • ELLER (|): jämför två bitar och returnerar 1 om bitarna är komplementära, annars 0.
  • XOR (^): EXKLUSIV-ELLER, liknande operatörerna ovan, det jämför båda bitarna och returnerar 1 om någon av bitarna är 1. Annars ger det 0 om båda bitarna är 0 eller 1.
  • Kompliment (~):
  • Vänsterväxling (<<): flyttar helt enkelt bitarna till höger och en 0 tilldelas längst till vänster.
  • Right Shift (>>): precis som SHIFT RIGHT men på motsatt sätt. Den flyttar bitarna till vänster och tilldelar 0 till den längst till höger.

Bitvisa operatörer används för att ändra en enskild bit. Och filtestoperatörer är lika enkla som operatörer för att kontrollera egenskaperna för en fil eller behörigheterna som läsa, skriva och köra. Dessa operatörer används tillsammans med IF-klausulen.

Observera: du kanske har stött på hur lösenorden inte syns på terminalen när du skriver. För att vara tydlig är detta inte en fråga utan en bra säkerhetspunkt. När du skriver in lösenordet hålls det mörkt men Linux sparar varje kran.

Slutsats

I den här artikeln har vi täckt de mest använda Linux-operatörerna. Från aritmetiska till bitvisa operatörer, med en kort förklaring och ett exempel. Detta är bara den bråkdel av tillgängliga kommandon, Linux har ett brett utbud av operatörskommandon, du kan lära dig och använda kommandon enligt ditt behov. Att använda och utnyttja kraften i dessa kommandon gör det lättare att använda Linux OS.

Rekommenderade artiklar

Detta är en guide till Linux-operatörer. Här diskuterar vi listan över Linux-operatörer som i princip körs på en Bourne Shell. Du kan också titta på följande artikel.

  1. Linux-systemloggning
  2. Linux File System
  3. Typer av skal i Linux
  4. Linux-distributioner