Bash
आंतरिक चर

परिचय

एक नज़र में बैश आंतरिक चर

परिवर्तनशील	विवरण
$* / $@	समारोह / स्क्रिप्ट स्थिति संबंधी पैरामीटर (तर्क)। इस प्रकार विस्तार करें: $* और $@ $1 $2 ... (ध्यान दें कि यह आमतौर पर उन लोगों को छोड़ने का कोई मतलब नहीं है) "$*" "$1 $2 ..." 1 के समान है "$@" "$1" "$2" ... 1. तर्क $ IFS के पहले चरित्र द्वारा अलग किए जाते हैं, जिसमें स्थान नहीं होना चाहिए।
$#	स्क्रिप्ट या फ़ंक्शन को पारित किए गए स्थितीय मापदंडों की संख्या
$!	सबसे हाल की नौकरी में अंतिम (righ- सबसे पाइपलाइनों के लिए) कमांड प्रक्रिया पृष्ठभूमि में डाल दी जाती है (ध्यान दें कि नौकरी नियंत्रण प्रक्रिया सक्षम होने पर नौकरी की प्रक्रिया समूह आईडी के समान नहीं है)
$$	उस प्रक्रिया की आईडी जो bash निष्पादित करती है
$?	अंतिम आदेश की स्थिति से बाहर निकलें
$n	स्थितिगत पैरामीटर, जहां n = 1, 2, 3, ..., 9
${n}	स्थितिगत पैरामीटर (ऊपर जैसा), लेकिन n> 9 हो सकता है
$0	लिपियों में, वह पथ जिसके साथ लिपि को आमंत्रित किया गया था; bash -c 'printf "%s\n" "$0"' name args' साथ bash -c 'printf "%s\n" "$0"' name args' : name (इनलाइन स्क्रिप्ट के बाद पहला तर्क), अन्यथा, उस bash को प्राप्त argv[0] ।
$_	अंतिम कमांड का अंतिम क्षेत्र
$IFS	आंतरिक क्षेत्र विभाजक
$PATH	PATH पर्यावरण वैरिएबल लुक-अप निष्पादन योग्य का उपयोग करता है
$OLDPWD	पिछले काम निर्देशिका
$PWD	वर्तमान कार्यशील निर्देशिका
$FUNCNAME	निष्पादन कॉल स्टैक में फ़ंक्शन नामों की सरणी
$BASH_SOURCE	FUNCNAME सरणी में तत्वों के लिए स्रोत पथ युक्त सरणी। स्क्रिप्ट पथ प्राप्त करने के लिए उपयोग किया जा सकता है।
$BASH_ALIASES	साहचर्य सरणी जिसमें सभी वर्तमान में परिभाषित उपनाम हैं
$BASH_REMATCH	पिछले रेगेक्स मैच से मैचों का एरियर
$BASH_VERSION	बैश संस्करण स्ट्रिंग
$BASH_VERSINFO	बैश संस्करण की जानकारी के साथ 6 तत्वों की एक सरणी
$BASH	वर्तमान में बाश शेल को निष्पादित करने के लिए पूर्ण पथ (उत्तराधिकारी द्वारा निर्धारित bash द्वारा निर्धारित argv[0] और $PATH का मूल्य; कोने के मामलों में गलत हो सकता है)
$BASH_SUBSHELL	बैश सब लेवल
$UID	प्रक्रिया चलाने का रियल (प्रभावी नहीं करता है, तो अलग) यूज़र आईडी bash
$PS1	प्राथमिक कमांड लाइन प्रॉम्प्ट; पीएस * चर का उपयोग कर देखें
$PS2	द्वितीयक कमांड लाइन प्रॉम्प्ट (अतिरिक्त इनपुट के लिए प्रयुक्त)
$PS3	तृतीयक कमांड लाइन प्रॉम्प्ट (चुनिंदा लूप में प्रयुक्त)
$PS4	क्वाटरनरी कमांड लाइन प्रॉम्प्ट (वर्बोज़ आउटपुट के साथ जानकारी संलग्न करने के लिए प्रयुक्त)
$RANDOM	0 और 32767 के बीच एक छद्म यादृच्छिक पूर्णांक
$REPLY	कोई चर निर्दिष्ट नहीं होने पर डिफ़ॉल्ट रूप से read उपयोग किया जाने वाला चर। उपयोगकर्ता द्वारा आपूर्ति किए गए मूल्य को वापस करने के लिए select द्वारा भी उपयोग किया जाता है
$PIPESTATUS	ऐरे वैरिएबल जो हाल ही में निष्पादित अग्रभूमि पाइपलाइन में प्रत्येक कमांड के निकास स्थिति मान रखता है।

परिवर्तनशील असाइनमेंट में पहले और बाद में कोई स्थान नहीं होना चाहिए। a=123 नहीं a = 123 । बाद अलगाव साधन में (एक समान रिक्त स्थान से घिरा हुआ चिह्न) आदेश चला a तर्क के साथ = और 123 है, हालांकि यह भी स्ट्रिंग तुलना ऑपरेटर में देखा जाता है (जो वाक्य रचना करने के लिए एक तर्क है [ या [[ या जो भी आप कर रहे हैं परीक्षण का उपयोग)।

$ BASHPID

बैश के वर्तमान उदाहरण की प्रोसेस आईडी (पीआईडी)। यह $$ चर के समान नहीं है, लेकिन यह अक्सर एक ही परिणाम देता है। यह बैश 4 में नया है और बैश 3 में काम नहीं करता है।

~> $ echo "\$\$ pid = $$  BASHPID = $BASHPID"
$$ pid = 9265  BASHPID = 9265

$ BASH_ENV

बैश स्टार्टअप फ़ाइल की ओर इशारा करते हुए एक पर्यावरण चर, जो एक स्क्रिप्ट के आने पर पढ़ा जाता है।

$ BASH_VERSINFO

एक सरणी जिसमें पूर्ण संस्करण जानकारी तत्वों में विभाजित है, $BASH_VERSION तुलना में बहुत अधिक सुविधाजनक है यदि आप केवल प्रमुख संस्करण की तलाश कर रहे हैं:

~> $ for ((i=0; i<=5; i++)); do echo "BASH_VERSINFO[$i] = ${BASH_VERSINFO[$i]}"; done
BASH_VERSINFO[0] = 3
BASH_VERSINFO[1] = 2
BASH_VERSINFO[2] = 25
BASH_VERSINFO[3] = 1
BASH_VERSINFO[4] = release
BASH_VERSINFO[5] = x86_64-redhat-linux-gnu

$ BASH_VERSION

चलाए जा रहे बैश के संस्करण को दिखाता है, यह आपको यह तय करने की अनुमति देता है कि क्या आप किसी उन्नत सुविधाओं का उपयोग कर सकते हैं:

~> $ echo $BASH_VERSION
4.1.2(1)-release

$ संपादक

डिफ़ॉल्ट संपादक जो किसी भी स्क्रिप्ट या प्रोग्राम, आमतौर पर vi या emacs द्वारा अनपेक्षित होगा।

~> $ echo $EDITOR
vi

$ FUNCNAME

वर्तमान फ़ंक्शन का नाम प्राप्त करने के लिए - टाइप करें:

my_function()
{
    echo "This function is $FUNCNAME"    # This will output "This function is my_function"
}

यदि आप इसे फ़ंक्शन के बाहर टाइप करते हैं तो यह निर्देश कुछ भी नहीं लौटाएगा:

my_function

echo "This function is $FUNCNAME"    # This will output "This function is"

$ HOME

उपयोगकर्ता की होम निर्देशिका

~> $ echo $HOME
/home/user

$ HOSTNAME

स्टार्टअप के दौरान सिस्टम को होस्टनाम सौंपा गया।

~> $ echo $HOSTNAME
mybox.mydomain.com

$ HOSTTYPE

यह चर हार्डवेयर की पहचान करता है, यह निर्धारित करने में उपयोगी हो सकता है कि कौन से बायनेरिज़ को निष्पादित करना है:

~> $ echo $HOSTTYPE
x86_64

$ समूह

उपयोगकर्ता के समूहों की संख्या वाले एक सरणी में है:

#!/usr/bin/env bash
echo You are assigned to the following groups:
for group in ${GROUPS[@]}; do
   IFS=: read -r name dummy number members < <(getent group $group )
   printf "name: %-10s number: %-15s members: %s\n" "$name" "$number" "$members" 
done

$ आईएफएस

आंतरिक फ़ील्ड सेपरेटर स्ट्रिंग समाहित करता है, जो लूपिंग करते समय स्ट्रिंग्स को विभाजित करने के लिए बैश का उपयोग करता है। डिफ़ॉल्ट सफेद वर्ण वर्ण है: \n (newline), \t (टैब) और स्थान। इसे किसी और चीज़ में बदलने से आप विभिन्न वर्णों का उपयोग करके तारों को विभाजित कर सकते हैं:

IFS=","
INPUTSTR="a,b,c,d"
for field in ${INPUTSTR}; do
    echo $field
done 

उपरोक्त का आउटपुट है:

a
b
c
d

टिप्पणियाँ:

• यह शब्द विभाजन के रूप में ज्ञात घटना के लिए जिम्मेदार है।

$ lineno

वर्तमान स्क्रिप्ट में लाइन नंबर को आउटपुट करता है। स्क्रिप्ट डीबग करते समय अधिकतर उपयोगी।

#!/bin/bash
# this is line 2
echo something  # this is line 3
echo $LINENO # Will output 4

$ MACHTYPE

उपरोक्त $HOSTTYPE समान, इसमें OS के साथ-साथ हार्डवेयर के बारे में भी जानकारी शामिल है

~> $ echo $MACHTYPE
x86_64-redhat-linux-gnu

$ OLDPWD

OLDPWD ( OLDP rint W orking D irectory ) में अंतिम cd कमांड से पहले डायरेक्टरी होती है:

~> $ cd directory
directory> $ echo $OLDPWD
/home/user

$ OSTYPE

मशीन पर चल रहे OS के प्रकार, जैसे, के बारे में जानकारी लौटाता है।

~> $ echo $OSTYPE
linux-gnu

$ पथ

आदेशों के लिए बायनेरिज़ खोजने के लिए खोज पथ। सामान्य उदाहरणों में शामिल हैं /usr/bin और /usr/local/bin ।

जब कोई उपयोगकर्ता या स्क्रिप्ट कमांड चलाने का प्रयास करता है, तो निष्पादन अनुमति के साथ मेल खाते फ़ाइल को खोजने के लिए $PATH में रास्ते खोजे जाते हैं।

$PATH की निर्देशिकाओं को a : character द्वारा अलग किया जाता है।

~> $ echo "$PATH"
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin

इसलिए, उदाहरण के लिए, उपरोक्त $PATH देखते हुए, यदि आप प्रॉम्प्ट पर lss टाइप lss , तो शेल /usr/kerberos/bin/lss , फिर /usr/local/bin/lss , तब /bin/lss , तब /usr/bin/lss , इस क्रम में, यह निष्कर्ष निकालने से पहले कि ऐसा कोई आदेश नहीं है।

$ PPID

स्क्रिप्ट या शेल के माता-पिता की प्रक्रिया आईडी (पीआईडी), जिसका अर्थ है वर्तमान स्क्रिप्ट या शेल को लागू करने की प्रक्रिया।

~> $ echo $$
13016
~> $ echo $PPID
13015

$ लोक निर्माण विभाग

PWD ( P rint W orking D irectory) वर्तमान में आपके द्वारा वर्तमान में काम कर रहे निर्देशिका:

~> $ echo $PWD
/home/user
~> $ cd directory
directory> $ echo $PWD
/home/user/directory

$ सेकंड

सेकंड की संख्या एक स्क्रिप्ट चल रही है। शेल में दिखाए जाने पर यह काफी बड़ा हो सकता है:

~> $ echo $SECONDS
98834

$ SHELLOPTS

अपने व्यवहार को नियंत्रित करने के लिए स्टार्टअप पर विकल्प बैश की एक आसान सूची की आपूर्ति की जाती है:

~> $ echo $SHELLOPTS
braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor

$ SHLVL

जब bash कमांड निष्पादित होता है तो एक नया शेल खोला जाता है। $ SHLVL पर्यावरण चर वर्तमान स्तर के शीर्ष पर चल रहे शेल स्तरों की संख्या रखता है।

एक नई टर्मिनल विंडो में, निम्न कमांड निष्पादित करने से उपयोग में लिनक्स वितरण के आधार पर विभिन्न परिणाम प्राप्त होंगे।

echo $SHLVL

फेडोरा 25 का उपयोग करते हुए, आउटपुट "3" है। यह इंगित करता है, कि एक नया शेल खोलते समय, एक प्रारंभिक बैश कमांड एक कार्य को निष्पादित और निष्पादित करता है। प्रारंभिक बैश कमांड एक बाल प्रक्रिया (दूसरा बैश कमांड) निष्पादित करता है, जो बदले में, नए शेल को खोलने के लिए एक अंतिम बैश कमांड निष्पादित करता है। जब नया शेल खुलता है, तो यह 2 अन्य शेल प्रोसेस की चाइल्ड प्रोसेस के रूप में चल रहा होता है, इसलिए "3" का आउटपुट होता है।

निम्नलिखित उदाहरण में (उपयोगकर्ता को फेडोरा 25 चला रहा है), एक नए शेल में $ SHLVL का आउटपुट "3" पर सेट किया जाएगा। जैसा कि प्रत्येक बैश कमांड को निष्पादित किया जाता है, $ SHLVL वेतन वृद्धि एक से।

~> $ echo $SHLVL
3
~> $ bash
~> $ echo $SHLVL
4
~> $ bash
~> $ echo $SHLVL
5

कोई यह देख सकता है कि 'बैश' कमांड को निष्पादित करने (या बैश स्क्रिप्ट को निष्पादित) एक नया खोल खोलता है। इसकी तुलना में, एक स्क्रिप्ट की सोर्सिंग वर्तमान शेल में कोड को चलाती है।

test1.sh

#!/usr/bin/env bash
echo "Hello from test1.sh. My shell level is $SHLVL"
source "test2.sh"

test2.sh

#!/usr/bin/env bash
echo "Hello from test2.sh. My shell level is $SHLVL"

run.sh

#!/usr/bin/env bash
echo "Hello from run.sh. My shell level is $SHLVL"
./test1.sh

निष्पादित:

chmod +x test1.sh && chmod +x run.sh
./run.sh

आउटपुट:

Hello from run.sh. My shell level is 4
Hello from test1.sh. My shell level is 5
Hello from test2.sh. My shell level is 5

$ यूआईडी

एक केवल पढ़ने योग्य चर जो उपयोगकर्ताओं की आईडी संख्या संग्रहीत करता है:

~> $ echo $UID
12345

$ 1 $ 2 $ 3 आदि ...

कमांड लाइन या फ़ंक्शन से स्क्रिप्ट के लिए पास किए गए पोजिशनल पैरामीटर:

#!/bin/bash
# $n is the n'th positional parameter
echo "$1"
echo "$2"
echo "$3"

उपरोक्त का आउटपुट है:

~> $ ./testscript.sh firstarg secondarg thirdarg
firstarg
secondarg
thirdarg

यदि स्थिति संबंधी तर्क की संख्या नौ से अधिक है, तो घुंघराले ब्रेसिज़ का उपयोग किया जाना चाहिए।

#  "set -- " sets positional parameters
set -- 1 2 3 4 5 6 7 8 nine ten eleven twelve
# the following line will output 10 not 1 as the value of $1 the digit 1
# will be concatenated with the following 0
echo $10   # outputs 1
echo ${10} # outputs ten
# to show this clearly:
set -- arg{1..12}
echo $10 
echo ${10}

$ #

कमांड लाइन तर्कों या स्थितीय मापदंडों की संख्या प्राप्त करने के लिए - प्रकार:

#!/bin/bash
echo "$#"

तीन तर्कों के साथ चलने पर ऊपर का उदाहरण आउटपुट के साथ आएगा:

~> $ ./testscript.sh firstarg secondarg thirdarg
3

$ *

एक ही तार में स्थितीय मापदंडों के सभी वापस आ जाएगी।

testscript.sh:

#!/bin/bash
echo "$*"

स्क्रिप्ट को कई तर्कों के साथ चलाएं:

./testscript.sh firstarg secondarg thirdarg 

आउटपुट:

firstarg secondarg thirdarg

$!

बैकग्राउंड में चलने वाली अंतिम नौकरी की प्रक्रिया आईडी (पीआईडी):

~> $ ls &
testfile1 testfile2
[1]+  Done                    ls
~> $ echo $!
21715

$ _

अंतिम कमांड से अंतिम फ़ील्ड को आउटपुट करता है, जो किसी अन्य कमांड को आगे से पास करने के लिए उपयोगी है:

 ~> $ ls *.sh;echo $_
testscript1.sh  testscript2.sh
testscript2.sh

---

यह स्क्रिप्ट पथ देता है यदि किसी अन्य कमांड से पहले उपयोग किया जाता है:

test.sh:

#!/bin/bash
echo "$_"

आउटपुट:

~> $ ./test.sh # running test.sh
./test.sh

नोट: यह स्क्रिप्ट पथ प्राप्त करने का एक मूर्ख तरीका नहीं है

$?

अंतिम निष्पादित फ़ंक्शन या कमांड की निकास स्थिति। आमतौर पर 0 का मतलब होगा ठीक है और कुछ भी विफलता का संकेत देगा:

~> $ ls *.blah;echo $?
ls: cannot access *.blah: No such file or directory
2
~> $ ls;echo $?
testfile1 testfile2
0

$$

वर्तमान प्रक्रिया की प्रक्रिया आईडी (पीआईडी):

~> $ echo $$
13246

$ @

"$@" अलग-अलग शब्दों के रूप में कमांड लाइन के सभी तर्कों तक फैलता है। यह "$*" से अलग है, जो सभी तर्कों को एक शब्द के रूप में विस्तारित करता है।

"$@" तर्कों के माध्यम से लूपिंग और रिक्त स्थान के साथ तर्कों को संभालने के लिए विशेष रूप से उपयोगी है।

विचार करें कि हम एक स्क्रिप्ट में हैं, जिसे हमने दो तर्कों के साथ लागू किया है, जैसे:

$ ./script.sh "␣1␣2␣" "␣3␣␣4␣"

---

चर $* या $@ $1␣$2 में विस्तारित होंगे, जो बदले में 1␣2␣3␣4 में विस्तार 1␣2␣3␣4 इसलिए नीचे लूप:

for var in $*; do # same for var in $@; do
    echo \<"$var"\>
done

दोनों के लिए प्रिंट करेंगे

<1>
<2>
<3>
<4>

---

जबकि "$*" को "$1␣$2" में विस्तारित किया जाएगा जो बदले में "␣1␣2␣␣␣3␣␣4␣" में विस्तारित होगा और इसलिए लूप:

for var in "$*"; do
    echo \<"$var"\>   
done

केवल एक बार echo करेगा और प्रिंट करेगा

<␣1␣2␣␣␣3␣␣4␣>

---

और अंत में "$@" का विस्तार "$1" "$2" में होगा, जो "␣1␣2␣" "␣3␣␣4␣" और "␣1␣2␣" "␣3␣␣4␣" में विस्तारित होगा

for var in "$@"; do
    echo \<"$var"\>
done

छप जाएगा

<␣1␣2␣>
<␣3␣␣4␣>

इस प्रकार दोनों आंतरिक अंतर को तर्कों और तर्कों को अलग करते हुए संरक्षित किया जाता है। ध्यान दें कि for var in "$@"; do ... निर्माण for var in "$@"; do ... इतना सामान्य और मुहावरेदार है कि यह लूप के लिए डिफ़ॉल्ट है और इसे for var; do ... छोटा किया जा सकता है for var; do ...

$ HISTSIZE

याद किए गए आदेशों की अधिकतम संख्या:

~> $ echo $HISTSIZE
1000

$ यादृच्छिक

हर बार जब इस पैरामीटर को संदर्भित किया जाता है, तो 0 और 32767 के बीच एक यादृच्छिक पूर्णांक उत्पन्न होता है। इस चर के मान को रैंडम संख्या जनरेटर ( स्रोत ) को सौंपना।

~> $ echo $RANDOM 
27119
~> $ echo $RANDOM 
1349