ការស្វែងរករបស់

មាតិកា

1. ការស្វែងរកពីរប្រភេទ
2. Project តូចមួយសម្រាប់ស្វែងរក
3. រក File តាមឈ្មោះ៖ find
4. រក File តាមប្រភេទ ទំហំ និងអាយុ
5. ស្វែងរកនៅខាងក្នុង File៖ grep -r
6. ការបង្រួមការស្វែងរក
7. តើ Command នេះនៅឯណា? which និង type
8. សាកល្បងដោយខ្លួនឯង

1. ការស្វែងរកពីរប្រភេទ

នៅពេលអ្នកកំពុងរកអ្វីមួយនៅលើកុំព្យូទ័រ ជាធម្មតាអ្នកកំពុងសួរសំណួរមួយក្នុងចំណោមសំណួរពីរ៖

• «តើ file ដែលមានឈ្មោះ… នៅឯណា?» — អ្នកដឹង ឈ្មោះ (ឬមួយផ្នែកនៃឈ្មោះ) ប៉ុន្តែមិនដឹងថាវានៅឯណាទេ។ នោះជាការងាររបស់ find។
• «តើ file ណាដែលមាន…?» — អ្នកដឹង អត្ថបទខ្លះនៅខាងក្នុង file ប៉ុន្តែមិនដឹងថាវានៅក្នុង file ណាទេ។ នោះជាការងាររបស់ grep -r។

ក្នុងនាមជាអ្នកអភិវឌ្ឍន៍ អ្នកនឹងសួរសំណួរទីពីរជារៀងរាល់ពេល៖ តើ function នេះត្រូវបានកំណត់នៅឯណា? តើ file ណាខ្លះដែលនៅតែប្រើ API URL ចាស់? តើសារ error នោះមកពីណា? Editor របស់អ្នកមានប្រអប់ស្វែងរកសម្រាប់ការនេះ ប៉ុន្តែនៅលើ server ក្នុង container ឬក្នុង script មួយ terminal គឺជាអ្វីតែមួយគត់ដែលអ្នកមាន។

2. Project តូចមួយសម្រាប់ស្វែងរក

នៅក្នុងជំពូកទី 4 អ្នកបានបង្កើត projects/website ដែលមាន folder src, tests និង docs។ តោះដាក់កូដខ្លះចូលទៅក្នុងវា។ រត់ប្លុកនីមួយៗពីខាងក្នុង ~/cli-practice៖

cd ~/cli-practice
mkdir -p projects/website/{src,tests,docs}

printf '%s\n' \
  "// Home page" \
  "function showHome() {" \
  "  // TODO: add a welcome message" \
  "  return 'Welcome';" \
  "}" > projects/website/src/home.js

printf '%s\n' \
  "// Login page" \
  "function login(user) {" \
  "  // todo: check the password" \
  "  return true;" \
  "}" > projects/website/src/login.js

printf '%s\n' \
  "test('home works', () => {});" \
  "// TODO: test the login page" > projects/website/tests/home.test.js

printf '%s\n' \
  "# Website" \
  "Run npm install, then npm run dev." > projects/website/docs/README.md

អ្នកមិនចាំបាច់យល់ JavaScript នេះទេ — វាគ្រាន់តែជាអត្ថបទសម្រាប់ស្វែងរកប៉ុណ្ណោះ។ Comment TODO គឺជាកំណត់ចំណាំដែលអ្នកអភិវឌ្ឍន៍ទុកសម្រាប់ការងារដែលនៅតែត្រូវធ្វើ ហើយការរកពួកវាទាំងអស់គឺជាការងារពិតប្រាកដមួយ។

3. រក File តាមឈ្មោះ៖ find

find ដើរកាត់ folder មួយ និងគ្រប់ folder ទាំងអស់នៅខាងក្នុងវា ហើយបង្ហាញគ្រប់ path ដែលត្រូវនឹងលក្ខខណ្ឌរបស់អ្នក។ ទម្រង់មូលដ្ឋានគឺ៖

find  where-to-look  conditions

រកគ្រប់ file JavaScript ទាំងអស់នៅក្រោម folder បច្ចុប្បន្ន៖

find . -name "*.js"

./projects/website/tests/home.test.js
./projects/website/src/home.js
./projects/website/src/login.js

សញ្ញា . មានន័យថា «ចាប់ផ្តើមពីទីនេះ» (ដូចដែលអ្នកបានរៀនក្នុងជំពូកទី 3)។ អ្នកក៏អាចចាប់ផ្តើមពីកន្លែងផ្សេងបានដែរ ដូចជា find ~/Documents -name "*.pdf" ឬ find projects -name "*.md"។

សូមកត់សម្គាល់ថាលទ្ធផលមិនស្ថិតក្នុងលំដាប់អក្ខរក្រមទេ — find បង្ហាញពួកវាតាមលំដាប់ដែលវាជួបពួកវានៅលើ disk។ សូម pipe output ទៅក្នុង sort បើលំដាប់មានសារៈសំខាន់។

ត្រូវដាក់ pattern ក្នុងសញ្ញាសម្រង់ជានិច្ច។ បើគ្មានសញ្ញាសម្រង់ទេ shell នឹងពង្រីក *.js (ជំពូកទី 4) មុនពេល find បានឃើញវាទៅទៀត។ បើ folder បច្ចុប្បន្នចៃដន្យមាន app.js នោះ command នឹងក្លាយជា find . -name app.js ហើយរកឃើញតែ file ដែលមានឈ្មោះនោះពិតប្រាកដ ដោយមិនប្រាប់អ្នកអ្វីសោះ។ បើមានសញ្ញាសម្រង់ * នឹងទៅដល់ find ដែលនឹងផ្គូផ្គងវាជាមួយគ្រប់ folder ដែលវាចូលទៅ។

-name ប្រកាន់អក្សរធំតូច (case-sensitive)៖ -name "*.JS" នឹងមិនត្រូវនឹង home.js ទេ។ សូមប្រើ -iname ដើម្បីមិនខ្វល់ពីអក្សរធំតូច៖

find . -iname "readme*"

4. រក File តាមប្រភេទ ទំហំ និងអាយុ

find អាចផ្គូផ្គងបានច្រើនជាងឈ្មោះទៅទៀត។ លក្ខខណ្ឌមួយចំនួនដែលមានប្រយោជន៍បំផុត៖

លក្ខខណ្ឌអាច ផ្សំគ្នា បាន ហើយ file មួយត្រូវតែត្រូវនឹងលក្ខខណ្ឌទាំងអស់៖

find . -type d                        # every folder
find projects -type f -name "*.js"    # files ending in .js (not folders)
find . -type f -mmin -60              # files you changed in the last hour

Command ចុងក្រោយនោះមានប្រយោជន៍គួរឲ្យភ្ញាក់ផ្អើល៖ «ខ្ញុំទើបតែរក្សាទុក file មួយនៅកន្លែងណាមួយ ប៉ុន្តែនៅឯណា?»

ករណីបុរាណមួយក្នុងពិភពពិត គឺការតាមរកអ្វីដែលកំពុងស៊ីទំហំ disk របស់អ្នក៖

find ~ -type f -size +500M 2> /dev/null

ការស្វែងរកទូទាំង home folder របស់អ្នកនឹងជួប folder មួយចំនួនដែលអ្នកមិនត្រូវបានអនុញ្ញាតឲ្យអាន ហើយ folder នីមួយៗនោះបង្ហាញ error Permission denied។ 2> /dev/null ពីជំពូកមុនបោះ error ទាំងនោះចោល ដូច្នេះនៅសល់តែលទ្ធផលប៉ុណ្ណោះ។

ការរក និងការលុប

find មាន option -delete ដែលលុបគ្រប់ file ដែលត្រូវគ្នា។ វាមានអានុភាព និងគ្រោះថ្នាក់ — គ្មានការបញ្ជាក់ ហើយគ្មានធុងសំរាមទេ។ បើអ្នកធ្លាប់ប្រើវា សូមអនុវត្តច្បាប់ដូចគ្នានឹង rm៖ រត់ command ដដែលនោះដោយគ្មាន -delete ជាមុនសិន អានបញ្ជីនោះ ហើយមានតែពេលនោះទេទើបបន្ថែម -delete នៅខាងចុង។

find . -name "*.tmp"           # 1. look
find . -name "*.tmp" -delete   # 2. only then delete

5. ស្វែងរកនៅខាងក្នុង File៖ grep -r

នៅក្នុងជំពូកទី 6 អ្នកបានប្រើ grep លើ file តែមួយ។ បន្ថែម -r (recursive) ហើយផ្តល់ folder មួយឲ្យវាជំនួសវិញ នោះវានឹងស្វែងរក គ្រប់ file ទាំងអស់នៅខាងក្នុង៖

grep -r "TODO" projects

projects/website/tests/home.test.js:// TODO: test the login page
projects/website/src/home.js:  // TODO: add a welcome message

លទ្ធផលនីមួយៗបង្ហាញ file ដែលវាមកពី សញ្ញា colon និង បន្ទាត់ដែលត្រូវគ្នា។ បន្ថែម -n ដើម្បីមើល លេខបន្ទាត់ ផងដែរ ដើម្បីឲ្យអ្នកអាចលោតទៅដល់វាភ្លាមៗនៅក្នុង editor របស់អ្នក៖

grep -rn "TODO" projects

projects/website/tests/home.test.js:2:// TODO: test the login page
projects/website/src/home.js:3:  // TODO: add a welcome message

សូមកត់សម្គាល់ថា login.js បាត់ — comment របស់វាសរសេរថា todo ជាអក្សរតូច។ បន្ថែម -i ដើម្បីមិនខ្វល់ពីអក្សរធំតូច៖

grep -rni "todo" projects

ឥឡូវនេះ ទាំងបីលេចឡើងហើយ។ -rni គួរតែទន្ទេញចាំ៖ recursive, លេខបន្ទាត់, មិនខ្វល់អក្សរធំតូច — វាជាការផ្សំដែលអ្នកនឹងប្រើច្រើនជាងគេ។

បើអ្នកគ្រាន់តែចង់ដឹងថា file ណាខ្លះ ដែលត្រូវគ្នា មិនមែនគ្រប់បន្ទាត់ទេ សូមប្រើ -l៖

grep -rli "todo" projects

projects/website/tests/home.test.js
projects/website/src/home.js
projects/website/src/login.js

ហើយ -w ផ្គូផ្គងតែ ពាក្យ ពេញប៉ុណ្ណោះ ដូច្នេះការស្វែងរក log ជាមួយ -w នឹងមិនត្រូវនឹង login ទេ៖

grep -rnw "login" projects

6. ការបង្រួមការស្វែងរក

នៅក្នុង project ពិត grep -r ធម្មតាឆាប់លិចអ្នកក្នុងលទ្ធផលរំខាន។ Folder node_modules របស់ project Node.js មួយអាចមាន file រាប់ម៉ឺនយ៉ាងងាយ ហើយ Git រក្សាទុកប្រវត្តិផ្ទាល់ខ្លួនរបស់វានៅក្នុង .git។ អ្នកស្ទើរតែមិនដែលចង់ស្វែងរកនៅក្នុងទាំងនោះទេ។

Option ពីរជួយឲ្យការស្វែងរកផ្តោតចំគោលដៅ៖

grep -rn "TODO" --include="*.test.js" projects     # only test files
grep -rn "TODO" --exclude-dir=node_modules .       # skip node_modules

អ្នកអាចប្រើ --exclude-dir ម្តងហើយម្តងទៀតសម្រាប់ folder ច្រើន៖

grep -rn "apiUrl" --exclude-dir=node_modules --exclude-dir=.git .

ហើយពិតណាស់ លទ្ធផលរបស់ grep អាចចូលទៅក្នុង pipe ដូចអ្វីផ្សេងទៀតដែរ៖

grep -rni "todo" projects | wc -l     # how many TODOs are left?

ជម្រើសដែលលឿនជាង៖ អ្នកអភិវឌ្ឍន៍ជាច្រើនដំឡើង ripgrep (ឈ្មោះ command គឺ rg) ដែលជាឧបករណ៍ទំនើបជំនួស grep -r។ វាលឿនជាងច្រើននៅលើ project ធំៗ ហើយរំលង node_modules, .git និងអ្វីៗដែលនៅក្នុង .gitignore ដោយស្វ័យប្រវត្តិ។ អ្វីៗដែលអ្នករៀនអំពី grep អាចយកទៅប្រើបានភ្លាមៗ។ ប្រអប់ស្វែងរករបស់ VS Code ខ្លួនឯងក៏ពិតជាប្រើ ripgrep នៅពីក្រោយដែរ។

7. តើ Command នេះនៅឯណា? which និង type

Command ក៏ជា file ដែរ។ នៅពេលអ្នកវាយ ls ឬ git shell រត់ file កម្មវិធីមួយដែលរក្សាទុកនៅកន្លែងណាមួយនៅលើ disk។ ដើម្បីដឹងថានៅឯណា សូមប្រើ which៖

which git

/usr/bin/git

នេះក្លាយជារឿងសំខាន់ភ្លាមៗនៅពេលមានអ្វីមួយចម្លែកកើតឡើង៖ អ្នកបានដំឡើង Node.js កំណែថ្មី ប៉ុន្តែ node --version នៅតែបង្ហាញកំណែចាស់។ which node ប្រាប់អ្នកថា shell ពិតជាកំពុងរត់ node ច្បាប់ណា — ហើយជាញឹកញាប់ណាស់ វាមិនមែនជាច្បាប់ដែលអ្នករំពឹងទុកទេ។

បន្ថែម -a ដើម្បីមើល គ្រប់ ច្បាប់ដែល shell អាចរកឃើញ តាមលំដាប់ដែលវាពិនិត្យ៖

which -a python3

Command មួយចំនួនមិនមែនជា file កម្មវិធីទាល់តែសោះ។ ឧទាហរណ៍ cd ត្រូវបាន បង្កប់នៅក្នុង shell ខ្លួនឯង — វាត្រូវតែជាដូច្នេះ ព្រោះកម្មវិធីដាច់ដោយឡែកមួយមិនអាចផ្លាស់ប្តូរ current directory ផ្ទាល់ខ្លួនរបស់ shell បានទេ។ type ប្រាប់អ្នកយ៉ាងច្បាស់ថាឈ្មោះមួយជាអ្វី៖

type cd
type ls
type git

cd is a shell builtin
ls is an alias for ls -G
git is /usr/bin/git

បន្ទាត់កណ្តាលនោះប្រហែលជាធ្វើឲ្យអ្នកភ្ញាក់ផ្អើល។ នៅលើប្រព័ន្ធជាច្រើន ls គឺជា alias — ផ្លូវកាត់មួយដែល shell ពង្រីកទៅជា command វែងជាងនេះ ដែលនៅទីនេះគឺ ls ជាមួយ option មួយដែលបន្ថែមពណ៌ (នៅលើ Ubuntu អ្នកនឹងឃើញ ls --color=auto ជំនួសវិញ)។ បើរបស់អ្នកគ្រាន់តែបង្ហាញថា ls is /bin/ls នោះមានន័យថាគ្មាន alias ត្រូវបានកំណត់ទេ។ អ្នកនឹងបង្កើត alias ផ្ទាល់ខ្លួនក្នុងជំពូកទី 9។

បើ which មិនបង្ហាញអ្វីសោះ ឬ type បង្ហាញថា not found នោះ shell មិនអាចរក command នោះឃើញទាល់តែសោះ — ដែលពិតជាអត្ថន័យរបស់ command not found។ របៀប ដែល shell សម្រេចថាត្រូវរកនៅកន្លែងណា គឺជាប្រធានបទនៃជំពូកទី 9 ស្តីពី PATH។

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

ធ្វើទាំងអស់នេះនៅខាងក្នុង ~/cli-practice។

1. ប្រើ find ដើម្បីបង្ហាញបញ្ជីគ្រប់ file .txt ទាំងអស់នៅក្នុង cli-practice បន្ទាប់មក pipe លទ្ធផលទៅក្នុង sort និង wc -l ដើម្បីរាប់ពួកវា។
2. រកគ្រប់ folder (មិនមែន file) នៅខាងក្នុង projects។
3. រក file ទាំងអស់ដែលអ្នកបានកែប្រែក្នុង 30 នាទីចុងក្រោយ។
4. រត់ find ~ -type f -size +100M 2> /dev/null។ តើអ្នកស្គាល់ file ធំៗដែលវារកឃើញទេ?
5. ប្រើ grep -rni ដើម្បីរកគ្រប់ TODO ទាំងអស់នៅក្នុង projects។ បន្ទាប់មកប្រើ -l ដើម្បីបង្ហាញតែឈ្មោះ file ហើយរាប់ពួកវាដោយប្រើ wc -l។
6. ស្វែងរកពាក្យ function នៅក្នុង projects ប៉ុន្តែតែក្នុង file ដែលនៅក្រោម src ប៉ុណ្ណោះ។ (តម្រុយ៖ អ្នកអាចផ្តល់ folder ចាប់ផ្តើមដែលជាក់លាក់ជាងនេះឲ្យ grep។)
7. រត់ which និង type លើ ls, cd, git និង printf។ តើមួយណាខ្លះជាកម្មវិធីនៅលើ disk ហើយមួយណាខ្លះត្រូវបានបង្កប់នៅក្នុង shell?

ឥឡូវនេះ អ្នកអាចរក file ណាមួយតាមឈ្មោះ និងបន្ទាត់អត្ថបទណាមួយទូទាំង project ទាំងមូលបានហើយ។ បន្ទាប់ តោះមើលកម្មវិធីដែលអ្នករត់ក្នុងនាមជា process៖ របៀបមើលពួកវា បញ្ឈប់ពួកវា និងរត់ពួកវានៅផ្ទៃខាងក្រោយ។