ដាក់អ្វីៗទាំងអស់បញ្ចូលគ្នា

មាតិកា

1. អ្វីដែលយើងនឹងបង្កើត
2. តើ Shell Script ជាអ្វី
3. ការសរសេរ Script
4. ការអានវាម្តងមួយបន្ទាត់
5. ការរត់ និងសាកល្បងវា
6. ហេតុអ្វី Script មិនអាច cd ជំនួសអ្នកបាន
7. ការដំឡើងវាជា Command ផ្ទាល់ខ្លួនរបស់អ្នក
8. ស៊េរីទាំងមូលក្នុងមួយទំព័រ
9. ទៅណាបន្ទាប់

1. អ្វីដែលយើងនឹងបង្កើត

រាល់ពេលដែលអ្នកចាប់ផ្តើម project ថ្មីមួយ អ្នកធ្វើរឿងមួយចំនួនដដែលៗ៖ បង្កើត folder មួយ បន្ថែម src, tests និង docs នៅខាងក្នុងវា សរសេរ README មួយ បន្ថែម .gitignore បង្កើត .env ទទេមួយ ហើយចាក់សោវា។ នោះប្រហែលជាដប់ command — ហើយជាប្រភេទការងារដដែលៗដែល command line ត្រូវបានបង្កើតឡើងដើម្បីធ្វើដោយស្វ័យប្រវត្តិ។

នៅក្នុងជំពូកនេះ អ្នកនឹងសរសេរ script មួយឈ្មោះ new-project ដែលធ្វើរឿងទាំងអស់នោះក្នុងពេលតែមួយ៖

new-project my-app

Creating project: my-app
Done! Files created:
my-app
my-app/.env
my-app/.gitignore
my-app/README.md
my-app/docs
my-app/src
my-app/src/index.js
my-app/tests

ស្ទើរតែគ្រប់បន្ទាត់របស់វាប្រើអ្វីមួយពីជំពូកមុនៗ ហើយនៅចុងបញ្ចប់ វានឹងក្លាយជា command ពិតប្រាកដដែលអ្នកអាចរត់ពីគ្រប់ទីកន្លែង — ដូចគ្នានឹង ls ឬ git ដែរ។

2. តើ Shell Script ជាអ្វី

Shell script គឺជា text file ដែលមាន command — command ដដែលៗដែលអ្នកបានវាយ — ដែល shell រត់ពីលើចុះក្រោម។ អ្នកបានបង្កើតមួយតូចៗ hello.sh រួចហើយនៅក្នុងជំពូកទី 10។

អ្វីក៏ដោយដែលអ្នកអាចវាយនៅ prompt អ្នកអាចដាក់វាក្នុង script បាន។ Script គ្រាន់តែបន្ថែមរឿងពីរ ដែលមិនសូវមានប្រយោជន៍ពេលអ្នកវាយដោយដៃ៖

• Argument៖ script អាចទទួលតម្លៃនៅពេលអ្នករត់វា ដូចជា my-app ខាងលើ។ នៅខាងក្នុង script argument ទីមួយអាចប្រើបានជា $1 ទីពីរជា $2 ហើយបន្តបន្ទាប់។
• ការសម្រេចចិត្ត៖ script អាចពិនិត្យអ្វីមួយ — «តើមានឈ្មោះត្រូវបានផ្តល់ឲ្យទេ? តើ folder នោះមានរួចហើយឬនៅ?» — ហើយឆ្លើយតបទៅនឹងវា។

ការសរសេរកម្មវិធី shell ពេញលេញ (loop, function និងផ្សេងៗទៀត) គឺជាប្រធានបទធំមួយដាច់ដោយឡែក ហើយស៊េរីនេះឈប់ដោយចេតនាមុនពេលទៅដល់វា។ if តូចមួយគឺគ្រប់គ្រាន់សម្រាប់យើងហើយ។

3. ការសរសេរ Script

ចូលទៅ folder អនុវត្តរបស់អ្នក ហើយបើក file ថ្មីមួយក្នុង nano៖

cd ~/cli-practice
nano new-project.sh

វាយ ឬបិទភ្ជាប់ខាងក្រោម បន្ទាប់មករក្សាទុកដោយ Ctrl + O, Enter ហើយចាកចេញដោយ Ctrl + X៖

#!/bin/bash
# new-project.sh — create a starter folder for a new project.
# Usage: new-project.sh <project-name>

set -e

name="$1"

if [ -z "$name" ]; then
  echo "Usage: new-project.sh <project-name>" >&2
  exit 1
fi

if [ -e "$name" ]; then
  echo "Error: '$name' already exists." >&2
  exit 1
fi

echo "Creating project: $name"

mkdir -p "$name"/{src,tests,docs}

echo "# $name" > "$name/README.md"
echo "Created on $(date +%Y-%m-%d) by $USER." >> "$name/README.md"

printf '%s\n' "node_modules/" ".env" ".DS_Store" > "$name/.gitignore"

touch "$name/src/index.js" "$name/.env"
chmod 600 "$name/.env"

echo "Done! Files created:"
find "$name" | sort

4. ការអានវាម្តងមួយបន្ទាត់

មុនពេលរត់ script មួយ — ទោះបីជា script របស់អ្នកផ្ទាល់ក៏ដោយ — សូមអានវាសិន។ នេះជាអ្វីដែលផ្នែកនីមួយៗធ្វើ និងកន្លែងដែលអ្នកបានរៀនវា។

#!/bin/bash

Shebang៖ #! អមដោយ path របស់កម្មវិធីដែលគួររត់ file នេះ។ នៅពេលអ្នករត់ ./new-project.sh ប្រព័ន្ធប្រតិបត្តិការអានបន្ទាត់ទីមួយនេះ ហើយប្រគល់ file ទៅឲ្យ /bin/bash។ នោះហើយជាមូលហេតុដែល script ដំណើរការដូចគ្នា ទោះបីជា terminal របស់អ្នកប្រើ zsh ក៏ដោយ។ អ្នកក៏នឹងឃើញ #!/usr/bin/env bash ដែរ ដែលស្វែងរក bash នៅលើ PATH របស់អ្នក (ជំពូកទី 9) ជំនួសឲ្យការប្រើទីតាំងថេរមួយ។

# new-project.sh — create a starter folder for a new project.

Comment (ជំពូកទី 2)។ អ្វីៗទាំងអស់បន្ទាប់ពី # ត្រូវបានមិនអើពើ។ Script ល្អមួយប្រាប់នៅខាងលើថាវាធ្វើអ្វី និងរបៀបប្រើវា។

set -e

«បញ្ឈប់ script ភ្លាមៗនៅពេល command ណាមួយបរាជ័យ»។ បើគ្មានវាទេ ប្រសិនបើ mkdir បរាជ័យ script នឹងបន្តទៅមុខ ហើយរត់ command ផ្សេងទៀតទាំងអស់ដដែល។ set -e ប្រើ exit code (ជំពូកទី 8)៖ command ណាដែលចេញដោយតម្លៃផ្សេងពី 0 នឹងបញ្ឈប់ script។

name="$1"

Variable មួយ (ជំពូកទី 9) ដែលផ្ទុក argument ទីមួយ។ នៅពេលអ្នករត់ new-project.sh my-app នោះ $1 គឺ my-app។ ការដាក់ឈ្មោះដែលអានយល់ឲ្យវា ធ្វើឲ្យផ្នែកដែលនៅសល់នៃ script ងាយតាមដានជាងមុន។

if [ -z "$name" ]; then
  echo "Usage: new-project.sh <project-name>" >&2
  exit 1
fi

ការសម្រេចចិត្តតែមួយគត់នៅក្នុង script នេះ។ [ -z "$name" ] ពិនិត្យថាតើ name ទទេ ឬអត់ (-z មានន័យថា «ប្រវែងសូន្យ»)។ បើវាទទេ — អ្នកភ្លេចដាក់ argument — script បង្ហាញរបៀបប្រើវា ហើយឈប់។ if ... then ... fi សម្គាល់ការចាប់ផ្តើម និងការបញ្ចប់នៃប្លុក (fi គឺ if សរសេរបញ្ច្រាស)។

មានព័ត៌មានលម្អិតពីរដែលមកពីជំពូកមុនៗ។ >&2 បញ្ជូនសារទៅ stderr (ជំពូកទី 6) ព្រោះវាជា error មិនមែនជាលទ្ធផលធម្មតាទេ។ ហើយ exit 1 បញ្ចប់ script ដោយ exit code មិនមែនសូន្យ ដូច្នេះអ្វីក៏ដោយដែលរត់ script នេះអាចដឹងថាវាបានបរាជ័យ។

if [ -e "$name" ]; then

គំនិតដដែល៖ -e ពិនិត្យថាតើមានអ្វីមួយដែលមានឈ្មោះនោះ មានរួចហើយ ឬអត់។ បើគ្មានការពិនិត្យនេះទេ ការរត់ script ពីរដងនឹងបន្ថែម file ដោយស្ងាត់ៗចូលទៅក្នុង project ដែលអ្នកបានចាប់ផ្តើមរួចហើយ។

mkdir -p "$name"/{src,tests,docs}

mkdir -p និង brace expansion (ជំពូកទី 4)។ សញ្ញាសម្រង់ជុំវិញ "$name" មានសារៈសំខាន់៖ បើនរណាម្នាក់រត់ new-project.sh "my app" ដកឃ្លានឹងត្រូវបានរក្សាទុកជាផ្នែកនៃឈ្មោះតែមួយ ជាជាងបំបែកវាជាពីរ។ ការដាក់សញ្ញាសម្រង់ជុំវិញ variable គឺជាទម្លាប់សំខាន់បំផុតក្នុងការសរសេរ shell script។

echo "# $name" > "$name/README.md"
echo "Created on $(date +%Y-%m-%d) by $USER." >> "$name/README.md"

Redirection (ជំពូកទី 6)៖ > បង្កើត README ជាមួយចំណងជើងមួយ ហើយ >> បន្ថែមបន្ទាត់ទីពីរ។ $USER គឺជា environment variable (ជំពូកទី 9)។ ហើយ $(...) គឺជារឿងថ្មី៖ វាគឺជា command substitution — shell រត់ command នៅខាងក្នុងវង់ក្រចក ហើយដាក់លទ្ធផលរបស់វាចូលក្នុងបន្ទាត់។ នៅទីនេះ date +%Y-%m-%d បង្ហាញកាលបរិច្ឆេទថ្ងៃនេះ ដូចជា 2026-10-01។

printf '%s\n' "node_modules/" ".env" ".DS_Store" > "$name/.gitignore"

ល្បិច printf ពីជំពូកទី 6 ដែលសរសេរបីបន្ទាត់ចូលក្នុង .gitignore ដើម្បីកុំឲ្យ Git តាមដាន dependency ព័ត៌មានសម្ងាត់ ឬ file រញ៉េរញ៉ៃរបស់ macOS។

touch "$name/src/index.js" "$name/.env"
chmod 600 "$name/.env"

File ទទេ (ជំពូកទី 4) និង permission (ជំពូកទី 10)៖ .env នឹងផ្ទុកព័ត៌មានសម្ងាត់ ដូច្នេះមានតែអ្នកប៉ុណ្ណោះដែលអាចអានវាបាន។

find "$name" | sort

find (ជំពូកទី 7) បង្ហាញបញ្ជីអ្វីៗទាំងអស់ដែលបានបង្កើត ហើយ pipe ចូលទៅក្នុង sort (ជំពូកទី 6) ដើម្បីឲ្យលំដាប់អាចទាយទុកបាន។

5. ការរត់ និងសាកល្បងវា

File នេះមិនទាន់អាច execute បាននៅឡើយទេ (ជំពូកទី 10) ដូច្នេះបន្ថែម x ជាមុនសិន៖

chmod +x new-project.sh

ឥឡូវសាកល្បងវាឲ្យបានត្រឹមត្រូវ — មិនមែនត្រឹមតែផ្លូវដែលដំណើរការល្អប៉ុណ្ណោះទេ ប៉ុន្តែក៏ករណីខុសផងដែរ។

គ្មាន argument៖

./new-project.sh
echo $?

Usage: new-project.sh <project-name>
1

Project ពិតប្រាកដមួយ៖

./new-project.sh my-app

អ្នកគួរតែឃើញបញ្ជី file ពីផ្នែកទី 1។ ពិនិត្យលទ្ធផលដោយប្រើឧបករណ៍ដែលអ្នកស្គាល់៖

cat my-app/README.md
ls -la my-app

# my-app
Created on 2026-10-01 by dara.

នៅក្នុងលទ្ធផល ls -la សូមកត់សម្គាល់ .env និង .gitignore ដែលត្រូវបានលាក់ (ជំពូកទី 3) ហើយថា .env បង្ហាញ -rw-------។

ឈ្មោះដដែលម្តងទៀត៖

./new-project.sh my-app
echo $?

Error: 'my-app' already exists.
1

ឥឡូវ script របស់អ្នកដោះស្រាយករណីទាំងបីដែលសំខាន់។ ការសាកល្បងករណីបរាជ័យ មិនមែនត្រឹមតែករណីជោគជ័យនោះទេ គឺជាទម្លាប់មួយដែលគួរយកទៅប្រើក្នុងគ្រប់កូដដែលអ្នកសរសេរ។

6. ហេតុអ្វី Script មិនអាច cd ជំនួសអ្នកបាន

វានឹងល្អណាស់ បើ script បញ្ចប់ដោយនាំអ្នកចូលទៅក្នុង folder ថ្មី។ សាកបន្ថែម cd "$name" ជាបន្ទាត់ចុងក្រោយរបស់វា ហើយរត់វាជាមួយឈ្មោះថ្មីមួយ — បន្ទាប់មករត់ pwd។ អ្នកនៅតែនៅក្នុង ~/cli-practice។

នេះមិនមែនជា bug ទេ។ ចាំជំពូកទី 8៖ ការរត់ script មួយចាប់ផ្តើម child process មួយ — ច្បាប់ចម្លង Bash ដាច់ដោយឡែកមួយ។ cd កើតឡើងនៅខាងក្នុង child នោះ ដែលផ្លាស់ប្តូរ current directory របស់វា បន្ទាប់មកចេញ។ Shell ផ្ទាល់ខ្លួនរបស់អ្នក ដែលជា parent មិនដែលត្រូវបានប៉ះពាល់ទេ។ Child process មិនអាចផ្លាស់ប្តូរ current directory, variable ឬអ្វីផ្សេងទៀតរបស់ parent វាបានទេ (ជំពូកទី 9)។

នោះក៏ជាមូលហេតុដែល cd ខ្លួនវាត្រូវតែត្រូវបានបង្កប់នៅក្នុង shell (ជំពូកទី 7)។ ដំណោះស្រាយសាមញ្ញគឺភ្ជាប់វាដោយខ្លួនឯងជាមួយ && (ជំពូកទី 8)៖

./new-project.sh my-api && cd my-api

cd រត់តែនៅពេល script បានជោគជ័យប៉ុណ្ណោះ។ (លុបបន្ទាត់ cd ចេញពី script បើអ្នកបានបន្ថែមវា។)

7. ការដំឡើងវាជា Command ផ្ទាល់ខ្លួនរបស់អ្នក

ឥឡូវនេះ អ្នកត្រូវវាយ ./new-project.sh ហើយបានតែពីខាងក្នុង ~/cli-practice ប៉ុណ្ណោះ។ តោះធ្វើឲ្យវាក្លាយជា command ពិតប្រាកដដែលដំណើរការពីគ្រប់ទីកន្លែង។ នេះពិតជារបៀបដែលឧបករណ៍ command line ត្រូវបានដំឡើង — ពួកវាជា file ដែលអាច execute បាន នៅក្នុង folder មួយលើ PATH របស់អ្នក។

បង្កើត folder bin មួយនៅក្នុង home folder របស់អ្នក (bin គឺខ្លីមកពី binaries ដែលជាឈ្មោះប្រពៃណីសម្រាប់ folder កម្មវិធី) ហើយផ្លាស់ទី script ចូលទៅក្នុងវា ដោយដក .sh ចេញ ដើម្បីឲ្យ command មើលទៅដូច command ផ្សេងទៀត៖

mkdir -p ~/bin
mv new-project.sh ~/bin/new-project

បន្ទាប់មកបន្ថែម folder នោះទៅក្នុង PATH របស់អ្នកជាអចិន្ត្រៃយ៍ នៅក្នុង startup file របស់អ្នក (ជំពូកទី 9)៖

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

បន្ថែមបន្ទាត់នេះនៅចុងបញ្ចប់ បន្ទាប់មករក្សាទុក ហើយចាកចេញ៖

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

ផ្ទុកការផ្លាស់ប្តូរ ហើយពិនិត្យថា shell អាចរកឃើញ command របស់អ្នក៖

source ~/.zshrc   # or: source ~/.bashrc
which new-project

/Users/dara/bin/new-project

ឥឡូវវាដំណើរការពីគ្រប់ទីកន្លែង៖

cd ~/cli-practice/projects
new-project portfolio && cd portfolio

អ្នកបានសរសេរកម្មវិធីមួយ ផ្តល់ permission ឲ្យវារត់ ដាក់វាលើ PATH របស់អ្នក ហើយរត់វាដូច command ផ្សេងទៀត។ គ្រប់ command ដែលអ្នកបានប្រើក្នុងស៊េរីនេះ — ls, git, node — បានមកដល់កុំព្យូទ័ររបស់អ្នកតាមរបៀបដូចគ្នានេះដែរ។

អ្នកក៏អាចកែសារ usage នៅខាងក្នុង script ឲ្យនិយាយថា new-project ជំនួសឲ្យ new-project.sh ដែរ ព្រោះឥឡូវនោះជាឈ្មោះរបស់វាហើយ។

8. ស៊េរីទាំងមូលក្នុងមួយទំព័រ

9. ទៅណាបន្ទាប់

Terminal លែងជាអាថ៌កំបាំងទៀតហើយ — វាជាឧបករណ៍មួយដែលអ្នកអាចប្រើបាន។ នេះជារបៀបដែលវាភ្ជាប់ទៅនឹងអ្វីដែលមកបន្ទាប់នៅលើ ផែនទីការសិក្សា «ចាប់ផ្តើមនៅទីនេះ»៖

• Git និង GitHub សម្រាប់អ្នកចាប់ផ្តើម — ជំហានបន្ទាប់ ហើយអ្នកនឹងប្រើវាទាំងស្រុងពី terminal៖ git init, git add, git commit និងបង្អួច vim នោះដែលឥឡូវអ្នកដឹងពីរបៀបគេចចេញហើយ។
• របៀបដែលគេហទំព័រដំណើរការ និង បណ្តាញសម្រាប់អ្នកអភិវឌ្ឍន៍ — អ្វីដែលពិតជានៅពីក្រោយ port 3000 នោះ និងឧបករណ៍ដូចជា curl ដែលនិយាយជាមួយ server ពី command line។
• Docker CLI Tutorial — គ្រប់ command របស់ Docker ត្រូវបានសាងសង់លើស៊េរីនេះ៖ docker ps និង docker logs -f គឺជា ps និង tail -f សម្រាប់ container ហើយអ្នកនឹងចំណាយពេលនៅក្នុង shell នៅខាងក្នុងពួកវា។
• ពង្រឹងសុវត្ថិភាព Linux Server — permission, user និង sudo ជាក់ស្តែង លើ server ដែលគ្មានអេក្រង់សោះ។

រក្សា ~/cli-practice ទុក ហើយត្រឡប់មកវាវិញរាល់ពេលដែលអ្នកចង់សាកល្បងអ្វីមួយដោយសុវត្ថិភាព។ ហើយលើកក្រោយដែល tutorial មួយនិយាយថា «គ្រាន់តែរត់នេះនៅក្នុង terminal របស់អ្នក» អ្នកនឹងដឹងច្បាស់ថាអ្នកកំពុងវាយអ្វី — និងថាវានឹងធ្វើអ្វី។