Environment Variable និង PATH

មាតិកា

1. Variable នៅក្នុង Shell
2. Environment Variable
3. export៖ បញ្ជូន Variable ទៅកម្មវិធី
4. របៀបដែលកម្មវិធីប្រើ Environment Variable
5. PATH៖ កន្លែងដែល Shell ស្វែងរក Command
6. ហេតុអ្វី «Command Not Found» កើតឡើង
7. ធ្វើឲ្យការផ្លាស់ប្តូរនៅជាប់រហូត៖ .zshrc និង .bashrc
8. Alias៖ Shortcut ផ្ទាល់ខ្លួនរបស់អ្នក
9. សាកល្បងដោយខ្លួនឯង

1. Variable នៅក្នុង Shell

ដូចភាសាសរសេរកម្មវិធីដែរ shell អាចរក្សាទុកតម្លៃក្រោមឈ្មោះមួយ — ហៅថា variable។ បង្កើតវាដោយ name=value៖

city=Phnom Penh

zsh: command not found: Penh

មានច្បាប់ពីរដែលធ្វើឲ្យគ្រប់គ្នាជំពប់ដួលនៅដំបូង៖

• កុំដាក់ដកឃ្លាជុំវិញ =។ city = Phnom មិនបង្កើត variable ទេ — shell គិតថា city ជា command ហើយ = និង Phnom ជា argument របស់វា។
• ដាក់សញ្ញាសម្រង់ជុំវិញតម្លៃដែលមានដកឃ្លា។ បើមិនដូច្នោះទេ shell នឹងឈប់នៅដកឃ្លាទីមួយ ដូចដែលអ្នកបានឃើញខាងលើ។

ដូច្នេះ៖

city="Phnom Penh"

ដើម្បី ប្រើ variable សូមដាក់ $ នៅពីមុខឈ្មោះរបស់វា។ Shell ជំនួស $city ដោយតម្លៃរបស់វា មុនពេលរត់ command៖

echo "I live in $city"

I live in Phnom Penh

ប្រើ សញ្ញាសម្រង់ពីរ (double quote) ជុំវិញអត្ថបទដែលមាន variable។ សញ្ញាសម្រង់មួយ (single quote) (ជំពូកទី 4) តឹងរ៉ឹង៖ shell ទុកអ្វីៗទាំងអស់នៅខាងក្នុងវាដូចដែលបានសរសេរ រួមទាំង $ ផងដែរ៖

echo 'I live in $city'

I live in $city

Variable រស់នៅតែក្នុង shell session បច្ចុប្បន្ន ប៉ុណ្ណោះ។ បិទ terminal ហើយ city ក៏បាត់ទៅ។

2. Environment Variable

Variable មួយចំនួនត្រូវបានកំណត់រួចជាស្រេចសម្រាប់អ្នក មុនពេលអ្នកវាយអ្វីមួយផង។ ពួកវាត្រូវបានហៅថា environment variable ហើយវាពិពណ៌នាអំពីបរិស្ថានដែលកម្មវិធីរបស់អ្នកដំណើរការនៅក្នុង។ តាមទម្លាប់ ឈ្មោះរបស់វាសរសេរជា អក្សរធំ៖

echo $HOME
echo $USER
echo $SHELL

/Users/dara
dara
/bin/zsh

ដើម្បីមើលទាំងអស់៖

env

នោះជាបញ្ជីវែងមួយ — pipe វាឆ្លងកាត់ sort ឬ less ឬស្វែងរកក្នុងវាដោយ env | grep HOME។

3. export៖ បញ្ជូន Variable ទៅកម្មវិធី

មានភាពខុសគ្នាសំខាន់មួយរវាង shell variable ធម្មតា និង environment variable។ ចាំពីជំពូកទី 8 ថា គ្រប់ command ទាំងអស់ជា child process របស់ shell អ្នក។ Variable ធម្មតានៅតែក្នុង shell ប៉ុណ្ណោះ។ Environment variable ត្រូវបាន ចម្លងចូលទៅក្នុងគ្រប់ child process ដែល shell ចាប់ផ្តើម។

អ្នកអាចមើលឃើញរឿងនេះដោយប្រើ bash -c ដែលចាប់ផ្តើម child shell ថ្មីមួយដើម្បីរត់ command តែមួយ៖

GREETING="Hello"
bash -c 'echo "The child sees: $GREETING"'

The child sees:

Child មិនទទួលបានអ្វីសោះ។ ឥឡូវ export វា ដែលប្រែក្លាយវាទៅជា environment variable៖

export GREETING
bash -c 'echo "The child sees: $GREETING"'

The child sees: Hello

អ្នកអាចបង្កើត និង export ក្នុងជំហានតែមួយ៖

export GREETING="Hello"

សញ្ញាសម្រង់មួយជុំវិញ command bash -c មានសារៈសំខាន់នៅទីនេះ៖ វាការពារមិនឲ្យ shell របស់អ្នក ជំនួស $GREETING ដោយខ្លួនឯង ដូច្នេះ child shell ទើបជាអ្នកស្វែងរកតម្លៃរបស់វា។

ក៏មាន shortcut មួយសម្រាប់កំណត់ variable សម្រាប់ តែ command មួយ ដោយមិនរក្សាវាទុកបន្ទាប់ពីនោះ — ដាក់វានៅពីមុខ៖

GREETING="Hi" bash -c 'echo $GREETING'

អ្នកនឹងឃើញលំនាំនេះក្នុង project ពិតៗ ដូចជា PORT=4000 npm run dev ដើម្បីចាប់ផ្តើម dev server លើ port ផ្សេងសម្រាប់ការរត់មួយលើក។

4. របៀបដែលកម្មវិធីប្រើ Environment Variable

Environment variable គឺជាវិធីដែលអ្នក កំណត់រចនាសម្ព័ន្ធ (configure) កម្មវិធីមួយ ដោយមិនចាំបាច់ផ្លាស់ប្តូរកូដរបស់វា។ កូដដដែលអាចរត់លើ laptop របស់អ្នក លើ test server និងក្នុង production ដោយអានការកំណត់ផ្សេងៗគ្នាពីបរិស្ថានរបស់វារាល់ពេល៖

// In a Node.js app
const port = process.env.PORT || 3000;
const dbUrl = process.env.DATABASE_URL;

វាក៏ជាកន្លែងដែល ព័ត៌មានសម្ងាត់ (secret) រស់នៅដែរ — ពាក្យសម្ងាត់ database, API key — ដើម្បីកុំឲ្យវាត្រូវបានសរសេរចូលក្នុងកូដ ហើយ commit ទៅ Git។

ក្នុង project ពិតៗ ជាធម្មតាអ្នកនឹងឃើញវានៅក្នុង file .env មួយក្នុង folder របស់ project៖

PORT=3000
DATABASE_URL=postgres://localhost:5432/myapp
API_KEY=replace-me

Framework ឬ library របស់អ្នកអាន file នោះ ហើយផ្ទុកបន្ទាត់នីមួយៗចូលក្នុង process.env នៅពេលកម្មវិធីចាប់ផ្តើម។ ដោយសារវាមានព័ត៌មានសម្ងាត់ .env ត្រូវបានដាក់ក្នុង .gitignore ដើម្បីកុំឲ្យ Git upload វាឡើយ។ អ្នកនឹងរៀបចំវាជាក់ស្តែងក្នុងស៊េរី NestJS និង Docker។

5. PATH៖ កន្លែងដែល Shell ស្វែងរក Command

នៅពេលអ្នកវាយ git តើ shell ដឹងដោយរបៀបណាថាត្រូវរត់ file មួយណា? វាស្វែងរកនៅក្នុង folder ដែលមានក្នុងបញ្ជីនៃ variable PATH៖

echo $PATH

/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

PATH គឺជាបញ្ជី folder ដែលបំបែកដោយ សញ្ញាចុចពីរ (colon)។ នៅពេលអ្នកវាយ command មួយ shell ពិនិត្យ folder នីមួយៗ តាមលំដាប់ ពីឆ្វេងទៅស្តាំ ហើយរត់កម្មវិធីដែលត្រូវគ្នា ដំបូងគេ ដែលវារកឃើញ។ បើវាទៅដល់ចុងបញ្ចប់ដោយរកមិនឃើញ អ្នកនឹងទទួលបាន command not found។

នោះហើយជាអ្វីដែល which (ជំពូកទី 7) បង្ហាញអ្នក — លទ្ធផលនៃការស្វែងរកនោះ។ ហើយ which -a បង្ហាញគ្រប់ការត្រូវគ្នាទាំងអស់ តាមលំដាប់ដែល PATH ពិនិត្យពួកវា។ បើអ្នកដំឡើង Node.js ពីរ version នោះ version ដែលនៅក្នុង folder ដែលមាននៅ មុនគេ ក្នុង PATH នឹងឈ្នះ។

អ្នកអាចមើលឃើញថាមានអ្វីកើតឡើងបើគ្មាន PATH ដោយធ្វើឲ្យវាខូច — ដោយសុវត្ថិភាព នៅក្នុង child shell ដែលអ្នកនឹងបោះចោល៖

bash
PATH=/nowhere
ls

bash: ls: command not found

ls នៅតែមាននៅក្នុង /bin — គ្រាន់តែ shell លែងដឹងថាត្រូវរកនៅឯណាប៉ុណ្ណោះ។ វាយ exit ដើម្បីចាកចេញពី child shell ហើយ shell ដើមរបស់អ្នក ដែល PATH មិនត្រូវបានប៉ះពាល់ នឹងត្រឡប់មកវិញ។ នេះក៏ជាមេរៀនមានប្រយោជន៍មួយដែរ៖ ការផ្លាស់ប្តូរ variable ប៉ះពាល់តែ shell ដែលអ្នកធ្វើវាប៉ុណ្ណោះ។

បន្ថែម folder មួយទៅក្នុង PATH

ដើម្បីបន្ថែម folder មួយ សូមដាក់វានៅពីមុខបញ្ជីដែលមានស្រាប់ ភ្ជាប់ដោយ colon៖

export PATH="$HOME/bin:$PATH"

អានវាដោយប្រុងប្រយ័ត្ន៖ PATH ថ្មីគឺ «$HOME/bin បន្ទាប់មក colon បន្ទាប់មកអ្វីក៏ដោយដែល PATH ធ្លាប់ជាពីមុន»។ ការដាក់វា មុនគេ មានន័យថាកម្មវិធីរបស់អ្នកឈ្នះកម្មវិធីប្រព័ន្ធដែលមានឈ្មោះដូចគ្នា។ ការភ្លេចផ្នែក :$PATH នឹង ជំនួស បញ្ជីនោះ ជាជាងបន្ថែមទៅលើវា ហើយស្ទើរតែគ្រប់ command ឈប់ដំណើរការ — បើរឿងនោះកើតឡើង គ្រាន់តែបិទ terminal ហើយបើកថ្មីមួយទៀត។

អ្នកនឹងដាក់ folder ផ្ទាល់ខ្លួនមួយលើ PATH នៅក្នុងជំពូកទី 11។

6. ហេតុអ្វី «Command Not Found» កើតឡើង

ឥឡូវ error ដែលធ្វើឲ្យអ្នកចាប់ផ្តើមដំបូងច្រឡំបំផុត មានន័យហើយ។ អ្នកដំឡើងឧបករណ៍មួយ កម្មវិធីដំឡើងប្រាប់ថាវាជោគជ័យ អ្នកវាយឈ្មោះរបស់វា ហើយ៖

zsh: command not found: node

មូលហេតុធម្មតា តាមលំដាប់នៃលទ្ធភាពកើតឡើង៖

1. Terminal ត្រូវបានបើករួចហើយ មុនពេលអ្នកដំឡើងវា។ កម្មវិធីដំឡើងបន្ថែម folder របស់ឧបករណ៍ទៅក្នុង PATH នៅក្នុង startup file របស់ shell អ្នក (ផ្នែកទី 7) ប៉ុន្តែ terminal ដែលបើកស្រាប់របស់អ្នកបានអាន file នោះនៅពេលវាចាប់ផ្តើម មុន ការផ្លាស់ប្តូរ។ បើក terminal ថ្មីមួយ ហើយសាកម្តងទៀត។ នេះដោះស្រាយបញ្ហាបានភាគច្រើន។
2. កម្មវិធីដំឡើងមិនបានបន្ថែមវាទៅក្នុង PATH សោះ។ រកមើលថាកម្មវិធីត្រូវបានដំឡើងនៅឯណា បន្ទាប់មកបន្ថែម folder នោះទៅក្នុង PATH ដោយខ្លួនឯង។
3. វាយខុស — nodejs ធៀបនឹង node, python ធៀបនឹង python3។
4. វាត្រូវបានដំឡើងនៅម្ខាងទៀត។ លើ Windows កម្មវិធីដែលដំឡើងលើ Windows មិនមានដោយស្វ័យប្រវត្តិនៅក្នុង WSL ទេ ហើយផ្ទុយមកវិញក៏ដូច្នោះដែរ។ ដំឡើងឧបករណ៍ Linux នៅខាងក្នុង WSL។

ហើយនៅពេល version ខុស ត្រូវបានរត់ សូមប្រើ which -a ដើម្បីមើលថាច្បាប់ចម្លងណាដែលនៅមុនគេក្នុង PATH។

7. ធ្វើឲ្យការផ្លាស់ប្តូរនៅជាប់រហូត៖ .zshrc និង .bashrc

អ្វីៗទាំងអស់ដែលអ្នកបានធ្វើរហូតមកដល់ពេលនេះ បាត់ទៅវិញនៅពេលអ្នកបិទ terminal។ ដើម្បីរក្សាការកំណត់មួយ សូមដាក់វានៅក្នុង startup file របស់ shell អ្នក — hidden file មួយនៅក្នុង home folder របស់អ្នក ដែល shell រត់រាល់ពេលដែល terminal ថ្មីត្រូវបានបើក៖

មិនច្បាស់ថាមួយណា? រត់ echo $SHELL។

បើកវាដោយ nano (ជំពូកទី 5)។ បើវាមិនទាន់មាននៅឡើយ nano នឹងបង្កើតវា៖

nano ~/.zshrc     # or: nano ~/.bashrc

ទៅចុងបំផុតនៃ file ហើយបន្ថែមបន្ទាត់មួយ៖

export EDITOR="nano"

រក្សាទុកដោយ Ctrl + O, Enter ហើយចាកចេញដោយ Ctrl + X។ ការផ្លាស់ប្តូរមិនទាន់សកម្មនៅក្នុង terminal នេះនៅឡើយទេ — file នោះត្រូវបានអានតែនៅពេល shell ចាប់ផ្តើមប៉ុណ្ណោះ។ បើក terminal ថ្មីមួយ ឬប្រាប់ shell បច្ចុប្បន្នឲ្យអានវាឡើងវិញដោយ source៖

source ~/.zshrc   # or: source ~/.bashrc
echo $EDITOR

នេះហើយជាអ្វីដែលកម្មវិធីដំឡើងដូចជា nvm, Homebrew និង pyenv ធ្វើ៖ ពួកវាបន្ថែមបន្ទាត់មួយចំនួនទៅក្នុង file នេះ។ បើអ្នកឆ្ងល់ថា shell របស់អ្នកកំពុងធ្វើអ្វីនៅពេលចាប់ផ្តើម សូម cat ~/.zshrc ហើយអានវា។

ប្រយ័ត្នពេលកែវា៖ កំហុសមួយនៅក្នុង file នេះនឹងរត់រាល់ពេលដែលអ្នកបើក terminal។ បើ terminal ថ្មីបង្ហាញ error ភ្លាមៗក្រោយពីការកែ សូមបើក file នោះម្តងទៀត មើលបន្ទាត់ដែលអ្នកទើបតែបន្ថែម ហើយកែវា។ ការបន្ថែមនៅ ចុង file និងការផ្លាស់ប្តូរម្តងមួយរឿង ធ្វើឲ្យងាយស្រួលរកកំហុស។

8. Alias៖ Shortcut ផ្ទាល់ខ្លួនរបស់អ្នក

Alias គឺជាឈ្មោះខ្លីសម្រាប់ command ដែលវែងជាង។ អ្នកបានជួបមួយរួចហើយនៅក្នុងជំពូកទី 7៖ type ls បានបង្ហាញថា ls ប្រហែលជា alias រួចទៅហើយ។

alias ll="ls -lah"
ll

ឥឡូវ ll រត់ ls -lah។ Alias ពេញនិយមមួយចំនួន៖

alias ll="ls -lah"
alias ..="cd .."
alias gs="git status"

ដូច variable ដែរ alias ដែលវាយក្នុង terminal នឹងបាត់ទៅវិញនៅពេលអ្នកបិទវា។ ដើម្បីរក្សាវាទុក សូមបន្ថែមបន្ទាត់ alias ទៅក្នុង ~/.zshrc ឬ ~/.bashrc របស់អ្នក ហើយ source វា។

រត់ alias តែឯង ដើម្បីបង្ហាញបញ្ជី alias ទាំងអស់របស់អ្នក ហើយ unalias ll ដើម្បីលុបមួយចេញ។ រក្សា alias សម្រាប់អ្វីដែលអ្នកវាយច្រើនដងក្នុងមួយថ្ងៃ — ហើយចាំថាវាមានតែលើម៉ាស៊ីន របស់អ្នក ប៉ុណ្ណោះ ដូច្នេះកុំប្រើវាក្នុង script ឬការណែនាំសម្រាប់អ្នកដទៃ។

9. សាកល្បងដោយខ្លួនឯង

1. បង្កើត variable name ដែលមានឈ្មោះពេញរបស់អ្នក (មានដកឃ្លា) ហើយបង្ហាញ Hello, <your name>! ដោយប្រើ echo។ សាកវាទាំងជាមួយ double quote និង single quote។
2. បង្ហាញ HOME, USER និង SHELL របស់អ្នក។ បន្ទាប់មករក HOME នៅក្នុងលទ្ធផលរបស់ env ដោយប្រើ grep។
3. ធ្វើការពិសោធន៍ bash -c ពីផ្នែកទី 3 ម្តងទៀត៖ បង្ហាញថា variable មួយមើលមិនឃើញដោយ child រហូតដល់អ្នក export វា។
4. បង្ហាញ PATH របស់អ្នក ដោយ folder នីមួយៗនៅលើបន្ទាត់ផ្ទាល់ខ្លួន៖ echo $PATH | tr ':' '\n'។ (tr បកប្រែ (translate) តួអក្សរមួយទៅជាតួអក្សរមួយទៀត — នៅទីនេះ គឺ colon ទៅជាបន្ទាត់ថ្មី។) តើ folder ណាមាន git? ពិនិត្យដោយ which git។
5. ចាប់ផ្តើម child bash កំណត់ PATH=/nowhere សាក ls បន្ទាប់មក exit។ បញ្ជាក់ថា ls ដំណើរការវិញ។
6. បន្ថែម alias ll="ls -lah" និង export EDITOR="nano" ទៅចុង startup file របស់អ្នក source វា ហើយសាកល្បងទាំងពីរ។ បើក terminal ថ្មីស្រឡាង ហើយពិនិត្យថាវានៅតែមាន។

ឥឡូវអ្នកយល់ហើយថាហេតុអ្វី command ត្រូវបានរកឃើញ — ឬមិនឃើញ — និងរបៀបធ្វើឲ្យ shell ក្លាយជារបស់អ្នកផ្ទាល់។ បន្ទាប់ សូមមើលថាអ្នកណាត្រូវបានអនុញ្ញាតឲ្យធ្វើអ្វី៖ permission និង sudo។