Theory
File નું જીવન
File બને છે, જોવાય છે, એની નકલ થાય છે, એ ખસે છે કે એનું નામ બદલાય છે, અને આખરે એ ભૂંસાઈ જાય છે. Linux આમાંના દરેક તબક્કા માટે એક નાનો command આપે છે, અને એ બધા મળીને server પર તમારું કામ સંભાળવાનાં રોજિંદાં ઓજારો બને છે.
એ પાંચ છે touch, cat, cp, mv અને rm. મોટા ભાગના નમ્ર છે. એમાંનો એક, એટલે કે rm, ખરેખર જોખમી છે, કારણ કે Linux સાચે જ ભૂંસી નાખે છે અને તમને બચાવવા કોઈ કચરાપેટી હોતી નથી. આ પાઠ આખા કુટુંબનો પરિચય આપે છે અને ક્યાં સાવધ રહેવું એ બરાબર દર્શાવે છે.
At a glance
| Command | એ શું કરે છે |
|---|---|
| touch file | ખાલી file બનાવે છે (કે હયાત file નું સમયનું ટપકું તાજું કરે છે) |
| cat file | File ની અંદરનું પડદા પર દેખાડે છે (files ને જોડી પણ આપે છે) |
| cp src dst | src ની નકલ dst માં કરે છે (આખી directory ની નકલ માટે cp -r) |
| mv old new | File ને ખસેડે છે, કે એનું નામ બદલે છે (એક જ command બંને કરે છે) |
| rm file | File ને કાયમ માટે ભૂંસે છે (directory અને એની અંદરના બધા માટે rm -r) |
Practical
Files સંભાળવાની એક session
$ echo "hello" > a.txt # create a.txt containing 'hello'
$ cat a.txt
hello
$ cp a.txt b.txt # copy: now a.txt AND b.txt exist
$ mv b.txt c.txt # rename b.txt to c.txt
$ ls
a.txt c.txt
$ rm a.txt # delete a.txt (permanently!)
$ ls
c.txtWatch out
rm કાયમી છે, અને rm -r એ જાણીતી આફત છે
Linux ના shell માં કોઈ કચરાપેટી નથી. તમે કોઈ file પર rm ચલાવો એટલે એ ગઈ, કચરાપેટીમાં ખસી નહીં, સાવ ગઈ. ધ્યાનથી ટાઇપ કરો.
પ્રખ્યાત જાળ છે `rm -r`, જે directory ને અને એની અંદરના બધાને ઊંડે સુધી ભૂંસી નાખે છે. એને ખોટી directory તરફ તાકો તો ક્ષણવારમાં પુષ્કળ કામ ભૂંસાઈ શકે છે. બે ટેવ મદદ કરે છે: દરેક ભૂંસતાં પહેલાં પુછાય એ માટે `rm -i` વાપરો, અને Enter દબાવતાં પહેલાં રસ્તો હંમેશા બે વાર તપાસો. rm ને માન આપો; મૂળભૂત રીતે એ બીજી વાર પૂછતો નથી.
Quiz
તમે ચલાવો છો: cp a.txt b.txt અને પછી mv b.txt c.txt. ત્યાર બાદ કઈ files હયાત રહે છે (એમ માનીને કે શરૂઆતમાં a.txt હતી)?
- ફક્ત c.txt, કારણ કે નકલ કરવાથી અને ખસેડવાથી મૂળ files ભૂંસાઈ જાય છે
- a.txt અને c.txt (cp એ a.txt ને એની જગ્યાએ રહેવા દીધી અને b.txt બનાવી; પછી mv એ b.txt નું નામ બદલીને c.txt કર્યું)
- a.txt, b.txt અને c.txt, એટલે ત્રણેય
- ફક્ત a.txt, કારણ કે બાકીની કામચલાઉ હતી
Show the answer
a.txt અને c.txt (cp એ a.txt ને એની જગ્યાએ રહેવા દીધી અને b.txt બનાવી; પછી mv એ b.txt નું નામ બદલીને c.txt કર્યું)
એક એક પગલું અનુસરો: cp a.txt b.txt એ નકલ કરે છે, એટલે a.txt રહે છે અને નવી b.txt દેખાય છે (બે files). પછી mv b.txt c.txt એ b.txt નું નામ બદલીને c.txt કરે છે, એટલે b.txt એ c.txt બની જાય છે. તમારી પાસે a.txt અને c.txt બચે છે. વિકલ્પ A ખોટો છે: cp મૂળ file ભૂંસતું નથી (નકલ કરવાનો આખો મુદ્દો જ એ છે), અને mv એ ફક્ત b.txt નું નામ બદલ્યું, a.txt નું નહીં. વિકલ્પ C ખોટો છે: mv એ b.txt નું નામ c.txt કરી નાખ્યા પછી b.txt રહેતી નથી. વિકલ્પ D ખોટો છે: અહીં કશું a.txt કે c.txt ને ભૂંસતું નથી. મુખ્ય ભેદ આ છે: cp નકલ કરે છે (મૂળ રહે છે), જ્યારે mv ખસેડે છે કે નામ બદલે છે (જૂનું નામ રહેતું નથી).
Think first
'ખસેડવું' અને 'નામ બદલવું' એક જ command કેમ છે?
mv એ file ને બીજી directory માં ખસેડે પણ છે અને એની જગ્યાએ જ એનું નામ પણ બદલે છે. એક જ command બે કામ કેમ કરે છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે Linux માટે ખસેડવું અને નામ બદલવું એ મૂળે એક જ ક્રિયા છે: file નો રસ્તો બદલવો. File નું નામ ખરેખર તો directory ના વૃક્ષમાં એનું સ્થાન જ છે, એટલે 'આ file ને નવું નામ આપ' અને 'આ file ને નવી જગ્યાએ મૂક', એ બંનેનો અર્થ 'આ નોંધ ક્યાં તરફ ચીંધે છે તે બદલ' જ થાય છે. તમે એ જ directory માં mv old.txt new.txt ચલાવો ત્યારે તમે રસ્તાનો નામવાળો ભાગ બદલો છો, એટલે એ નામ બદલવાનું થયું. તમે mv report.txt /home/riya/archive/ ચલાવો ત્યારે તમે રસ્તાનો directory વાળો ભાગ બદલો છો, એટલે એ ખસેડવાનું થયું. ક્રિયા એક જ, એટલે કે રસ્તો બદલવો, તેથી એક જ command, mv, બંને સંભાળે છે, અને એ બંને સાથે પણ કરી શકે છે (mv old.txt archive/new.txt એકસાથે ખસેડે પણ છે અને નામ પણ બદલે છે). બે અલગ commands રાખવા કરતાં આ વધુ સુઘડ છે, અને એ પાયાની સચ્ચાઈ પણ દર્શાવે છે કે file નું નામ એ કોઈ સ્થાન પરની ચિઠ્ઠી માત્ર છે. વ્યવહારુ ચેતવણી પણ નોંધો: mv રસ્તો બદલતું હોવાથી, જે નામ મુકામ પર પહેલેથી હોય એવી file પર એ ચૂપચાપ લખી નાખી શકે છે, એટલે શંકા હોય તો પુછાય એ માટે mv -i વાપરો. એક જ command, કારણ કે ખસેડવું અને નામ બદલવું એ એક જ વિચાર છે.
Summary
Key takeaways
- touch ખાલી file બનાવે છે (કે એનું સમયનું ટપકું તાજું કરે છે); cat file ની અંદરનું દેખાડે છે.
- cp src dst એ file ની નકલ કરે છે (મૂળ રહે છે); cp -r આખી directory ની નકલ કરે છે.
- mv old new એ file ને ખસેડે છે કે એનું નામ બદલે છે, એટલે એક જ command, કારણ કે બંને ફક્ત file નો રસ્તો જ બદલે છે.
- rm file ને કાયમ માટે ભૂંસે છે; rm -r એ directory અને એની અંદરના બધાને ભૂંસે છે.
- કોઈ કચરાપેટી નથી: rm ને પાછું વાળી શકાતું નથી, અને ખોટી directory પર rm -r એ જાણીતી આફત છે.
- cp અને mv મુકામ પરની હયાત file પર ચૂપચાપ લખી નાખી શકે છે; પુછાય એ માટે -i વાપરો, અને Enter પહેલાં રસ્તા તપાસો.
- યાદ રાખવાની કડી: touch એટલે બનાવવું, cat એટલે દેખાડવું, cp એટલે નકલ, mv એટલે ખસેડવું કે નામ બદલવું, rm એટલે કાયમ ભૂંસવું.