ការអាន និងការកែប្រែ File

មាតិកា

1. បង្ហាញ File៖ cat
2. រំកិលមើល File វែង៖ less
3. ដើម និងចុង៖ head និង tail
4. តាមដាន File ពេលវាកំពុងរីកធំ៖ tail -f
5. តើនេះជា File ប្រភេទអ្វី? file
6. កែប្រែនៅក្នុង Terminal៖ nano
7. ជួយផង ខ្ញុំជាប់នៅក្នុង Vim
8. បើក File នៅក្នុង Editor ពិតរបស់អ្នក
9. សាកល្បងដោយខ្លួនឯង

ដូចមុនដែរ អ្វីៗទាំងអស់ធ្វើឡើងនៅក្នុង folder អនុវត្តរបស់អ្នក៖

cd ~/cli-practice

យើងត្រូវការ file មួយចំនួនដែលមានអ្វីមួយនៅខាងក្នុង។ echo ជាមួយ > សរសេរបន្ទាត់មួយចូលទៅក្នុង file (ជំនួសអ្វីដែលមាននៅទីនោះ) ហើយ >> បន្ថែមបន្ទាត់មួយនៅខាងចុង។ ជំពូកទី 6 ពន្យល់ទាំងពីរនេះឲ្យបានត្រឹមត្រូវ — សម្រាប់ពេលនេះ គ្រាន់តែរត់ command ទាំងនេះ៖

echo "Buy rice" > notes/shopping.txt
echo "Buy eggs" >> notes/shopping.txt
echo "Buy coffee" >> notes/shopping.txt
seq 1 500 > notes/numbers.txt

seq 1 500 បង្ហាញលេខពី 1 ដល់ 500 មួយបន្ទាត់មួយលេខ — ជាវិធីរហ័សមួយដើម្បីបានជា file វែងសម្រាប់អនុវត្ត។

1. បង្ហាញ File៖ cat

cat បង្ហាញមាតិកាទាំងមូលនៃ file មួយនៅលើអេក្រង់៖

cat notes/shopping.txt

Buy rice
Buy eggs
Buy coffee

ឈ្មោះនេះមកពីពាក្យ concatenate — ការភ្ជាប់អ្វីៗតពីគ្នា។ ផ្តល់ឲ្យ cat នូវ file ច្រើន ហើយវានឹងបង្ហាញពួកវាម្តងមួយៗតៗគ្នា ហាក់ដូចជាពួកវាជា file តែមួយ៖

cat notes/shopping.txt notes/todo.txt

បន្ថែម -n ដើម្បីដាក់លេខរៀងបន្ទាត់ ដែលមានប្រយោជន៍នៅពេល error message និយាយអ្វីមួយដូចជា «syntax error on line 12»៖

cat -n notes/shopping.txt

cat ល្អឥតខ្ចោះសម្រាប់ file ខ្លីៗ។ ឥឡូវនេះ សាកល្បងវាលើ file វែងមួយ៖

cat notes/numbers.txt

បន្ទាត់ប្រាំរយហោះកាត់យ៉ាងលឿន ហើយអ្វីដែលអ្នកអាចមើលឃើញគឺត្រឹមតែផ្នែកចុងប៉ុណ្ណោះ។ សម្រាប់ file វែង អ្នកត្រូវការអ្វីដែលល្អជាងនេះ។

2. រំកិលមើល File វែង៖ less

less បើក file មួយនៅក្នុង viewer ដែលអនុញ្ញាតឲ្យអ្នករំកិលមើលម្តងមួយអេក្រង់៖

less notes/numbers.txt

ឥឡូវនេះ file ពេញ terminal ហើយ prompt របស់ shell បាត់ទៅ រហូតដល់អ្នកចាកចេញ។ នៅខាងក្នុង less៖

បើគ្រាប់ចុចទាំងនេះមើលទៅធ្លាប់ស្គាល់ នោះគឺដោយសារតែ man (ជំពូកទី 2) ប្រើ less ដើម្បីបង្ហាញ manual page។ រៀនវាម្តង ហើយអ្នកអាចប្រើបានទាំងពីរ។

less ក៏មានសុវត្ថិភាពផងដែរ៖ វា គ្រាន់តែអាន file ប៉ុណ្ណោះ។ គ្មានអ្វីដែលអ្នកចុចនៅខាងក្នុងវាអាចផ្លាស់ប្តូរ ឬលុបអ្វីមួយបានទេ។ វាក៏បើក file ធំៗ — log រាប់ gigabyte — បានភ្លាមៗ ព្រោះវាផ្ទុកតែផ្នែកដែលអ្នកកំពុងមើលប៉ុណ្ណោះ។

3. ដើម និងចុង៖ head និង tail

ជាញឹកញាប់ អ្នកខ្វល់តែពីផ្នែកដើម ឬផ្នែកចុងនៃ file ប៉ុណ្ណោះ។ head បង្ហាញ 10 បន្ទាត់ដំបូង ហើយ tail បង្ហាញ 10 បន្ទាត់ចុងក្រោយ៖

head notes/numbers.txt
tail notes/numbers.txt

ប្រើ -n ដើម្បីជ្រើសរើសចំនួនបន្ទាត់៖

head -n 3 notes/numbers.txt    # 1, 2, 3
tail -n 5 notes/numbers.txt    # 496 to 500

តើវាសំខាន់នៅកន្លែងណាក្នុងជីវិតពិត?

• ប្រើ head លើ CSV file ធំមួយ ដើម្បីមើលឈ្មោះ column របស់វាដោយមិនចាំបាច់បើកវាទាំងមូល។
• ប្រើ tail លើ log file មួយ ដើម្បីមើល error ថ្មីៗបំផុត — log ត្រូវបានសរសេរពីលើចុះក្រោម ដូច្នេះបន្ទាត់ថ្មីបំផុតតែងតែនៅខាងចុង។

4. តាមដាន File ពេលវាកំពុងរីកធំ៖ tail -f

tail -f (follow) បង្ហាញផ្នែកចុងនៃ file មួយ ហើយបន្ទាប់មក បន្តឃ្លាំមើលវា ដោយបង្ហាញបន្ទាត់ថ្មីភ្លាមៗនៅពេលដែលពួកវាត្រូវបានបន្ថែម។ នេះជារបៀបដែលអ្នកអភិវឌ្ឍន៍មើល log ខណៈពេលដែល app កំពុងដំណើរការ។

ដើម្បីមើលវាដំណើរការ អ្នកត្រូវការ terminal ពីរ នៅក្បែរគ្នា។ បើកបង្អួច ឬ tab terminal ទីពីរ (Cmd + T លើ macOS, ប៊ូតុង + នៅក្នុង Windows Terminal, Ctrl + Shift + T នៅក្នុង terminal Linux ភាគច្រើន)។

នៅក្នុង terminal ទីមួយ៖

cd ~/cli-practice
touch notes/app.log
tail -f notes/app.log

File នោះទទេ ដូច្នេះគ្មានអ្វីលេចឡើងទេ — ហើយ prompt ក៏មិនត្រឡប់មកវិញដែរ។ tail កំពុងអង្គុយនៅទីនោះ រង់ចាំ។

នៅក្នុង terminal ទីពីរ បន្ថែមបន្ទាត់មួយចំនួន៖

cd ~/cli-practice
echo "Server started on port 3000" >> notes/app.log
echo "GET /home 200" >> notes/app.log
echo "ERROR: database connection failed" >> notes/app.log

បន្ទាត់នីមួយៗលេចឡើងនៅក្នុង terminal ទីមួយភ្លាមៗនៅពេលអ្នកចុច Enter។ នៅពេលអ្នករួចរាល់ សូមត្រឡប់ទៅ terminal ទីមួយវិញ ហើយចុច Ctrl + C ដើម្បីឈប់តាមដាន។

នេះគឺជាគំនិតដូចគ្នានៅពីក្រោយ docker logs -f និង npm run dev៖ process មួយបន្តសរសេរបន្ទាត់ ហើយ terminal បន្តបង្ហាញពួកវា រហូតដល់អ្នកបញ្ឈប់វាដោយ Ctrl + C។

5. តើនេះជា File ប្រភេទអ្វី? file

តើមានអ្វីកើតឡើង បើអ្នក cat អ្វីមួយដែលមិនមែនជាអក្សរ ដូចជារូបថត ឬកម្មវិធី? សាកល្បងវាជាមួយរូបភាពពិតណាមួយដែលអ្នកមាន (ឬចម្លងមួយចូលទៅក្នុង ~/cli-practice/photos)៖

cat photos/some-real-photo.jpg

អ្នកនឹងទទួលបានអេក្រង់ពេញដោយតួអក្សររញ៉េរញ៉ៃ ប្រហែលជាមានសំឡេងប៊ីបខ្លះ ហើយម្តងម្កាល terminal ចាប់ផ្តើមបង្ហាញអក្សរចម្លែកៗបន្ទាប់ពីនោះ។ ដូចដែលអ្នកបានរៀននៅក្នុង Bit, Byte ហើយអ្វីៗទាំងអស់គឺជាលេខ byte នៅខាងក្នុង JPEG គឺជា pixel មិនមែនជាអក្សរទេ ដូច្នេះការបង្ហាញវាជាអក្សរគ្មានន័យអ្វីទាំងអស់។ បើ terminal របស់អ្នកច្រឡំ សូមវាយ reset ហើយចុច Enter (ទោះបីអ្នកមើលមិនឃើញអ្វីដែលអ្នកកំពុងវាយក៏ដោយ) ដើម្បីជួសជុលវា។

ដើម្បីដឹងថាមានអ្វីនៅខាងក្នុង file មុនពេលបើកវា សូមប្រើ file៖

file notes/shopping.txt
file photos/some-real-photo.jpg

notes/shopping.txt:          ASCII text
photos/some-real-photo.jpg:  JPEG image data, JFIF standard 1.01, ...

file មើល byte នៅខាងក្នុង មិនមែន extension ទេ។ ប្តូរឈ្មោះរូបថតមួយទៅជា .txt ហើយ file នៅតែប្រាប់អ្នកថាវាជា JPEG — ពិតជាចំណុចដែលបានលើកឡើងនៅក្នុង File និង File System។

6. កែប្រែនៅក្នុង Terminal៖ nano

ភាគច្រើន អ្នកនឹងកែប្រែកូដនៅក្នុង editor បែបក្រាហ្វិក។ ប៉ុន្តែពេលខ្លះ អ្នកនៅលើ server ដែលគ្មាន desktop ឬអ្នកគ្រាន់តែត្រូវការផ្លាស់ប្តូរមួយបន្ទាត់នៅក្នុង config file ហើយ terminal text editor គឺជាវិធីរហ័សបំផុត។

nano គឺជាមួយដែលងាយស្រួលប្រើបំផុត។ វាមានស្រាប់នៅក្នុង Ubuntu (និង WSL), Git Bash និង macOS (ដែល nano តាមពិតគឺជា editor ស្ទើរតែដូចគ្នាបេះបិទមួយឈ្មោះ pico)។

nano notes/todo.txt

File នោះបើកនៅខាងក្នុង terminal។ អ្នកអាចវាយ លុប និងផ្លាស់ទីដោយប្រើគ្រាប់ចុចព្រួញ ដូចជា text editor សាមញ្ញមួយ។ នៅខាងក្រោមអេក្រង់ មានបញ្ជី shortcut៖

^G Help    ^O Write Out    ^W Where Is    ^K Cut    ^X Exit

សញ្ញា ^ មានន័យថា Ctrl។ ដូច្នេះ៖

សាកល្បងវា៖ បន្ថែមបន្ទាត់មួយដូចជា Practise nano ចុច Ctrl + O, Enter បន្ទាប់មក Ctrl + X។ ពិនិត្យថាវាដំណើរការ៖

cat notes/todo.txt

បើអ្នក nano file ដែលមិនទាន់មាន nano នឹងបង្កើតវានៅពេលអ្នករក្សាទុក។ ដូច្នេះ nano notes/new-file.txt គឺជាវិធីមួយទៀតដើម្បីបង្កើត file។

7. ជួយផង ខ្ញុំជាប់នៅក្នុង Vim

មិនយូរមិនឆាប់ កម្មវិធីណាមួយនឹងទម្លាក់អ្នកចូលទៅក្នុង vim ដោយគ្មានការព្រមាន។ មូលហេតុទូទៅបំផុត៖ ការរត់ git commit ដោយគ្មាន message ដែលបើក editor លំនាំដើមរបស់អ្នកដើម្បីសរសេរមួយ — ហើយនៅលើប្រព័ន្ធជាច្រើន editor លំនាំដើមនោះគឺ vim។

Vim គឺជា editor ដ៏មានឥទ្ធិពលមួយដែលអ្នកអភិវឌ្ឍន៍ជាច្រើនចូលចិត្ត ប៉ុន្តែវាដំណើរការខុសគ្នាខ្លាំងណាស់៖ នៅពេលវាបើក ការវាយមិនបញ្ចូលអត្ថបទទេ ហើយ shortcut ធម្មតាៗមិនដំណើរការ។ អ្នកចាប់ផ្តើមដំបូងល្បីថាមិនអាចរកវិធីចាកចេញបាន។ នេះជាផែនការរត់គេច៖

1. ចុច Esc (ប្រហែលជាពីរដង) ដើម្បីប្រាកដថាអ្នកនៅក្នុង command mode របស់ vim។
2. វាយ :q! ហើយចុច Enter — នេះមានន័យថា «ចាកចេញ ហើយបោះចោលការផ្លាស់ប្តូរទាំងអស់»។

បើអ្នកពិតជាចង់រក្សាអ្វីដែលអ្នកបានវាយ៖

1. ចុច Esc។
2. វាយ :wq ហើយចុច Enter — «សរសេរ (រក្សាទុក) បន្ទាប់មកចាកចេញ»។

អ្នកនឹងឃើញ :q! ឬ :wq លេចឡើងនៅខាងក្រោមអេក្រង់ ពេលអ្នកវាយ។ នោះជារបៀបដែលអ្នកដឹងថា vim កំពុងស្តាប់។

បើអ្នកចង់ឲ្យ Git បើក nano ជំនួសវិញ មេរៀនស៊េរី Git នឹងបង្ហាញអ្នកពីរបៀបផ្លាស់ប្តូរ editor លំនាំដើមរបស់វា។

8. បើក File នៅក្នុង Editor ពិតរបស់អ្នក

សម្រាប់ការសរសេរកូដពិតប្រាកដ អ្នកនឹងចង់បាន editor ពេញលេញដូចជា VS Code។ អ្នកអាចបើកវាពី terminal នៅត្រង់កន្លែងដែលអ្នកកំពុងនៅ៖

code notes/todo.txt   # open one file
code .                # open the whole current folder as a project

code . គឺជា command មួយក្នុងចំណោម command ដែលត្រូវបានប្រើច្រើនបំផុតក្នុងការអភិវឌ្ឍន៍ web៖ cd ចូលទៅក្នុង project មួយ បន្ទាប់មក code . ដើម្បីចាប់ផ្តើមធ្វើការលើវា។

បើអ្នកទទួលបាន command not found: code៖

• macOS៖ បើក VS Code ចុច Cmd + Shift + P ហើយរត់ Shell Command: Install 'code' command in PATH។
• WSL៖ ដំឡើង extension WSL នៅក្នុង VS Code លើ Windows។ បន្ទាប់ពីនោះ code . នៅខាងក្នុង WSL នឹងបើក folder នៅក្នុង VS Code ដែលភ្ជាប់ទៅ Linux។
• Linux និង Git Bash៖ កម្មវិធីដំឡើង VS Code ជាធម្មតារៀបចំការនេះឲ្យរួចស្រេច។ សូមបើក terminal របស់អ្នកឡើងវិញបន្ទាប់ពីដំឡើង។

ជំពូកទី 9 ពន្យល់ថា ហេតុអ្វី បានជា «បើក terminal របស់អ្នកឡើងវិញ» ជារឿយៗជួសជុល command not found បាន។

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

1. ប្រើ cat ដើម្បីបង្ហាញ notes/shopping.txt បន្ទាប់មកបង្ហាញវាម្តងទៀតជាមួយលេខរៀងបន្ទាត់។
2. បើក notes/numbers.txt នៅក្នុង less។ លោតទៅចុងដោយ G ស្វែងរក 250 ដោយ /250 ហើយចាកចេញដោយ q។
3. បង្ហាញតែបន្ទាត់ទី 1 ដល់ 3 នៃ notes/numbers.txt បន្ទាប់មកបង្ហាញតែបន្ទាត់ចុងក្រោយ។
4. រៀបចំការពិសោធន៍ tail -f ជាមួយ terminal ពីរ ហើយបន្ថែមបន្ទាត់បីផ្ទាល់ខ្លួនរបស់អ្នកទៅក្នុង notes/app.log។ បញ្ឈប់វាដោយ Ctrl + C។
5. រត់ file លើ text file មួយ និងលើរូបថតពិតមួយ។ បន្ទាប់មកចម្លងរូបថតនោះ ប្តូរឈ្មោះច្បាប់ចម្លងឲ្យបញ្ចប់ដោយ .txt ហើយរត់ file លើវាម្តងទៀត។
6. ប្រើ nano ដើម្បីបង្កើត notes/journal.txt សរសេរពីរបន្ទាត់ រក្សាទុក ហើយចាកចេញ។ ពិនិត្យវាដោយប្រើ cat។
7. បើក vim ដោយចេតនាជាមួយ vim notes/journal.txt វាយគ្រាប់ចុចចៃដន្យខ្លះ បន្ទាប់មករត់គេចដោយ Esc និង :q!។ រត់ cat ដើម្បីបញ្ជាក់ថាគ្មានអ្វីផ្លាស់ប្តូរទេ។

ឥឡូវនេះ អ្នកអាចអាន file គ្រប់ទំហំ និងធ្វើការកែប្រែរហ័សៗដោយមិនចាំបាច់ចាកចេញពី terminal។ បន្ទាប់មកទៀតគឺគំនិតដ៏មានឥទ្ធិពលបំផុតមួយនៅលើ command line៖ ការភ្ជាប់ command ជាមួយគ្នាដោយប្រើ pipe និង redirection។