Input Output

File Descriptor

Unix နှင့် Linux OS များတွင် File Descriptor ဟု အမည်ရသော Input Output သုံး ပရိုဂရမ်ကို ပိုင်ဆိုင်ပြီး၊ Process များနှင့် ထို File Descriptor များအား ပူတွဲထားလေ့ရှိ၏။ အကယ်၍ ပရိုဂရမ်တစ်ခုမှ ဖိုင်တစ်ခုဆီသို့ Input Output လုပ်လိုသည့် အခါတိုင်း ပရိုဆက်များသည် ထို File Descriptor အား အသုံးပြု၍ အသုံးပြုလိုသော File ဆီသို့ Access လုပ်လေ့ရှိပါသည်။

File Descriptor များအား သုညမှ ငါး အထိ နံပါတ်များဖြင့် သက်မှတ်ထားပြီး၊ 0, 1, 2 အထိ ၃မျိုးသည် ကြိုတင် သတ်မှတ်ပြီး ဖြစ်၏။ ပရိုဆက်တစ်ခုခုက အလုပ်လုပ်တိုင်း ထို File Descriptor များသည် အသုံးပြုရန် အသင့် အနေအထားသို့ ပြောင်းလည်းသွားမည် ဖြစ်ပါသည်။

File Descriptor နံပတ် 0 သည် Standard Input ဖြစ်ပြီး၊ ကီးဘုတ်ဆီမှ ရိုက်သွင်းလိုက်သော Input များအား Shell ပရိုဂရမ်ဆီသို့ လက်ဆင့်ကမ်းပေးပါသည်။

တဖန် နံပတ် 1 သည် Standard Output ဖြစ်ပြီး Terminal မျက်နှာပြင်တွင် Output လုပ်စေပါသည်။ Shell ပရိုဂရမ်များအတွင်းမှ ကွန်မန်းများ၏ ရလဒ်များသည် Terminal ပေါ်တွင် ဖော်ပြနိုင်ခြင်းသည် Shell အား အလုပ်လုပ်နေသော ပရိုဆက်သည် Standard Output အား အသုံးပြု၍ Output လုပ်နေခြင်းကြောင့် ဖြစ်ပါသည်။

နံပါတ် 2 သည် Standard Error ဖြစ်ပါသည်။ Standard Error သည်လည်း Terminal ၏ မျက်နှာပြင်တွင် Output လုပ်ပါသည်။ Standard Output နှင့် Standard Error အား ခွဲခြား၍ Output လုပ်လိုသည့်အခါမျိုးတွင် အသုံးပြုနိုင်ရန် အတွက် File Descriptor အား သီးခြားစီ သတ်မှတ်ထားခြင်း ဖြစ်ပါသည်။

Redirection

အထက်ပါ File Descriptor တွင် ပုံမှန်အားဖြင့် Standard Input အား ကီးဘုတ်မှ၊ Standard Output အား Terminal ဆီသို့ ထုတ်လုပ်ပေးကြောင်း ဖော်ပြပေး၏။ ဤကဲ့သို့ Input Output များအား ပုံမှန် အသုံးပြုရာနေရာမှ  ပြောင်းပြီး အသုံးပြုခြင်းအား Redirection ဟု ခေါ်ဆိုပါသည်။ Shell ပရိုဂရမ်များတွင် Redirection အား အသုံးပြု၍ Input များအား File မှ တဆင့် အသုံးပြုခြင်း၊ Output များအား အခြားသော ဖိုင်များတွင် ရေးသားစေခြင်း အစရှိသည့် လုပ်ဆောင်ချက်များအား လုပ်ဆောင်စေနိုင်ပါသည်။

Redirection ကို အသုံးပြုရာတွင် Output အား [ > ] ဟု သော်၎င်း၊ Input အား [ < ] ဟု သော်၎င်း ရေးသားနိုင်ပါသည်။

အထက် ဖော်ပြပါအတိုင်း echo "hello shell" ဟု ရေးသားရာတွင် Standard Output ကို အသုံးပြုပါသဖြင့် ရရှိလာသော ရလဒ်အား Terminal တွင် ဖော်ပြပေးစေပါသည်။ တဖန် echo "hello shell" > test.txt ဟု ရေးထားခြင်းသည် echo "hello shell" ၏ ရလဒ်အား test.txt ဟု အမည် ရသော ဖိုင်ဆီသို့ Redirect လုပ်နေခြင်း ဖြစ်ပါသည်။ ဤနည်းအားဖြင့် echo ၏ ရလဒ်အား test.txt တွင် အသစ်ရေသားမည် ဖြစ်ပါသည်။ ထို့ကြောင့် cat test.txt ဟု ရိုက်ပြီး အတွင်းရှိစာသားများအား ဖော်ပြစေရာတွင် hello shell ဟု ဖော်ပြနိုင်ခြင်း ဖြစ်ပါသည်။

တဖန် redirection များတွင် > ဟု ရေးသားထားလျှင် ဖိုင်အား အသစ် ဖွင့်၍ ရေးသားမည်ဖြစ်ပြီး၊ >> ဟု ရေးသားထားပါက ထိုဖိုင်၏ နောက်ဆုံးစာကြောင်းမှ တဆင့် ဆက်၍ ရေးသားသွားမည် ဖြစ်ပါသည်။

အလားတူပင် < ဟု ရေးသားထားပါက Input ကို ရည်ညွှန်းခြင်း ဖြစ်ပါသည်။ ဥပမာအားဖြင့် command < file ဟု ရေးထားပါက file အတွင်းမှ ခေါ်ယူပြီး command ဆီသို့ ပါရာမီတာ အဖြစ် အသုံးပြုနိုင်မည် ဖြစ်သည်။ တဖန် << သည် ရေးသားထားသည်ကို တိုက်ရိုက်ခေါ်ယူသွင်းခြင်း ဖြစ်ပါသည်။ command << word ဟု ရေးသားထားပါက word အား ပါရာမီတာအဖြစ် command ဆီသို့ ပေးနိုင်မည် ဖြစ်ပါသည်။

ကျွှန်တော်တို့ အစပိုင်းတွင် File Descriptor များအား နံပါတ်များ သက်မှတ်ထားသည်ဟု ဖော်ပြခဲ့သည်ကို မှတ်မိပါဦးမည်။ အမှန်ဆိုလျှင် Standard Output အား ဖိုင် သို့ Redirect လုပ်မည်ဆိုလျှင် အောက်ပါအတိုင်း ရေးရန် လိုအပ်ပါသည်။

command 1> file

အကယ်၍ File Descriptor များအား ရေးသားထားခြင်း မရှိပါက၊ Default အနေဖြင့် Standard Output အား အသုံးပြုမည် ဖြစ်သောကြောင့် command > file ဟု ရေးသားထားခြင်းဖြင့် Standard Output အား file ဆီသို့ Redirect လုပ်ပေးနိုင်ခြင်း ဖြစ်ပါသည်။ အလားတူစွာပင် command < file ဟု ရေးသားထားခြင်းသည်လည်း Standard Input အား file ဆီမှ Redirect လုပ်ယူခြင်းပင် ဖြစ်ပါသည်။ ထို့ကြောင့် command 0< file ဟု ရေးသားခြင်းနှင့် ထပ်တူပင် ဖြစ်ပါသည်။

အသုံးများသော ရေးသားပုံမှာမှာ အောက်ပါအတိုင်း ဖြစ်ပါသည်။

အတိုကောက်	ပုံမှန် ရေးသားပုံ	ရှင်းလင်းချက်
> file	1> file	Standard Output အား file တွင် ရေးသားပါမည်။
>> file	1>> file	Standard Output အား file တွင် ဖြည့်စွက် ရေးသားပါမည်။
>&m	1>&m	Standard Output အား နံပါတ် m မြောက် File Descriptor တွင် ရေးသားပါမည်။
>&-	1>&-	Standard Output အား close လုပ်ပါမည်။
< file	0< file	Standard Input အား file မှ အသုံးပြုပါမည်။
<&m	0<&m	Standard Input အား နံပါတ် m မြောက် File Descriptor မှ အသုံးပြု ပါမည်။
<&-	0<&-	Standard Input အား close လုပ်ပါမည်။
<< word	0<< word	Here Document ဟု ခေါ်ဆိုပြီး၊ စာလုံးရှည်များအား Standard Input မှ အသုံးပြုလိုသည့်အခါတွင် အသုံးပြုပါသည်။

Output နမှုနာ

ကျွှန်တော်တို့ ဒီတစ်ခေါက် Shell ပရိုဂရမ်အတွင်းမှ log ရေးနိုင်သော ဖန်ရှင်အား ရေးသား၍ File Output ၏ နမှုနာကို ရေးသားကြည့်ပါမည်။

log.func

LOG()
{
        #log directory
        LOG_DIR=./

        #parameter data
        FILENM=`basename $0`
        MSG=$1

        #var
        LOG_DATE=`date '+%Y-%m-%d'`
        LOG_TIME=`date '+%H:%M:%S'`
        LOGFILE="${LOG_DIR}${LOG_DATE}_`basename $0 .sh`.log"

        printf "%-10s %-8s %-14s %-50s\n" \
        "${LOG_DATE}" "${LOG_TIME}" "${FILENM}" "${MSG}" >>${LOGFILE}
}

GetYM()
{
        SYSTEM_MONTH=`date '+%Y%m'`
        echo ${SYSTEM_MONTH}
}

GetYMD()
{
        SYSTEM_DATE=`date '+%Y%m%d'`
        echo ${SYSTEM_DATE}
}

ဤ နမှုနာထဲတွင် LOG အမည်ရသော ဖန်ရှင်အား ရေးသားထားပြီး၊ ၎င်းအား အခြားသော Shell ပရိုဂရမ်များမှ ခေါ်ယူခြင်း အားဖြင့် Log ဖိုင်များတွင် လိုအပ်သော log message များအား ရေးသားစေခြင်း ဖြစ်ပါသည်။ LOG ဖန်ရှင် အထဲတွင် basename ကွန်မန်းဖြင့် ဖိုင်အမည်ကို ရယူကာ၊ log message အတွင်းတွင်သော်၎င်း၊ log ဖိုင် အမည်တွင်၎င်း အသုံးပြုထားပါသည်။ တဖန် log message အား log ဖိုင် တွင် ရေးသားရာတွင် >> အား အသုံးပြုထားပါသည်။

GetYM နှင့် GetYMD မှာ နမှုနာတွင် အသုံးပြုရန်အတွက် ဖန်ရှင်များဖြစ်ကြပြီး၊ နှစ်လ နှင့် နှစ်လရက်ကို ရရှိနိုင်ပါသည်။

sample.sh

#!/bin/sh
#read common file
. ./log.func

#start log
LOG "Sample Application START"

#getYM
YM=`GetYM`
mkdir ${YM}
LOG "Make Directory is finished"

#getYMD
YMD=`GetYMD`
touch ${YM}/${YMD}
LOG "Creating file is finished"

LOG "Sample Application END"

ဤ နမှုနာ အတွင်းမှာမူ အသုံးပြုလိုသော common file တစ်ခုဖြစ်သည့် log.func အား . ကွန်မန်းအား အသုံးပြု၍ ခေါ်ယူထားပါသည်။ ပြီးပါက LOG ဖန်ရှင်အား အသုံးပြု၍ Log Message များအား ရေးသားစေပါသည်။ အတွင်းမှာမူ နမှုနာအနေဖြင့် ဒိုင်အတ္တရီနှင့် ဖိုင်များအား ရေးသားစေပြီး၊ အသီးသီး log message များအား ရေးသားစေပါသည်။

ကျွှန်တော်တို့ အထက်ပါ နမှုနာကို အလုပ်လုပ်ကြည့်စေပါမည်။

အထက်ပါအတိုင်း ရက်စွဲဖြင့် ဒိုင်အတ္တရီ တစ်ခုကို ရေးသားနိုင်ပြီး၊ log ဖိုင်ကိုလည်း ရေးသားနိုင်သည်ကို တွေ့ရပါသည်။

ဖိုင် Input နမှုနာ

ဒီနမှုနာတွင် အချက်အလက်များအား ဖိုင်အတွင်းတွင် သိမ်းဆည်းထား၍ ထိုအချက်အလက်များအား ဖတ်ယူကာ အလုပ်လုပ်စေတတ်သော နမှုနာတစ်ခုကို ရေးသားပါမည်။

sample.sh

#!/bin/sh

LIST=./abc.list

GETSTR()
{
        if [ $# -ne 1 ]
        then
                return 1
        else
                ID=$1
        fi

        while read F1 F2
        do
                if [ "${F1}" = "${ID}" ]
                then
                        echo ${F2}
                        break
                fi
        done < ${LIST}
}

STR002=`GETSTR 002`
STR003=`GETSTR 003`
STR005=`GETSTR 005`

echo "STR002=${STR002}"
echo "STR003=${STR003}"
echo "STR005=${STR005}"

အထက်ပါ နမှုနာထဲတွင် GETSTR ဟု အမည်ရသော ဖန်ရှင်တစ်ခုအား ရေးသားထားပါသည်။ ဖန်ရှင်အတွင်းတွင် စာကြောင်း၇ဖြင့် အကယ်၍ ဖန်ရှင်အား ခေါ်ယူသည့် ပါရာမီတာ အရေအတွက်သည် ၁ခုထက်နည်းပါက ဆက်မလုပ်ပဲ 1 ကို return လုပ်မည် ဖြစ်ပါသည်။ သို့မဟုတ်ပါက ကိန်းရှင် ID တွင် နံပါတ်တစ်ပါရာမီတာအား အစားထိုးပါမည်။ တဖန် စာကြောင်း ၁၄တွင် while ဝါကျဖြင့် ကိန်းရှင် F1နှင့် F2 အား ခေါ်ယူပါသည်။

ထို ကိန်းရှင်များမှာ စာကြောင်း ၂၁တွင် ရေးထားသည့်အတိုင်း LIST ကိန်းရှင်မှ input လုပ်ထားပါသည်။ LIST ၏ တန်ဖိုးသည် ./abc.list ဖြစ်ပါသဖြင့် abc.list ဖိုင်၏ အတွင်းရှိစာသားများဖြင့် while ဝါကျအား အလုပ်လုပ်စေမည် ဖြစ်ပါသည်။ အတွင်းပိုင်းတွင် F1 ၏တန်ဖိုးနှင့် F2 သည် တူညီပါက F2 အား echo လုပ်နေခြင်း သာဖြစ်ပါသည်။ အောက်ပါအတိုင်း abc.list ဖိုင်အား ရေးသားပါမည်။

အထွေအထူးမဟုတ်။ ကီးနှင့် တန်ဖိုးအား တွဲထားသော Map တစ်ခုကဲ့သို့ပင် ဖြစ်၏။ ရေးသားထားသော Shell အား အလုပ်လုပ် ကြည့်စေသောအခါ အောက်ပါအတိုင်း တွေ့ရပါမည်။

ဆက်ပါဦးမည်။ လေးစားစွာဖြင့်။

မင်းလွင်

Built In Commands

ပြီးခဲ့သော B Shell အခန်းဆက်များဖြင့် Shell Function များအကြောင်းကို ဖော်ပြခဲ့၏။ Shell Script တစ်ခု၏ ပရိုဂရမ်များကို ဖတ်ရှုရေးသားနိုင်မည် ဖြစ်သည်။ ရေးသားပုံမှာ ကုန်ပြီဖြစ်၏။ သို့ရာတွင် ကြားထိုးနည်းကို သင်ပြီးသော်လည်း လက်တွေ့နှစ်ကွက်ကျော်စားနည်း အစရှိသည့် ဗျူဟာများအား မသုံးတတ်သေးပဲ ရှိပါလိမ့်မည်။

စနစ်ကျ၍ အသုံးဝင်သော Shell ပရိုဂရမ်များအား ရေးသားနိုင်ရန် Shell ကွန်မန်းများနှင့် ရေးသားပုံများအား လေ့လာသွားရန် လိုအပ်ပါသည်။ နောက်ဆုံး မရှိမဖြစ်လိုအပ်တာကာတော့ အတွေ့အကြုံဖြစ်၏။ ဤအရာကတော့ ကိုယ်တိုင်များများဖတ်၊ များများတွေး၊ များများရေးမှဖြစ်ပါလိမ့်မည်။ ကျွှန်တော်တို့ ဒီကနေ့ အသုံးများသော Shell ကွန်မန်းများအကြောင်းကို ရေးသားဖော်ပြသွားပါမည်။

Built In Commands

Linux စက်များကို အသုံးပြုရာတွင် Terminal မှ cd, ls, pwd, echo, whoami, date အစရှိသည့် ကွန်မန်းများကို အသုံးပြု ဘူးမည်ဖြစ်သည်။ ဤကဲ့သို့သော ကွန်မန်းများသည် Shell Script ကို အသုံးပြုရာတွင် အသုံးပြုနိုင်ရန် ပြင်ဆင်ထားသော Built In ကွန်မန်းများ ဖြစ်ပါသည်။



man


ကွန်မန်းတစ်ခု၏ အသုံးပြုပုံအားသိရှိရန် man ကွန်မန်းကို အသုံးပြုနိုင်ပါသည်။ ဥပမာအားဖြင့် test ကွန်မန်း၏ အသုံးပြုပုံကို သိရှိရန် man test ဟု ရေးသားခြင်းအားဖြင့် test ကွန်မန်း၏ အသုံးပြုပုံကို သိရှိနိုင်ပါသည်။ အသုံးပြုနိုင်သော ပါရာမီတာများအားလည်း man အား အသုံးပြု၍ ကြည့်ရှုနိုင်ပါသည်။

man -L en_us.UTF-8 man ဟု locale အား အင်္ဂလိပ်စာဖြင့် သတ်မှတ်ပြီး man ၏ အသုံးပြုပုံကို ကြည့်ရှုခြင်းဖြစ်ပါသည်။

which


ကွန်မန်းတစ်ခုသည် မည်သည့်နေရာမှ ကွန်မန်းအား အသုံးပြုနေသည်ကို သိရှိရန်အတွက် which ကွန်မန်းအား အသုံးပြုနိုင်ပါသည်။

အထက်ပါအတိုင်း which test ဟု test ကွန်မန်း၏ နေရာကို ဖော်ပြစေပါသည်။ ထိုအခါ /user/bin/test ဟု ဖော်ပြပေးနိုင်ပါသည်။ အကယ်၍ which hello ဟု မရှိသောကွန်မန်းတစ်ခုအား ခေါ်ယူကြည့်သောအခါ အသုံးပြုသူ၏ PATH အတွင်းတွင် hello မရှိကြောင်းကို ဖော်ပြပေးနိုင်ပါသည်။

ဤနည်းအားဖြင့် Shell ပရိုဂရမ်တစ်ခုကို ရေးသားရင်း အသုံးပြုလိုသော ကွန်မန်းအား which ဒါမှမဟုတ် man ကွန်မန်းများ ဖြင့်စစ်ဆေးနိုင်ပါသည်။

အသုံးများသော ကွန်မန်းများ

အမည်	အသုံးပြုပုံ	ရှင်းလင်းချက်
.	. filename [arguments]	. ကွန်မန်းသည် ဖိုင်အတွင်းရှိ စာကြောင်းများကို ဖတ်ရှု၍ ကွန်မန်းအနေဖြင့် အလုပ်လုပ်စေသော ကွန်မန်းဖြစ်ပါသည်။ ပရိုဂရမ်အတွင်းတွင် ဘုံအနေဖြင့် အသုံးပြုလိုသော ဖန်ရှင်များ ကိန်းရှင်များအား လိုင်ဘရီအဖြစ်အသုံးပြုလိုပါက ဖိုင်တစ်ခုတွင် ရေးသားထားပြီး၊ ပရိုဂရမ်၏ အစတွင် . .mylib ဟု ရေးသားထားပါက ထိုပရိုဂရမ်အတွင်းတွင် .mylib အတွင်းတွင်ရေးသားထားသော ဖန်ရှင်များနှင့် ကိန်းရှင်များအား အသုံးပြုနိုင်မည် ဖြစ်သည်။
alias	alias [-p] [name=[value]]	အခြား အမည်ကို သတ်မှတ်ရာတွင် အသုံးပြုသော ကွန်မန်းဖြစ်ပါသည်။ alias sw='cd /home/minlwin/sh-work' အကယ်၍ အထက်ပါအတိုင်း ရေးသားထားပါက sw ဟု ရိုက်လိုက်တိုင်း /home/minlwin/sh-work နေရာကို ရွှေ့ပေးမည် ဖြစ်ပါသည်။
break	break number	while နှင့် for ဝါကျများအတွင်းတွင် ထပ်ခါတလဲလဲ လုပ်ဆောင်ချက်များအတွင်းမှ နှုတ်ထွက်လိုသည့်အခါတွင် အသုံးပြုနိုင်သော ကွန်မန်းဖြစ်ပါသည်။ break ဟု ရိုးရိုးရေးသားထားပါက ထိုနေရာအရောက်တွင် နှုတ်ထွက်သွားမည်ဖြစ်ပါသည်။ loop အဆင့်ဆင့်ကို နှုတ်ထွက်လိုပါက break ၏ ပါရာမီတာအနေဖြင့် နှုတ်ထွက်လိုသည့် loop အရေအတွက်ကို ရေးသားရန် လိုအပ်ပါသည်။
continue	continue number	continue ကွန်မန်းသည် loop လုပ်ဆောင်ချက်များ အတွင်းတွင် လက်ရှိ လုပ်ဆောင်ကြိမ်အား ပြီးဆုံးစေ၍ နောက်အကြိမ်အား လုပ်ဆောင်စေလိုသည့်အခါ များတွင် အသုံးပြုနိုင်ပါသည်။ break ကွန်မန်းကဲ့သို့ loop အကြိမ်ကြိမ်အား ကျော်လုပ်စေလိုသည့် အခါများတွင် ကျော်လုပ်စေလိုသည့် loop အရေအတွက်ကို ပါရာမီတာအဖြစ် အသုံးပြုရန် လိုအပ်ပါသည်။
eval	eval [args ...]	eval ကွန်မန်းသည် ပါရာမီတာအဖြစ်ပါဝင်သော ကွန်မန်းများ၊ ကိန်းရှင်များအား ဆက်သွယ်ပြီး တစ်ခုသော ကွန်မန်းအဖြစ်လုပ်ဆောင်စေရာတွင် အသုံးပြုနိုင်ပါသည်။
exec	exec [-cl] [-a name] [command[args]]	အကယ်၍ ကွန်မန်းတစ်ခုအား ပရိုဆက်အသစ်တစ်ခု ဖြင့် ခေါ်ယူခြင်း မပြုလုပ်လိုပါက exec ကို အသုံးပြုနိုင်ပါသည်။ exec ကို အသုံးပြုခြင်းအားဖြင့် လက်ရှိ အသုံးပြုနေသော ပရိုဆက်ဖြင့် command ကို ခေါ်ယူမည် ဖြစ်သည်။
exit	exit [n]	လက်ရှိ အလုပ်လုပ်နေသော Shell အား Status n ဖြင့် ပြီးဆုံးစေသော ကွန်မန်းတစ်ခု ဖြစ်ပါသည်။ အကယ်၍ n အား မရေးသားပါက နောက်ဆုံးရလဒ်အား Status အနေဖြင့် ရရှိမည်ဖြစ်ပါသည်။
export	export [-fn] [name[=value]] export [-p]	name အား ပတ်ဝင်းကျင်ကိန်းရှင် အဖြစ်အသုံးပြုရန် ကြော်ငြာသည့်အခါတွင် အသုံးပြုပါသည်။ -f သည် ဖန်ရှင်များအား ကြော်ငြာရာတွင် အသုံးပြုနိုင်ပါသည်။ -p သည် အသုံးပြုနိုင်သော ပတ်ဝင်းကျင်ကိန်းရှင်များအား ဖော်ပြပေးနိုင်ပါသည်။ -n သည် ပတ်ဝင်းကျင်ကိန်းရှင်များအတွင်းမှ name အမည်ရသော ကိန်းရှင်အား ဖျက်ပစ်ရာတွင် အသုံးပြုနိုင်ပါသည်။
pwd	pwd [-LP]	လက်ရှိ ဒိုင်အတ္တရီ၏ အတိအကျနေရာကို ဖော်ပြရာတွင် အသုံးပြုပါသည်။
read	read [-params] [name ...]	Shell ပရိုဂရမ်များတွင် ကိန်းရှင်တစ်ခုအား Terminal ၏ ပုံမှန် Input မှခေါ်ယူ အသုံးပြုလိုလျှင် read ကွန်မန်းကို အသုံးပြုရပါသည်။ ပြင်ပမှ ရိုက်ထည့်လာသော စာလုံးများအား name အမည်ရှိ ကိန်းရှင်များတွင် အစားထိုးပါမည်။ Shell ပရိုဂရမ်အတွင်းမှ နောက်ပိုင်း လော့ဂျစ်များတွင် ထိုကိန်းရှင်များ၏ တန်ဖိုးကို အသုံးပြုနိုင်မည် ဖြစ်ပါသည်။
readonly	readonly [-aAf] [name[=value] ...]	ပြုပြင်ပြောင်းလည်း၍ မရသော ကိန်းသေများ အဖြစ်သတ်မှတ်လိုပါက readonly ကို အသုံးပြုရပါသည်။
return	return [n]	return ကွန်မန်းသည် အလုပ်လုပ်နေသော ဖန်ရှင်တစ်ခုအား n တန်ဖိုးဖြင့် ပြီးဆုံးစေပါမည်။ အကယ်၍ n ကို ရေးသားထားခြင်း မရှိပါက၊ အလုပ်လုပ်နေသော ဖန်ရှင်၏ နောက်ဆုံး ကွန်မန်း၏ ရလဒ်ကို n အနေဖြင့် ရရှိမည် ဖြစ်ပါသည်။
set	set [-option] set [+option] set [param ...]	set ကွန်မန်းသည် လက်ရှိအသုံးပြုနေသော Shell အား option သတ်မှတ်ရာတွင် အသုံးပြုပါသည်။ - သင်္ကေတသည် option အား အသစ်သတ်မှတ်ရာတွင် အသုံးပြုပါသည်။ + သင်္ကေတသည် ရှိပြီးသား option အား ဖြုတ်ပစ်ရာတွင် အသုံးပြုပါသည်။ အသုံးများသော option များမှာ -I မှာ^Dဖြစ်သော EOF ကို အသိအမှတ်ပြုမည် မဟုတ်။ -i အပြန်အလှန် Mode ဖြင့် အလုပ်လုပ်စေမည် ဖြစ်သည်။ -n ကွန်မန်းများအား ဖတ်ရုံသာဖတ်ပြီး အလုပ်လုပ်စေမည် မဟုတ်။ -s ကွန်များအား Standard Input မှသာ ရယူမည် ဖြစ်သည်။ -v ရယူထားသော ကွန်မန်းများအား Standard Error အဖြစ်ဖော်ပြပြီး အလုပ်လုပ်စေမည်။ -x ကွန်မန်းများအား အလုပ်မလုပ်ခင် Standard Error အဖြစ်ဖော်ပြပြီးမှ ဆက်အလုပ်လုပ်စေမည် ဖြစ်သည်။ တဖန် set [param ...] ဟု အသုံးပြုခြင်းဖြင့် ပါရာမီတာများအား သတ်မှတ်နိုင်ပါသည်။
shift	shift [n]	ပါရာမီတာများအား n ဘယ်ဘက်သို့ နေရာရွှေ့စေရာတွင် အသုံးပြုပါသည်။
test	test expression [ expression ]	expression တစ်ခုသည် မှန်ကန်ခြင်း ရှိမရှိ ဆိုသည်ကို စမ်းသပ်ရာတွင် အသုံးပြုပါသည်။ ဖိုင်ဆိုပါက -r file ဖိုင်သည် ဖတ်နိုင်ပါက true -w file ဖိုင်သည် ရေးနိုင်ပါက true -x file Runnable ဖိုင်ဖြစ်ပါက true -f file သည် ဖိုင်ဖြစ်ပါက true -d file ဖိုင်သည် ဒိုင်အတ္တရီဖြစ်ပါက true -s file ဖိုင်size သည် 0 ထက်ကြီးပါက true String ဆိုပါက -z string စာလုံးအရည်အတွက်သည် 0 ဆိုပါက true -n string  စာလုံးအရည်အတွက်သည် 0 ထက်ကြီးပါက true string null မဟုတ်ပါက true string1 = string2 စာလုံးနှစ်လုံး တူညီပါက true string1 != string2 စာလုံးနှစ်လုံး မတူညီပါက true ကိန်းဂဏန်းဆိုပါက int1 -eq int2 java ၏ int1 == int2 int1 -ne int2  java ၏ int1 != int2 int1 -lt int2  java ၏ int1 < int2 int1 -le int2  java ၏ int1 <= int2 int1 -gt int2  java ၏ int1> int2 int1 -ge int2  java ၏ int1 >= int2
trap	trap command-list signals	ဖြစ်ပေါ်လာသော signal အပေါ်တွင်မှုတည်၍ ကွန်မန်းများအား အလုပ်လုပ်စေလိုပါက trap ကွန်မန်းကို အသုံးပြုရန်လိုအပ်ပါသည်။ နောက်အခန်းများတွင် signal နှင့်ပတ်သက်သော အကြောင်းအရာများကို အသေးစိတ် ဖော်ပြရန်ရှိပါသည်။
type	type [name ...]	name အမည်ရှိ ကွန်မန်း၏ အမျိုးအစားအား သိရှိလိုပါက အသုံးပြုနိုင်မည် ဖြစ်ပါသည်။
wait	wait [id ...]	process id များအား စောင့်ပြီး၊ ရလဒ်များကို စောင့်ယူနိုင်ရန် wait ကွန်မန်းကို အသုံးပြုပါသည်။ id သည် process id များသာမဟုတ် job  specification များကိုလည်း အသုံးပြုနိုင်ပါသည်။ job specification ဆိုပါက အဆိုပါ id ကို အသုံးပြုသော job များ အားလုံးကို စောင့်နေမည်ဖြစ်သည်။ အကယ်၍ id ကို ရေးသားထားခြင်းမရှိပါက အလုပ်လုပ်နေသော child process များအား စောင့်မည်ဖြစ်သည်။ နောက်ဆုံးတွင် 0 ကို return လုပ်မည်ဖြစ်သည်။ အကယ်၍ id ကို အသုံးပြုသော process သည် မရှိခဲ့ပါက၊ ဒါမှမဟုတ် ပြီးဆုံးနေပြီ ဖြစ်ပါက 127 ကို return လုပ်မည်ဖြစ်သည်။ အထက်ပါ အချက်အလက်များနှင့် မညီညွတ်ပါက နောက်ဆုံး လုပ်ဆောင်ချက်၏ ရလဒ်ကို ပြန်ပြီးreturn လုပ်မည်ဖြစ်ပါသည်။

အသုံးများသော Built In ကွန်မန်းများအား စုစည်း၍ ဖော်ပြထားပါသည်။ Option များမှာလည်း အသုံးများသော Option များကိုသာ ဖော်ပြထားသည်ဖြစ်ပါသ၍ လက်တွေ့ရေးသားခါနီး man ဖြင့် အသုံးပြုပုံကို လေ့လာပြီးမှ ရေးသားရန် အကြံပြုအပ်ပါသည်။

ဆက်ပါဦးမည်။ လေးစားစွာဖြင့်။

မင်းလွင်

B Shell Functions

စာဖတ်သူများက ထင်ကြပေမည်။ Java အကြောင်းလည်းမဟုတ်ပါလားဟု။ အကြောင်းရှိပါသည်။ Servlet နှင့် JSP ကို အစပြု၍ Enterprise Java အကြောင်းကို လွယ်ကူစွာ ဖော်ပြနေခဲ့၏။ သို့ရာတွင် Enterprise ဟုဆိုပါက အချက်အလက်များကို စနစ်တကျအသုံးပြုနိုင်ရန် လိုအပ်၏။ ဤနေရာတွင် Database ကို ချန်ထား၍မရပေ။ ထို့ကြောင့် JSP ကို ခေတ္တရပ်ထား၍ Database နှင့် JDBC ကို မိတ်ဆက်ရန် ကြံစည်ပါသည်။

Database အနေဖြင့် အခြေခံမှာ MySQL ကို အသုံးပြုရန် စီစဉ်ထားပြီး၊ Server Application များရေးလျှင် Unix Server များကို ရင်းနှီးထားပါက အစဉ်ပြေမည် ဖြစ်သည်။ လုပ်မယ့်လုပ် Linux ပေါ်ရှိ MySQL ကို အသုံးပြု၍ Database ၏ အခြေခံကို မိတ်ဆက်ရန် အကြံရပါသည်။ ထို့ကြောင့် Linux ကွန်မန်းလိုင်းပေါ်တွင် ပရိုဂရမ်ရေးသားခြင်းကို ရင်းနှီးထားစေရန် ရည်ရွယ်၍ B Shell အကြောင်းကို စရေးနေခဲ့ခြင်း ဖြစ်ပါသည်။

ပြန်လည် အသုံးပြုနိုင်ရန် အတွက် ဖန်ရှင်

ကျွှန်တော်သည် B Shell နှင့် ပတ်သက်ပြီး အခြေခံ ရေးသားပုံတို့ကို ဖော်ပြလာခဲ့သည်မှာ ဤအကြိမ်နှင့် ဆိုလျှင် ၅ ကြိမ်မြောက်ကို ရောက်ခဲ့ပါပြီ။ B Shell ဆိုသည်မှာ အဘယ်နည်း၊ B Shell တွင် အသုံးပြုသော ကိန်းရှင်များနှင့် အခြေအနေပေါ်မှုတည်၍ ပြောင်းလည်း အလုပ်လုပ်စေနိုင်သော Control ဝါကျများကို နမှုနာများနှင့် တကွ လွယ်ကူစွာ မိတ်ဆက်ခဲ့ပါသည်။

ဤတစ်ခေါက်တွင် B Shell တွင် အသုံးပြုသော ဖန်ရှင်အကြောင်းကို ဖော်ပြပါမည်။ Shell ပရိုဂရမ်မင်း အကြောင်းကို လေ့လာသူသည် အခြားသော ပရိုဂရမ်မင်း ဘာသာတစ်ခုခုကို လေ့လာပြီးသူ ဖြစ်ပါလိမ့်မည်။ အခြားသော ဘာသာရပ်များတွင် Function, Method အစရှိသည့် အမည်အမျိုးမျိုးဖြင့် ခေါ်ဆိုသော လုပ်ဆောင်ချက်များကို Shell ဘာသာရပ်တွင်လည်း အသုံးပြုနိုင်ပါသည်။ ရေးသားပုံမှာ ကွာခြားသော်လည်း သဘောတရားမှာမူ အတူတူဖြစ်ပါသည်။

ဆိုကြပါစို့၊ ကျွှန်တော်တို့ ရေးသားထားသော ပရိုဂရမ်တစ်ခုအတွင်းတွင် လော့ရေးနေသော အပိုင်းများ ရှိပါလိမ့်မည်။ ပုံမှန်အားဖြင့် ရေးလိုသည့်နေရာများတွင် တိုက်ရိုက်ရေးရင်လည်း ဖြစ်ပါသည်။ သို့ရာတွင်ပရိုဂရမ် တစ်ခုအတွင်းတွင် တူညီသော အရာများအား အကြိမ်ကြိမ်ရေးလိုသည့်အခါမျိုးတွင် တူညီသော အစီအစဉ်များအား တနေရာထဲတွင် စုရေးထားပြီး ကွဲခြားသည့်နေရာများကိုသာ ပါရာမီတာအဖြစ် ရယူရေးသားနိုင်ပါသည်။

လော့ရေးသည့်အခါတွင် ပရိုဂရမ်အစ၊ အဆုံး နှင့် ဘယ်နေရာရောက်ပြီ ဆိုသည့်အရာများအား လော့ဖိုင်အတွင်း တွင်ရေးသားပါမည်။ ရေးရမည့် သတင်း အချက်အလက်သာ ကွာခြားပါမည်။ ရေးရမည့်ဖိုင်၊ ပုံစံ၊ နှင့် အချိန်များအား ရေးထုတ်ရမည်မှာအတူတူပင်ဖြစ်၏။ ပြောင်းလည်းမည့် အကြောင်းအရာကို ပါရာမီတာ အဖြစ်ရယူပြီး တူညီသည့်နေရာများအား တစ်နေရာထဲတွင် စုရေးသားနိုင်ပါသည်။

ဤကဲ့သို့ စုဝေးထားသော အစီအစဉ် အစုအဝေးအား ဖန်ရှင်ဟု ခေါ်ဆိုပါသည်။


ဖန်ရှင်တစ်ခုအား ရေးသားပုံ


B Shell တွင်ဖန်ရှင် တစ်ခုအား ရေးသားပုံမှာ အောက်ပါအတိုင်း ဖြစ်ပါသည်။

ဖန်ရှင်၏အမည်() {
    ကွန်မန်းများ
}

နမှုနာတစ်ခု ရေးကြည့်ပါမည်။ show ဟု အမည်ရသော ဖန်ရှင်တစ်ခုကို ရေးကြည့်ပါမည်။ အတွင်းပိုင်းတွင် shell ကွန်မန်းဖြစ်သော ls -l ကို ရေးသားထားပါမည်။

ပြီးပါက show ဟု ခေါ်ဆိုကြည့်ပါမည်။ ls -l ကို အလုပ်လုပ်စေပြီး . နှင့် .. ဟု ဖော်ပြပေးပါသည်။
တဖန် touch somefile.txt ဟု ဖိုင်အလွတ် တစ်ခုကို တည်ဆောက်ပါမည်။ ပြီးပါက show ဟု ခေါ်ကြည့်သောအခါ . နှင့် .. အပြင် somefile.txt ကိုပါ ဖော်ပြနေသည်ကို တွေ့ရပါမည်။


ဖန်ရှင်အတွင်းမှ ပါရာမီတာများအား အသုံးပြုပုံ

အခြားသောဘာသာရပ်များ ကဲ့သို့ပင် B Shell ၏ ဖန်ရှင်တွင်လည်း ပါရာမီတာများကို အသုံးပြုနိုင်ပါသည်။ Shell မှာက ပါရာမီတာများကို အသုံးပြုရန် အထွေအထူး ရေးသားရန်မလိုအပ်ပေ။ Java ကဲ့သို့ Strong Type Programming ဘာသာရပ် များတွင် ပါရာမီတာများကို အသုံးပြုလိုပါက လုပ်ဆောင်ချက်တွင် ကြိုတင် ရေးသားထားရန် လိုအပ်ပါသည်။ B Shell မှာမူ ကြိုတင်ရေးသားရန် မလိုအပ်ပဲ Shell Script တွင် ရေးသားသကဲ့သို့ပင် $နှင့် အစပြုသော ပါရာမီတာများကို အသုံးပြုနိုင်ပါသည်။

ကျွှန်တော်တို့ အထက်တွင် ရေးသားထားသော show လုပ်ဆောင်ချက်အား ပြန်လည်ပြုပြင် ရေးသား ကြည့်ပါမည်။

show() {
    ls -l $1
}

ဤကဲ့သို့ ls -l $1 ဟု ရေးသားထားခြင်းအားဖြင့် နံပါတ်၁ ပါရာမီတာအား အသုံးပြုနိုင်မည် ဖြစ်ပါသည်။

အထက်ပါအတိုင်း show ဖန်ရှင်အား ရေးသားပြီး show ~ ဟု Home Directory အား ဖော်ပြကြည့်စေပါသည်။ ပါရာမီတာ ~ အား အသုံးပြု၍ ls -l ~ ကို ဖော်ပြပေးနေသည်ကို တွေ့ရပါလိမ့်မည်။

Shell ၏ အလိုအလျှောက်အသုံးပြုနိုင်သော ကိန်းရှင်များတွင် Shell Script အတွင်းတွင် အသုံးပြုနိုင်သော ပါရာမီတာများ အကြောင်းကို ရေးသားခဲ့ဘူးပါသည်။ သဘောတရားမှာ အတူတူပင်ဖြစ်သောကြောင့် ဤနေရာတွင် ပြန်လည် မရေးသားတော့ပါ။


ဖန်ရှင်၏ ရလဒ်

B Shell ဖန်ရှင်တစ်ခုတွင် ရလဒ်အား ခေါ်ယူရာသို့ ပြန်လည်ပေးပို့လိုပါက အခြားသောဘာသာရပ်များ ကဲ့သို့ပင် return ကို အသုံးပြုနိုင်ပါသည်။ ရေးသားရာတွင် ဖန်ရှင်၏ နောက်ဆုံး ကွန်မန်းအဖြစ်၎င်း၊ လော့ဂျစ်အတွင်း အနေအထားတစ်ခုကို ရောက်ရှိသွားသည့် အခါမျိုးတွင်၎င်း return အား ရေးသားနိုင်ပါသည်။ ပရိုဂရမ်အား အလုပ်လုပ်လာစေရင်း return နေရာသို့ရောက်ပါက နောက်ဆက်မလုပ်ပဲ ရလဒ်အား ခေါ်ယူသည့်နေရာဆီသို့ ပြန်ပို့ပေးမည်ဖြစ်သည်။

#!/bin/sh

twice() {
    RET=`expr $1 \* 2 2>/dev/null`

    if [ $? != 0 ]; then
        echo "Parameter $1 is not a number"
        exit -1
    fi

    return ${RET}
}

twice 29
echo "twice of 29 is" $?

twice bb
echo "twice of bb is" $?

အထက်ပါ ပရိုဂရမ်ထဲတွင် စာကြောင်း နံပါတ် ၄ တွင် RET ၏ တန်ဖိုးအား `expr $1 \* 2 2>/dev/null` ဟု နံပါတ်၁ပါရာမီတာအား ၂ဖြင့် မြှောက်ပြီး အစားထိုးပါသည်။ တဖန် စာကြောင်း ၆ တွင် if [ $? != 0 ]; then ဟု ပုံမှန်ပြီးဆုံးခြင်း မရှိပါက ပါရာမီတာ ၁သည် နံပါတ်မဟုတ်သောကြောင့် စာကြောင်း နံပါတ် ၈ တွင် exit -1 ဟု ပရိုဂရမ်အား ပြီးဆုံးစေမည် ဖြစ်သည်။ နောက်ဆုံးတွင် ရလဒ်အား return ${RET} ဟု ပြန်ပေးစေပါသည်။ ဤနည်းအားဖြင့် `expr $1 \* 2` အား လုပ်ဆောင်ခြင်းသည် ပုံမှန်ပြီးဆုံးပါက ရလဒ်အား ပြန်ပေးစေနိုင်မည် ဖြစ်ပါသည်။

အထက်ပါအတိုင်း twice ဖန်ရှင်၏ ရလဒ်အား ပြန်လည်အသုံးပြုနိုင်သည်ကို တွေ့ရပါလိမ့်မည်။ ထူးခြားသည်မှာ ရလဒ်အား $? ကိန်းရှင်အနေဖြင့် ရယူနေရခြင်း ဖြစ်ပါသည်။

ဆက်ပါဦးမည်

မင်းလွင်

ကိန်းရှင်များ ၂

ပြီးခဲ့သော တစ်ခေါက်က Shell Script ၏ ကိန်းရှင်များအကြောင်းကို ဖော်ပြခဲ့၏။ Java C များကို ရင်းနှီးခဲ့သူများအတွက် Shell Script ၏ ကိန်းရှင်များ၏ အသုံးပြုပုံမှာ အနည်းငယ် ထူးဆန်းသလို ဖြစ်ပါလိမ့်မည်။ ဥပမာအားဖြင့် ကြိုတင်သတ်မှတ်ထားခြင်း မရှိသော ကိန်းရှင်တစ်ခုအား ကွန်ပိုင်းဘာသာရပ် တစ်ခုဖြစ်သော Java တွင် အသုံးပြုနိုင်ခြင်း မရှိပေ။ ${var:=new_var} ကို Java ဖြင့်ရေးမည် ဆိုလျှင် အတော်လေး ရေးရမည် ဖြစ်သည်။ ယခုတစ်ခေါက်တွင်လည်း ဘီရှဲ၏ ကိန်းရှင်များ အကြောင်းကို ဆက်လက် ဖော်ပြသွားပါဦးမည်။

အလိုအလျှောက် အသုံးပြုနိုင်သော ကိန်းရှင်များ

B Shell ကို အသုံးပြုရာတွင် ကြိုတင်ပြင်ဆင်ထားသော ကိန်းရှင်များရှိကြ၏။ ထိုကိန်းရှင်များအား ပရိုဂရမ်မာက ရေးသားစရာမလိုပဲ အလိုအလျှောက် ခေါ်ယူအသုံးပြုနိုင်ပါသည်။ B Shell အတွင်းတွင် အလိုအလျှောက် အသုံးပြုနိုင်သော ကိန်းရှင်များမှာ အောက်ပါအတိုင်းဖြစ်၏။

ကိန်းရှင်	ရှင်းလင်းချက်
$?	နောက်ဆုံးအသုံးပြုသွားသော ကွန်မန်း၏exit ရလဒ်။
$$	ရှဲ၏ ပရိုဆက်အိုင်ဒီ။
$!	ရှဲမှ နောက်ဆုံးခေါ်ယူခဲ့သော Background Process ၏ Process ID
$0	ရှဲစကရစ်၏ အမည်။
$1-9	စကရစ်အား ခေါ်ယူရာတွင် အသုံးပြုခဲ့သော ပါရာမီတာများ။ $1 ပဋ္ဌမပါရာမီတာ $9 ၉လုံးမြောက် ပါရာမီတာ
$#	ရှဲစကရစ်အား ခေါ်ယူရာတွင် အသုံးပြုခဲ့သော ပါရာမီတာ အရေးအတွက်။ ပါရာမီတာ မပါပဲ ခေါ်ယူခဲ့ပါက ရလဒ်သည် 0 ဖြစ်ပေမည်။
$*	စကရစ်အား ခေါ်ယူရာတွင် အသုံးပြုခဲ့သော ပါရာမီတာ လစ်။ "$*" ဟု အသုံးပြုပါက "$1 $2 ... $n" ဟု ဖော်ပြပါမည်။
$@	စကရစ်အား ခေါ်ယူရာတွင် အသုံးပြုခဲ့သော ပါရာမီတာ လစ်။ "$@" ဟု အသုံးပြုပါက "$1" "$2" ... "$n" ဟု ဖော်ပြပါမည်။

test2-1.sh

#!/bin/sh

echo "Count of parameter is $#."
echo "Name of Script is $0."
echo "1st parameter is $1."
echo "2nd parameter is $2."
echo "Process ID of Script is $$."

echo "Test of \"\$*\""
for var1 in "$*"
do
        echo "Params : $var1"
done

echo "Test of \"\$@\""
for var2 in "$@"
do
        echo "Params : $var2"
done

အထက်ပါ test2-1.sh အား ပါမစ်ရှင်းပြောင်း၍ အလုပ်လုပ်ကြည့်စေပါက အောက်ပါအတိုင်း တွေ့မြင်ရမည် ဖြစ်၏။

နမှုနာ ရှဲအားခေါ်ယူရာတွင် sh test2-1.sh param1 param2 ဟု ပါရာမီတာ ၂လုံးသုံးကာ ခေါ်ယူကြည့်ပါသည်။ ရှဲ၏ အမည် ပါရာမီတာများ၊ ပရိုဆက်အိုင်ဒီများကို ဖော်ပြရာတွင် ရှင်းလင်းစွာနားလည် နိုင်ပါသည်။ သို့ရာတွင် $* နှင့် $@ ၏ ခြားနားပုံကို ကြည့်စေလိုပါသည်။

for ဝါကျကို အသုံးပြု၍ "$*" ကို အသုံးပြုကြည့်သောအကာ "param1 param2" ဟု ပါရာမီတာ တစ်လုံးအနေဖြင့် အသုံးပြုသွားပါသည်။ သို့ရာတွင် "$@" ကိုမှု "param1" "param2" ဟု တစ်လုံးခြင်း ခွဲခြားအသုံးပြုနိုင်ပုံကို တွေ့မြင်နိုင်ပါသည်။

$* နှင့် $@ တို့သည် ပါရာမီတာလစ်ကို ဖော်ပြတာခြင်းတူသော်လည်း ""ကို ဝန်းရန်အသုံးပြုခြင်းအားဖြင့် $* သည် ပါရာမီတာ တစ်လုံးအဖြစ်ပြောင်းလည်းပြီး၊ $@ မှာမူ လစ်အဖြစ်မှ ပြောင်းလည်းခြင်းမရှိပါ။

ကိန်းရှင်များအား ကွန်မန်းရလဒ်များဖြင့်အစားထိုးခြင်း

ကွန်မန်း၏ရလဒ်များအား ကိန်းရှင်၏တန်ဖိုးအဖြစ် အစားထိုးအသုံးပြုနိုင်ပါသည်။ ရှဲဘာသာရပ်တွင် ကွန်မန်းများ၏ အဖွင့်အပိတ်တွင် (`) ဖြင့် ဝန်းရန်ရေးသားပါက၊ ၎င်းကွန်မန်း၏ ရလဒ်သည် တန်ဖိုးအဖြစ်ပြန်လည် အစားထိုး အသုံးပြုနိုင်မည် ဖြစ်သည်။

test2-2.sh

#!/bin/sh

var=`date`

echo $var

var=`date` ဟု ရေးသားထားခြင်း အားဖြင့် ကိန်းရှင် var တွင် date ကွန်မန်း၏ ရလဒ်ကို အစားထိုးပါသည်။ ထို့ကြောင့် echo $var ဟု ရေးသားသောခါ date ကွန်မန်း၏ ရလဒ်ကို ဖော်ပြနိုင်ခြင်း ဖြစ်၏။ ကိန်းရှင် var ကို အစားမထိုးပဲလဲ၊ echo `date` ဟု ရေးသားရုံဖြင့် date ကွန်မန်း၏ ရလဒ်ကို ကွန်ဆိုးပေါ်တွင် ဖော်ပြပေးနိုင်မည် ဖြစ်၏။

ရှဲစကရစ်၏ အထူးစာလုံးများနှင့် စကားလုံးများအား ပေါင်းဆက်ခြင်း

အထူးစာလုံးများ

ပရိုဂရမ်မင်းဘာသာရပ်များတွင် အချို့သောစာလုံးများ ဒါမှမဟုတ် စကားလုံးများအား ပရိုဂရမ်အတွင်းတွင် အဓိပ္ပါယ်တစ်ခုခု အနေဖြင့် အသုံးပြုနေကြပါသည်။ ဤကဲ့သို့သော စာလုံးများအား အထူးစာလုံးများဟု ခေါ်ဆိုပြီး၊ စကားလုံး (String) များ အနေဖြင့် တိုက်ရိုက်အသုံးပြု၍မရပေ။ ထိုစာလုံးများအား ကျော်ပြီးသုံးမည်ဟု(Escape) သက်မှတ်ပြီးမှသာ String ဒါမှမဟုတ် Text အနေဖြင့် အသုံးပြုနိုင်မည် ဖြစ်သည်။

ရှဲဘာသာရပ်တွင် အသုံးပြုနေသော အထူးစာလုံးများမှာ အောက်ပါအတိုင်းဖြစ်၏။

; & ( ) | ^ < > ? * [ ] $ ` " ' { } [TAB] [SPACE]

ဘီရှဲဘာသာရပ်တွင် ဤကဲ့သို့ အထူးစာလုံးများအား Escape လုပ်ရာတွင် နည်းလမ်း၃မျိုးရှိပါသည်။

1. နောက်ပြန်မျဉ်းစောင်း (\) အား အသုံးပြုခြင်း။ အထူးစာလုံး တစ်လုံးခြင်းဆိုပါက (\) စာလုံးကို အထူးစာလုံး၏ အရှေ့တွင် ရေးသားခြင်းအားဖြင့် အထူးစာလုံးအား Text စာလုံးအနေဖြင့် အသုံးပြုနိုင်ပါသည်။
2. Single Quotation (') ဖြင့် ဝန်းရံခြင်း။ စာကြောင်းတစ်ခု ဒါမှမဟုတ် စကားလုံးတစ်လုံး အား (') ဖြင့် ဝန်းရံထားပါက အတွင်းရှိ အထူးစားလုံးများအား ပုံမှန် Text စာလုံးအဖြစ် ဖော်ပြပေးနိုင်မည် ဖြစ်သည်။
3. Double Quotation (") ဖြင့် ဝန်းရံခြင်း။ စာကြောင်းတစ်ခု ဒါမှမဟုတ် စကားလုံးတစ်လုံး အား (") ဖြင့် ဝန်းရံထားပါက အတွင်းရှိ [$ ` \] မှလွဲသော အခြားသော အထူးစားလုံးများအား ပုံမှန် Text စာလုံးအဖြစ် ဖော်ပြပေးနိုင်မည် ဖြစ်သည်။ ဤနည်းအားဖြင့် $ ကွန်မန်း နှင့် \ စာလုံးများအား Text အဖြစ်အသုံးပြုလိုပါက (') ကို အသုံးပြု၍ မှုရင်း အထူးစာလုံးအဖြစ် အသုံးပြုလိုပါက (") ကို အသုံးပြုခြင်းဖြင့် ခွဲခြား အသုံးပြုနိုင်ပါသည်။

လက်တွေ့ ရေးသားကြည့်ပါဦးမည်။

test2-3.sh

#!/bin/sh

var="hello minlwin"
echo $var
echo "$var"
echo '$var'
echo \$var
echo '\$var'

စာလုံးများအား ပေါင်းဆက်ခြင်း


ပရိုဂရမ်မင်းဘာသာရပ်အပေါ် မှုတည်၍ Text ဒါမှမဟုတ် String စာလုံးများအား ပေါင်းစပ်ပုံ အမျိုးမျိုးကွဲခြားပါသည်။ လူသိများသော JavaScript ဘာသာရပ်တွင် + ကို အသုံးပြု၍ String တစ်ခုနှင့် တစ်ခုကို ပေါင်းစက်နိုင်ပါသည်။ Java ဘာသာရပ်တွင်မှု + ကို သော်၎င်း၊ StringBuilder ဒါမှမဟုတ် StringBuffer ကလပ်စ်များ၏ အော့ဘဂျက်များကို အသုံးပြု၍ စာလုံးများအား ပေါင်းဆက်၍ စာလုံးတစ်လုံးအနေဖြင့် အသုံးပြုနိုင်ပါသည်။ သို့ရာတွင် B Shell ဘာသာရပ်တွင်မှု အထွေအထူး ဘာမှရေးသားစရာမလိုပဲ ဒီအတိုင်း စာလုံးနှစ်လုံးကို ဘေးချင်းယှဉ်ရေးသားရုံဖြင့် စာလုံးနှစ်လုံးအား တစ်လုံးအဖြစ်အသုံးပြုနိုင်ပါသည်။ လက်တွေ့ရေးသားကြည့်ပါမည်။

test2-4.sh

#!/bin/sh

VAR1="hello"
VAR2="Min Lwin"

echo $VAR1 $VAR2

echo "How are" "you?"

ဆက်ပါဦးမည်။ လေးစာစွာဖြင့်။

မင်းလွင်

ကိန်းရှင်များ

ကွန်ပျူတာ ပရိုဂရမ်မင်းဘာသာရပ် အတော်များများမှာ ပရိုဂရမ်အတွင်းတွင် အသုံးပြုနေသည့် တန်ဖိုးများကို အစားထိုးအသုံးပြုရန် ကိန်းရှင်များကို အသုံးပြုလေ့ရှိပါသည်။ ဘီရှဲတွင်လည်း ကိန်းရှင်များကို အသုံးပြု၍ ပရိုဂရမ်များကို ရေးသားနိုင်ပါသည်။ ကိန်းရှင်များအား အင်္ဂလိပ်စာလုံးများနှင့် _ စာလုံးကို အသုံးပြု၍ ရေးသား နိုင်ပါသည်။ သို့ရာတွင် ပဋ္ဌမဦးဆုံးစာလုံးအား ကိန်းဂဏာန်းများကို အသုံးပြု၍မရပေ။ ကိန်းရှင်များအား အစားထိုးအသုံးပြုရာတွင် = ကို အသုံးပြု၍ ကိန်းရှင်အား တန်ဖိုးဖြင့် အစားထိုးနိုင်ပါသည်။ သတိပြုရန် အချက်မှာ = ၏ ဘယ်ညာတွင် Blank စာလုံးကို အသုံးပြု၍ မရပါ။

#!/bin/sh

var="This is variable"

echo $var

အထက်ပါအတိုင်း $var ဟု ရေးသားခြင်း အားဖြင့် ကိန်းရှင်များ၏ တန်ဖိုးများအား အသုံးပြုနိုင်ပါသည်။ ထို့ကြောင့် echo $var ကွန်မန်း၏ ရလဒ်သည် this is variable ဟု ကိန်းရှင်၏ တန်ဖိုးကို echo လုပ်ပေးနိုင်ခြင်း ဖြစ်ပါသည်။

တန်ဖိုးသတ်မှတ်မထားသေးသော ကိန်းရှင်များအား အသုံးပြုခြင်း

B Shell တွင် ကိန်းရှင်တစ်လုံး၏ တန်ဖိုးသည် ဗလာဖြစ်သည့်အခါတွင်၎င်း၊ သတ်မှတ်ထားခြင်း မရှိသည့်အခါမျိုး တွင်၎င်း အမျိုးမျိုးသော လုပ်ဆောင်ချက်များကို လုပ်ဆောင်စေနိုင်ပါသည်။

ရေးသားပုံ	တန်ဖိုးသတ်မှတ်ပြီးအခါ	တန်ဖိုးသတ်မှတ်ထားခြင်း မရှိသောအခါ
${ကိန်းရှင်:-word}	ကိန်းရှင်၏ တန်ဖိုးကို အသုံးပြုပါမည်။	word ၏ တန်ဖိုးအား အသုံးပြုပါမည်။
${ကိန်းရှင်:=word}	ကိန်းရှင်၏ တန်ဖိုးကို အသုံးပြုပါမည်။	word ၏ တန်ဖိုးအား ကိန်းရှင်တွင် အစားထိုး၍ အသုံးပြုပါမည်။
${ကိန်းရှင်:?word}	ကိန်းရှင်၏ တန်ဖိုးကို အသုံးပြုပါမည်။	word အား Error Message အဖြစ် အသုံးပြု၍ စကရစ်အား ပြီးဆုံးစေပါမည်။
${ကိန်းရှင်:+word}	word ၏ တန်ဖိုးဖြင့် ကိန်းရှင်အား အစားထိုးပါမည်။	ဘာမှမလုပ်ပါ

${ကိန်းရှင်:-word}

#!/bin/sh

echo What is your name? $name
echo What is your name? ${name:-minlwin}
echo $name

name=kgkg
echo What is your name? ${name:-minlwin}

စာကြောင်း ၄ကြောင်းမြောက်တွင် name သည် တန်ဖိုးသတ်မှတ်ထားခြင်း မရှိပါသဖြင့် minlwin အား အစားထိုး အသုံးပြုသွားသည်ကို တွေ့ရပါမည်။ သို့ရာတွင် name အား အစားထိုးခြင်း မရှိပါသဖြင့် စာကြောင်း နံပါတ် ၅ ၏ echo $name ရဲ့ ရလဒ်မှာ ဗလာ အတိုင်းဖြစ်ပါသည်။

တဖန် စာကြောင်း ၇ တွင် name အား kgkg ဖြင့် အစားထိုးပါသည်။ ထို့ကြောင့် စာကြောင်း ၈ တွင် ${name:-minlwin} ဟု ရေးသားထားပါသော်လည်း name မှာ ဗလာ မဟုတ်ပါသောကြောင့် name ၏ တန်ဖိုးဖြစ်သော kgkg ကို ဖော်ပြနိုင်ခြင်း ဖြစ်ပါသည်။


${ကိန်းရှင်:=word}

#!/bin/sh

echo What is your name? $name
echo What is your name? ${name:=minlwin}
echo $name

name=kgkg
echo What is your name? ${name:=minlwin}
echo $name

စာကြောင်း၄ တွင် name ၏ တန်ဖိုးသည် သတ်မှတ်ထားခြင်းမရှိပါသဖြင့်၊ ${name:=minlwin} ဟု ရေးသားထားသောကြောင့် echo ၏ ရလဒ်မှာ minlwin အား အစားထိုး၍ အသုံးပြုသွားပါသည်။ တဖန် စာကြောင်း ၅ ၏ ရလဒ်ကို ကြည့်ခြင်းအားဖြင့် name ၏ တန်ဖိုးအား minlwin ဖြင့် အစားထိုးသွားသည်ကို တွေ့မြင် နိုင်ပါသည်။

တဖန် စာကြောင်း ၇ တွင် name အား kgkg ဖြင့် အစားထိုးပါသဖြင့်၊ စာကြောင်း၉တွင် name အစား minlwin ဖြင့် ဖော်ပြခြင်းမရှိသလို၊ စာကြောင်း ၁၀ အားကြည့်ခြင်းအားဖြင့် name ၏ တန်ဖိုးအား minlwin ဖြင့် အစားမထိုးကြောင်း တွေ့မြင်နိုင်ပါသည်။


${ကိန်းရှင်:?word}

#!/bin/sh

name=kgkg
echo What is your name? ${name:?minlwin}

name=
echo What is your name? ${name:?minlwin}

စာကြောင်း ၄ ၏ ရလဒ်သည် name ၏ တန်ဖိုးသည် kgkg ဖြစ်ပါသဖြင့် kgkg ကို ဖော်ပြပေးပါသည်။ စာကြောင်း ၇ ၏ ရလဒ်သည် စာကြောင်း ၆ တွင် name အား ဗလာဖြင့် အစားထိုးထားပါသဖြင့် Error Message အဖြင့် minlwin ကို ဖော်ပြပြီး၊ Script အား အမှားအဖြစ် ပြီးဆုံးစေပါသည်။


${ကိန်းရှင်:+word}

#!/bin/sh

name=kgkg
echo What is your name? ${name:+minlwin}
echo $name
name=
echo What is your name? ${name:+minlwin}

စာကြောင်း ၄၏ ရလဒ်သည် name တွင် kgkg ဟူသော တန်ဖိုးကို ပိုင်ဆိုင်သောကြောင့် minlwin ကို အစားထိုးဖော်ပြပါသည်။ သို့ရာတွင် စာကြောင်း ၇ ၌မှု name ၏ တန်ဖိုးမှာ ဗလာဖြစ်ပါသဖြင့် minlwin ဖြင့် အစားထိုးဖော်ပြခြင်း မရှိသည်ကို တွေ့ရပါမည်။

ဆက်လက် လေ့လာဖော်ပြသွားပါဦးမည်။

လေးစားစွာဖြင့်

မင်းလွင်

Hello B Shell

ဆာဗာအပလီကေးရှင်းများ ရေးသားသူတွေအတွက်တော့ ရင်းနှီးပြီး ဘာသာရပ်တစ်မျိုးဖြစ်ပါသည်။ Open Source အပလီများ ခေတ်စားလာသည်နှင့်အတူ Linux ဆာဗာများသည်လည်း အသုံးများလာကြပါသည်။ ဂျပန်လိုနိုင်ငံမျိုးမှာတော့ ဆာဗာစက်အတော်များများသည် ယခင်ကတည်းက Solaries, AIX ကဲ့သို့ Unix ဆာဗာများကို အသုံးပြုခဲ့သခဲ့သို့ Open Source ခေတ်အရောက်မှာလည်း Unix ကို အခြေခံသော Linux ဆာဗာများကို အသုံးပြုလာပါသည်။

Unix အခြေခံ Linux စက်များသည် ယခင်ကတည်းက ဆာဗာအတွက်ကိုရည်ရွယ်ပြီး ရေးသားခဲ့ပါသဖြင့် ဆာဗာအတွက် အလွန်သင့်တော်သည်မှာ မေးစရာပင်မလို။ ယခုနောက်ပိုင်းတွင် GUI ဘက်ပိုင်းဆိုင်ရာတွင် တိုးတက်လာခဲ့ပြီး Ubintu၊ CentOS အစရှိသည့် Personal PC သုံး Linux OS များကြောင့် Linux ကို ပို၍ လူသိများလာခဲ့ပါသည်။

Shell ဆိုသည်မှာ Linux စက်များအပေါ်တွင် အသုံးပြုနိုင်သော လွန်စွာအသုံးဝင်သည့် Script ဘာသာရပ် တစ်မျိုးဖြစ်ပါသည်။ Linux ကို အသုံးပြုဘူးသူတိုင်းသိရှိပါလိမ့်မည်။ Linux တွင် GUI အပြင် CUI Interface သည် လွန်စွာမှ အသုံးဝင်လှပါသည်။ Linux စက်ပေါ် Login လုပ်ပြီး Command Prompt ကို ဖွင့်ကာ ls ဟု ကွန်မန်းကို ရိုက်လိုက်ပါက လက်ရှိ Directory အောက်ရှိ ဖိုင် နှင့် ဒိုင်အတ္တရီများကို ဖော်ပြပေးနိုင်ပါသည်။ ထိုကဲ့သို့ ကွန်မန်းများသည် Shell ကွန်မန်းများဖြစ်ကြပြီး၊ ထို Shell ကွန်မန်းများအား စီရီ၍ ကွန်ပျူတာအား လိုအပ်သလို ခိုင်းစေနိုင်ပါသည်။ Shell ကွန်မန်းများ စီရီရေသားထားသော Text ဖိုင်များအား Shell Script ဖိုင်များ ဟုခေါ်ဆိုပါသည်။

Shell သည် အမျိုးအစားကွဲပေါင်းများစွာရှိ၏။ ထင်ရှားသည်မှာ Bash Shell၊ C Shell, Korn Shell (kshell) တို့ဖြစ်ကြ၏။ ထို့အပြင် Shell ဘာသာရပ်၏ ဝါကျများသည် လွန်စွာရိုးရှင်း၍ တော်ရုံ ကွန်ပျူတာပရိုဂရမ်မင်း အခြေခံရှိသူ တစ်ယောက်ဆိုပါက အထွေအထူးလေ့လာစရာမလိုပဲ Manual များကို ဖတ်ပြီး လက်တမ်း ချရေးနိုင်လောက်အောင် လွယ်ကူလှပါသည်။ တဖန် Shell တစ်မျိုးမျိုးကို လေ့လာဖူးပါက ကျန်သော Shell များကိုလည်း လွယ်ကူစွာ လေ့လာ အသုံးပြုနိုင်ပါသည်။ ထို့အပြင် Shell များသည် လွယ်ကူရုံသာမက လွန်စွာမှ အသုံးဝင်လှပေသည်။ ဤခေါင်းစဉ်ဖြင့် ဘယ် Linux အပေါ်တွင်မဆို Default အနေဖြင့် ပါဝင်သော B Shell အကြောင်းကို မိတ်ဆက်သွားပါမည်။

Hello B Shell

ပြောနေသည်ထက် ရေးကြည့်သည် ကပို၍မြန်ပါသည်။

Linux တာမိနယ်ကို ဖွင့်၍ အထက်ပါအတိုင်း vi hello.sh ဖြင့် Text ဖိုင်တစ်ခုရေးသားရန် vi Editor ကို ဖွင့်ပါမည်။ ပြီးလျှင် အောက်ပါ Shell ကွန်မန်းများကို ရေးသားပါမည်။

#!/bin/sh

echo "Hello B Shell"

ပဋ္ဌမစာကြောင်းဖြင့် အသုံးပြုမည့် Interpreter ကို သတ်မှတ်နေပါသည်။ ဤနေရာတွင် /bin/sh ဟု ရေးသားထားပါသည်။ Interpreter ၏ နေရာသည် စက်နှင့် အသုံးပြုသူ၏ သက်မှတ်ချက်အပေါ်တွင် မှုတည်၍ ပြောင်းလည်းတတ်ပါသည်။ ထို့ကြောင့် ဘယ်နေရာမှာ shell ၏ Interpreter ရှိမှန်းမသိပါက which sh ဟု ရိုက်ကြည့်ပါက အသုံးပြုနေသည့် Interpreter ၏ နေရာကို ဖော်ပြပေးပါမည်။ တတိယစာကြောင်းသည် ဤ စကရစ်တွင် အသုံးပြုမည့် အမိန့်ပေးစာကြောင်းဖြစ်ပါသည်။ ဤနေရာတွင် echo "Hello B Shell" ဟု ရေးသားထားပါသည်။ echo ကွန်မန်းကို အသုံးပြု၍ "Hello B Shell" ဟူသည့် စာကြောင်းကို ဖော်ပြပေးနိုင်ပါသည်။

ပြီးပါက cat hello.sh ဖြင့် ရေးသားထားသော စာများအား ပြန်ဖွင့်ကြည့်ပါမည်။ ပြီးလျှင် ls -l ကွန်မန်းကို ရိုက်ထည့်လိုက်ပါက hello.sh ဖိုင်ကို တွေ့ရမည် ဖြစ်သည်။ vi ဖြင့်ရေးထားသော ဖိုင်သည် Default အတိုင်းဆိုပါက ရေးသား၍ ဖတ်နိုင်သော (-rw-rw-r--) Text ဖိုင်တစ်ခုသာဖြစ်ပါမည်။ Shell Script အဖြစ်အသုံးပြုနိုင်ရန် chmod +x hello.sh ဟု ပါမစ်ရှင်းကို ပြောင်းလည်းပါမည်။

-rwxrwxr-x ဟု Runnable ဖိုင်အဖြစ်ပြောင်းလည်းသွားသည်ကို တွေ့ရပါမည်။ သင်သည် Shell Script ဖိုင်တစ်ခုကို ရေးသားပြီး ဖြစ်ပါလိမ့်မည်။ ./hello.sh ဟု ရိုက်ကြည့်ပါက ရေးသားထားသော hello.sh သည် အလုပ်လုပ်ပြီး Hello B Shell ဟု ဖော်ပြပေးနိုင်သည်ကို တွေ့ရပါလိမ့်မည်။

တစ်ခုသတိထားမိမည် ဖြစ်ပါသည်။ hello.sh ကို ခေါ်ယူရာတွင် ./hello.sh ဟု ရေးသားနေပါသည်။ အကြောင်းမှာ ကွန်ပျူတာတစ်လုံးတွင် ကွန်မန်းများအား ခေါ်ယူရာတွင် အသုံးပြုမည့် နေရာများကို ကြိုတင်သတ်မှတ်ထားရန်လိုအပ်ပါသည်။ ကွန်ပျူတာအတွင်းတွင် အသုံးပြုမည့် ကွန်မန်းများအား PATH ဟု အမည်ရသော ကိန်းရှင်အတွင်းတွင် ကြိုတင်သတ်မှတ်ထားရန်လိုအပ်ပါသည်။

အကယ်၍ hello.sh ရိုက်လိုက်ပါက PATH အတွင်းတွင် hello.sh ကို ရှာဖွေမည် ဖြစ်၏။ မတွေ့ပါက ရှာမတွေ့ပါဟု အဖြေပြန်ထုတ်ပေးမည် ဖြစ်၏။ ယခုတစ်ခေါက်တွင် hello.sh ကို ရေးသားသားသော ဒိုင်အတ္တရီအား PATH အတွင်းတွင် သတ်မှတ်ထားခြင်းမရှိသောကြောင့် နေရာအတိအကျကို ဖော်ပြပေးရန် လိုအပ်ပါသည်။ ./ သည် Current Directory ကို ဖော်ပြနိုင်ပါသဖြင့် ./hello.sh ဟု ရေးသားရခြင်း ဖြစ်ပါသည်။ ဤကဲ့သို့ရေးသားသောကြောင့် current directory အောက်ရှိ hello.sh ကို အလုပ်လုပ်ရန်လိုအပ်သည်ဟု ကွန်ပျူတာမှသိရှိနိုင်ပြီး Hello B Shell ဟု ပြန်လည် ဖော်ပြပေးနိုင်ခြင်းဖြစ်ပါသည်။

ကွန်မန့်များ

ပရိုဂရမ်တစ်ခုသည် ကွန်မန်းများကို စီရီရေထားခြင်းဖြင့် အလုပ်လုပ်စေနိုင်ပါသည်။ သို့ရာတွင် ကွန်မန်းများကြီးသာဆိုပါက လူတစ်ယောက်က ဖက်ကြည့်မည်ဆိုလျှင် နားလည်ရခက်ခဲမည် ဖြစ်သည်။ နောင်တစ်ချမ်း ပြန်ဖတ်ကြည့်မည်ဆိုလျှင် တစ်ခါတစ်လေ ဘာရေးထားမှန်း မသိ ဖြစ်တတ်ပါသည်။

ပရိုဂရမ်များအားနာလည် လွယ်ကူစေရန် ပရိုဂရမ်အတွင်းတွင် အလုပ်လုပ်ရန် မလိုသော်လည်း ရေးသားသူများ နားလည်လွယ်စေရန် ကွန်မန့်များကို ရေးသားလေ့ရှိ၏။ C နှင့် java ဘာသာရပ်များတွင်// /* */ အစရှိသည့် လက္ခဏာများကို အသုံးပြု၍ ကွန်မန့်များကို ရေးသားလေ့ရှိ၏။ Shell ဘာသာရပ်တွင်လည်း ကွန်မန့်များကို ရေးသားနိုင်ပါသည်။

# စ၍ ရေးသားထားသော စာကြောင်းများသည် ကွန်မန့်များဖြစ်ကြ၏။ အထက်ပါ hello.sh အား ကွန်မန့်တစ်ခု ဖြည့်စွက်ရေးသားကြည့်ပါမည်။

#!/bin/sh

# out hello b shell
echo "Hello B Shell"

အထက်ပါအတိုင်း # out hello b shell ဟုရေးသားထားသော စာကြောင်းသည် ကွန်မန့် စာကြောင်းဖြစ်ပါသဖြင့် ပရိုဂရမ်ကအလုပ်လုပ်စရာမလိုပဲ echo "Hello B Shell" ကိုသာ အလုပ်လုပ်စေမည် ဖြစ်ပါသည်။

ယနေ့ဘလောဂ်ဖြင့် Shell Script တစ်ခု ရေးသားပုံကို လွယ်ကူစွာ မိတ်ဆက်ခဲ့ပါသည်။ Shell Script ပရိုဂရမ်တစ်ခုသည် ကွန်မန်းများကို စီရီရေးသားထားသော Text ဖိုင်တစ်ခုဖြစ်ပြီး၊ ကွန်မန်းများအကြားတွင် ရေးသားသူများ ဖတ်၍ နားလည်လွယ်ကူစေရန် ကွန်မန့်များကို ဖြည့်စွက် ရေးသားနိုင်ပါသည်။

နောက်ဘလောဂ်ဖြင့် Shell တွင် အသုံးပြုနိုင်သော ကိန်းရှင်များ အကြောင်းကို ဆက်လက်ဖော်ပြပါဦးမည်။

လေးစားစွာဖြင့်

မင်းလွင်