Variabelen vormen het essentiële onderdeel van programmeren, of we kunnen zeggen dat ze de geest van een programmeertaal vormen. Variabelen specificeren de geheugenlocatie via tekens, numeriek en alfanumeriek. Er wordt naar hen verwezen en ze kunnen in een computerprogramma worden gemanipuleerd.
Wat zijn de variabelen?
Variabelen zijn de containers waarin gegevens of een nuttig stukje informatie worden opgeslagen als de waarde erin. Hieronder vindt u de syntaxis voor een variabele:
Variable_name =value
Een variabele is een gecombineerde vorm van twee woorden, d.w.z. variabel + in staat, wat betekent dat de waarde ervan kan worden gewijzigd en meerdere keren kan worden gebruikt.
converteer Java-object naar json
Variabele staat bekend als de tijdelijke opslag voor elk soort gegevens, zoals integer, float, char, enz. Een variabelenaam kan zijn: alfabetten, cijfers en onderstrepingstekens , en de naam kan alleen met alfabetten en onderstrepingstekens beginnen.
Opmerking: we kunnen geen variabelenaam definiëren die met een willekeurig cijfer begint.
Wat zijn Bash-variabelen?
We kunnen bash-variabelen niet gebruiken zonder over de juiste informatie te beschikken ( syntaxis, gegevenstypen, typen, werking ) erover, dus laten we deze korte tutorial doornemen om het juiste overzicht van Bash-variabelen te krijgen.
Ken eerst de syntaxis.
Syntaxis:
Variable_name=value
Regels voor het definiëren van Bash-variabelen:
- Voeg een dollarteken ($) toe aan de naam van de variabele tijdens het lezen of afdrukken van een variabele.
- Laat het dollarteken ($) weg als u een variabele met een willekeurige waarde instelt.
- De naam van een variabele kan alfanumeriek zijn, of kan worden geschreven met een onderstrepingsteken (_).
- Een variabelenaam is hoofdlettergevoelig: x en X worden beschouwd als twee verschillende variabelen.
- de variabelenaam kan in UPPER_CASE- of LOWER_CASE-letters worden geschreven, of in een combinatie van beide, zoals u wilt.
- Een variabele kan overal in een Bash-script of op de opdrachtregel worden geplaatst, omdat Bash deze tijdens runtime zal vervangen door de toegewezen waarde. Het werd mogelijk doordat vervanging werd uitgevoerd voordat de opdracht werd uitgevoerd.
- Er mag geen witruimte staan aan weerszijden van het gelijkteken (=) tussen de naam van de variabele en de waarde ervan. Hieronder volgen enkele voorbeelden van Ongeldige variabelen met spaties (aangegeven door punten ...) ertussen, zoals hieronder weergegeven:
var1=...variabele1
var2...=variabele2
var3...=...variabele3 - Het is niet nodig om aanhalingstekens te gebruiken, zowel enkele als dubbele, om een variabele te definiëren met een waarde van één teken, zoals var1=variabel . Als u meerdere woorden of String als één item in een variabele wilt invoeren, gebruikt u aanhalingstekens om uw inhoud in die variabele te plaatsen.
- Enkele aanhalingstekens ('') helpen elk teken te behandelen.
- Dubbele aanhalingstekens ('') helpen bij de vervanging.
Gegevenstypen
In de formele programmeertalen moet u het gegevenstype van elke variabele definiëren op het moment dat de variabele wordt gedeclareerd. Bijvoorbeeld:
int year=2012 char comp_name='jtp'
Maar in het geval van Bash hoeft u het gegevenstype van geen enkele variabele te definiëren op het moment dat de variabele wordt gedeclareerd. Bash-variabelen zijn dat wel ongetypeerd , wat betekent dat u gewoon de naam van de variabele typt door de waarde ervan toe te wijzen, en het zal automatisch rekening houden met dat gegevenstype.
Zodanig dat als u een numerieke waarde aan de variabele toewijst, deze als geheel getal zal werken en als u een tekenwaarde aan de variabele toewijst, het een String zal zijn.
year=2012 comp_name=jtp
gebruik het echo-commando en lees ze door een $-teken voor hun naam toe te wijzen, zoals
echo $jaar
echo $naam
Soorten Bash-variabelen
Er zijn twee soorten variabelen in een shell of elk UNIX-systeem.
- Door het systeem gedefinieerde variabelen
- Door de gebruiker gedefinieerde variabelen
1. Door het systeem gedefinieerde variabelen: Dit zijn de vooraf gedefinieerde variabelen zoals ze worden gemaakt en onderhouden door het LINUX-besturingssysteem zelf. Hun standaardconventie is dat ze over het algemeen worden gedefinieerd in hoofdletters, dat wil zeggen UPPER_CASE. Dus wanneer u een variabele ziet die in hoofdletters is gedefinieerd, zijn dit hoogstwaarschijnlijk de door het systeem gedefinieerde variabelen.
Dit zijn de volgende door het systeem gedefinieerde variabelen, zoals hieronder weergegeven:
1. BASH vertegenwoordigt de Shell-naam.
Voorbeeld:
BASH=/usr/bin/bash
2. BASH_VERSIE specificeert de shell-versie die de Bash bevat.
Voorbeeld:
BASH_VERSION=4.2.46(2)
3. KOLOMMEN specificeer het nr. van kolommen voor ons scherm.
Voorbeeld:
COLUMNS=80
4. THUIS specificeert de thuismap voor de gebruiker.
Voorbeeld:
HOME=/home/jatpoint
5. LOGNAAM specificeert de gebruikersnaam voor loggen.
Voorbeeld:
LOGNAME=javatpoint
6. OSTYPE vertelt het type besturingssysteem.
Voorbeeld:
OSTYPE=linux-gnu
7. PWD vertegenwoordigt de huidige werkmap.
Voorbeeld:
PWD=/home/javatpoint
8. GEBRUIKERSNAAM specificeert de naam van de momenteel ingelogde gebruiker.
Voorbeeld:
USERNAME=javatpoint
Om de lijst met deze variabelen in uw systeem te kennen, typt u de opdrachten set, omv , En afdrukkenv op de opdrachtregelterminal als volgt:
1. Typ het set commando.
Uitgang:
2. Typ het omg commando
Uitgang:
3. Typ de opdracht printenv
Uitgang:
Laten we deze variabelen oproepen via Bash Shell. Hieronder volgen de gegeven stappen:
Stap 1: Maak een script met de naam Bash_sdvar en typ de volgende code als volgt in de Bash Console:
#! /bin/bash # Bash System-defined Variables echo $HOME # Home Directory echo $PWD # current working directory echo $BASH # Bash shell name echo $BASH_VERSION # Bash shell Version echo $LOGNAME # Name of the Login User echo $OSTYPE # Type of OS
Stap 2. Kijk naar de Bash-console hieronder:
Stap 3. Sla het script op en voer het uit. Het toont de uitvoer zoals u kunt zien in de onderstaande afbeelding.
Uitgang:
2. Door de gebruiker gedefinieerde variabelen: Deze variabelen worden door de gebruiker gemaakt en onderhouden. Over het algemeen worden dit soort variabelen gedefinieerd in LOWER_CASES. Er bestaat geen strikte regel om deze variabelen in kleine letters te schrijven. We kunnen ze ook in hoofdletters schrijven.
Laten we een Bash-script maken om deze variabelen te definiëren. Volg de onderstaande stappen:
Stap 1. Maak een script met de naam by bash_yard en typ de volgende code in Bash Console:
#! /bin/bash # User-Defined Variables name=Peter ROLL_NO=5245325 echo 'The student name is $name and his Roll number is $ROLL_NO.'
Stap 2. Zie de code op Bash Console.
Stap 3. Bewaar het script en voer het uit.
Uitgang:
Werking van Bash-variabelen
Laten we, na een basisdemonstratie van variabelen, gaan kijken hoe ze werken?
Er zijn twee acties die we gewoonlijk uitvoeren voor een variabele in Bash, zoals hieronder weergegeven:
- een waarde instellen voor een variabele
- het lezen van de waarde ervoor.
Een variabele waarde kan op verschillende manieren worden ingesteld, waarbij de meest gebruikelijke manier is om de waarde rechtstreeks in te stellen. Om een variabele te lezen, kunnen we de naam ervan (voorafgegaan door een $-teken) ergens in het script plaatsen.
Bash controleert eerst alle namen van variabelen alsof ze aanwezig zijn in het script. Vervolgens interpreteert het elke regel van ons script. Nadat elke variabele is geïdentificeerd, wordt de naam van een variabele vervangen door de toegewezen waarde. Het interpreteert/voert die coderegel immers uit en zet dit proces voort voor elke gecodeerde regel van ons script.
OPMERKING: Beide soorten variabelen in Bash (we hebben besproken) werken zowel op de terminal als op het Bash-script. Laten we hun werk aan terminal en Bash zien aan de hand van een eenvoudig voorbeeld:
Voorbeeld: Roep een gebruikersnaam op met XYZ, zijn locatie waar hij momenteel werkt en de versie van Bash Shell die hij gebruikt voor Bash Scripting.
1. Werken aan de terminal
2. Werken aan Bash Shell
Zie het script met de naam Bash_Var hieronder:
In de 3rdregel van het script , hebben we een variabele gedeclareerd GEBRUIKER_NAME om de gebruikersnaam op te slaan XYZ als zijn waarde.
In de laatste twee regels , hebben we het bedoelde bericht afgedrukt met behulp van de echo commando.
Er staan twee variabelen en één opdracht in dit bericht. Elk ervan wordt voorafgegaan door het dollarteken ($) waarbij:
Voor een beter begrip kunt u dit script maken door de gegeven code te volgen:
#! /bin/bash #Bash Variables USER_NAME=XYZ echo Hey there! $USER_NAME is any user currently working on the directory $PWD with Bash Shell Version $BASH_VERSION.
Het toont de uitvoer zoals u kunt zien in de volgende afbeelding:
Uitgang:
Er zijn nog enkele voorbeelden voor het oefenen van variabelen op zowel terminal als Bash Shell. Door het volgen van de regels ingesteld (eerder besproken) oefen als volgt met variabelen:
A. Met behulp van de opdrachtregelterminal
1. De variabelen instellen
2. De variabelen lezen en ernaar verwijzen
3. Ongeldige variabelen
4. Combineren van twee stringvariabelen
5. Strings aaneenschakelen met variabelen
OPMERKING: Gebruik geen enkele aanhalingstekens voor het combineren van twee variabelen en ook voor het aaneenschakelen van tekenreeksen met variabelen. Zodanig dat als je Strings aaneenschakelt door ze tussen enkele aanhalingstekens te plaatsen, het niet lukt om ze te lezen, zoals je kunt zien in de onderstaande afbeelding:
B. Bash-script gebruiken:
Het is een voorbeeld van het combineren van de String-variabelen.
Uitgang:
Opdrachtregelargumenten
Commandoregelargumenten worden gebruikt om een script dynamischer te maken door invoer aan de code door te geven. We geven deze argumenten tijdens de runtime van het script door in de volgende vorm:
./script_name arg1 arg2 arg3.....
Er mag geen spatie staan tussen de scriptnaam en alle passerende argumenten.
Hoe gebruik ik opdrachtregelargumenten?
In een Bash Shell worden ze gebruikt met de verwijzing naar de volgende standaardparameters of de speciale variabelen.
Hieronder volgen de twee methoden die we gebruiken voor het doorgeven van opdrachtregelargumenten:
Methode 1: Positienummer gebruiken
Het is de eerste manier om toegang te krijgen tot de argumenten door de standaardparameters (...) te gebruiken. Onderstaande afbeelding legt het uit:
Uitgang:
Methode 2: Array gebruiken.
Het is de tweede manier om de argumenten als een array door te geven. Volg het gegeven algoritme om deze methode toe te passen.
Stap 1: Maak een Bash-script.
Stap 2: Declareer een willekeurige variabelenaam en wijs de waarde ervan toe als $ een in de volgende vorm:
variable_name=('$@')
Waar $@ is het standaardargument dat wordt gebruikt om de argumenten (we doorgeven) op te slaan als een array.
Stap 3: Geef de argumenten weer door hun array-index in de volgende vorm te definiëren:
${variable_name[i]} Stap 4: Sla het script op en sluit het.
Stap 5: Voer het script uit door de argumenten door te geven.
Zie het volgende programma:
Programma:
#!/bin/bash args=('$@') echo ${args[0]} ${args[1]} ${args[2]} ${args[3]} Op Bash-console:
Uitgang:
Commando vervanging
Volgens de officiële documentatie van Bash
'Commandovervanging maakt het mogelijk dat de uitvoer van een commando het commando zelf vervangt. Bash voert de uitbreiding uit door de opdracht uit te voeren in een subshell-omgeving en de opdrachtvervanging te vervangen door de standaarduitvoer van de opdracht, waarbij alle volgende nieuwe regels worden verwijderd. Ingebedde nieuwe regels worden niet verwijderd, maar kunnen wel worden verwijderd tijdens het splitsen van woorden.'
Commandovervanging verwijst naar een uitbreiding die Bash voor ons uitvoert. Het neemt de uitvoer van het Bash-commando, slaat het op in een variabele (meestal) en geeft het weer met echo.
Commando vervanging biedt dataflexibiliteit met betrekking tot scripting en toewijzing van variabelen. Het is eenvoudig en gemakkelijk om de enkele opdrachtregeluitvoer te hebben. Als de uitvoer over een paar regels gaat, worden de nieuwe regels verwijderd en komt de volledige inhoud van de uitvoer op één regel terecht.
Zie de syntaxis voor gebruik:
Syntaxis
De klassieke vorm van het vervangen van opdrachten in een variabele of opdrachtvervanging is het gebruik van aanhalingstekens (`...`), zoals hieronder weergegeven:
variable_name=`command_name` variable_name=`command_name [option...] argument1 argument2...` variable_name=`/path/to/command`
Nu voeren we opdrachtvervanging uit door de opdrachten tussen haakjes te plaatsen (voorafgegaan door het dollarteken ($)). Even kijken:
variable_name=$(command_name) variable_name=$(command_name [option...] argument1 argument2...) variable_name=$(path/to/command)
Laten we dus opdrachtvervanging uitvoeren met een voorbeeld volgens de discussie.
In dit voorbeeld vervangen we het enkele commando ls in een variabele. Zie de terminal.
Lijn 1: Zonder opdrachtvervanging wordt de uitvoer over meerdere regels uitgebreid.
Lijn 2 en 3: Met opdrachtvervanging wordt de uitvoer op een enkele regel beëindigd (ruimte bespaard door nieuw getrokken regels te verwijderen).
Hieronder volgt het Bash-script om de opdrachtvervanging te testen.
Programma:
#! /bin/bash # command substitution lsResult=$(ls) echo 'My files are:' $lsResult
Zie de Bash-console:
Uitgang:
