Theory
Editor ખોલ્યા વગર સુધારવું
grep લીટીઓ શોધે છે; પછી ઘણી વાર તમને એમને બદલવી હોય છે, એટલે કે શબ્દ બદલવો, અમુક લીટીઓ કાઢવી, ફરી ગોઠવવું, અને એ પણ આખી file પર, આપોઆપ. File ને nano માં ખોલીને હાથે સુધારવું એ હજારો લીટીઓ સુધી કે script ની અંદર ચાલવા સુધી પહોંચી શકતું નથી.
sed, એટલે કે stream નું editor, એનો જવાબ છે. એ લખાણ પોતાની પાસેથી પસાર થાય તેમ એને સુધારે છે, અને તમારી સૂચનાઓ પ્રમાણે દરેક લીટી બદલે છે, અને એમાં કોઈ interactive editor સંડોવાયેલું નથી. એની સૌથી મહત્ત્વની આવડત છે શોધો-અને-બદલો, અને અભ્યાસક્રમનો આ સમાપનનો પાઠ એ કેવી રીતે કામ કરે છે એ દેખાડે છે.
Theory
પ્રતિસ્થાપનનો command
sed ની ઓળખ છે પ્રતિસ્થાપન: s/old/new/. એ old (એક ભાત) શોધીને એને new થી બદલે છે. મૂળભૂત રીતે એ દરેક લીટી પરનો ફક્ત પહેલો મેળ બદલે છે.
g નું flag ઉમેરો, એટલે કે s/old/new/g, અને એ દરેક લીટી પરના બધા મેળ બદલે છે ('g' એટલે global). આખી file કે stream પર લગાડાયેલો આ એક command બધે એક શબ્દ બદલી શકે, આખામાં એક જ typo સુધારી શકે, કે data ને ફરી ગોઠવી શકે. ભાતવાળો ભાગ regular expression છે, એટલે regex વિશે તમે શીખેલું બધું અહીં પણ લાગુ પડે છે.
Practical
sed નું પ્રતિસ્થાપન અને કાઢી નાખવું (ચકાસાયેલું)
# Replace only the FIRST match on the line
$ echo "cat cat cat" | sed 's/cat/dog/'
dog cat cat
# Replace ALL matches with the g flag
$ echo "cat cat cat" | sed 's/cat/dog/g'
dog dog dog
# Delete line 2 with a line address
$ printf "one\ntwo\nthree\n" | sed '2d'
one
threeFormula
g નું flag, અને લીટીનાં સરનામાં
બે વિચાર sed નું મોટા ભાગનું તાળું ખોલે છે. g નું flag વ્યાપ નક્કી કરે છે: s/old/new/ લીટી દીઠ પહેલો મેળ બદલે છે, s/old/new/g દરેક મેળ બદલે છે. 'બધા' નો અર્થ હોય ત્યારે g ભૂલી જવું એ sed ની સૌથી સામાન્ય લપસણ છે.
લીટીનાં સરનામાં નક્કી કરે છે કે command ક્યાં કામ કરે: 2d લીટી 2 કાઢે છે, /ERROR/d ERROR સાથે મળતી દરેક લીટી કાઢે છે, અને 1,5s/old/new/g ફક્ત લીટી 1 થી 5 માં પ્રતિસ્થાપન કરે છે. આ પણ નોંધો: મૂળભૂત રીતે sed પોતાનું પરિણામ પડદા પર છાપે છે અને file બદલતું નથી; file ને જગ્યા પર જ સુધારવા -i ઉમેરો (સંભાળીને, કારણ કે એમાં undo નથી).
Quiz
echo "cat cat cat" | sed 's/cat/dog/' શું output આપે છે (નોંધો: g નું flag નથી)?
- dog dog dog, દરેક cat બદલીને
- dog cat cat, લીટી પરનું ફક્ત પહેલું cat બદલીને
- cat cat cat, બદલાયા વગર
- ભૂલ, કારણ કે sed ને file જોઈએ છે
Show the answer
dog cat cat, લીટી પરનું ફક્ત પહેલું cat બદલીને
g ના flag વગર, sed નું s/old/new/ દરેક લીટી પરનો ફક્ત પહેલો મેળ બદલે છે, એટલે 'cat cat cat' એ 'dog cat cat' બને છે, ફક્ત પહેલું cat જ બદલાય છે. વિકલ્પ A ફક્ત g ના flag સાથે સાચો હોત (s/cat/dog/g), જે બધા મેળ બદલીને 'dog dog dog' આપે છે; એ એક અક્ષર જ ફરક છે. વિકલ્પ C ખોટો છે: sed પ્રતિસ્થાપન કરે જ છે; લીટી બદલાયા વગર રહેતી નથી. વિકલ્પ D ખોટો છે: sed pipe (પ્રમાણભૂત input) માંથી ખુશીથી વાંચે છે, એને file ની દલીલ જોઈતી નથી. નિયમ યાદ રાખો: g નહીં એટલે ફક્ત પહેલો મેળ; લીટી પરના બધા મેળ માટે g ઉમેરો.
Think first
File ને હાથે સુધારવાને બદલે sed કેમ વાપરવું?
નાના ફેરફાર માટે nano સહેલું છે. sed ક્યારે અને શા માટે વધુ સારી પસંદગી છે? પછી tap કરો.
Show the answer
sed ત્યારે જીતે છે જ્યારે સુધારો આપોઆપ, ફરી ફરી કરી શકાય એવો, કે મોટા પાયે હોવો જોઈએ, કારણ કે એ interactive નથી અને pipelines તથા scripts માં બંધબેસે છે. nano માં હાથે સુધારવું એક file અને એક ફેરફાર માટે ઠીક છે, પણ એ મોટા પાયે પહોંચતું નથી: 500 ગોઠવણની files માં એક શબ્દ બદલવાનું કલ્પો, કે રોજ રાત્રે log માં એ જ typo સુધારવાનું, કે pipeline માંથી વહેતા data ને બદલવાનું, કોઈ માણસ દરેક file ખોલીને ફરી નહીં લખે. sed એ એક command માં કરે છે, અને એ પોતાની સૂચનાઓ command ની લીટી પર લેતું હોવાથી, તમે એને script માં મૂકીને હજાર વાર એકસરખું ચલાવી શકો, કે pipeline માં grep પછી જોડી શકો (રસપ્રદ લીટીઓ grep કરો, પછી એમને ફરી ઘડવા sed). એ એવા data પર પણ કામ કરે છે જે ક્યારેય file બનતો જ નથી, એટલે કે commands વચ્ચે વહેતું લખાણ. આપ-લે એ છે કે હાથે સુધારવાથી તમે દરેક ફેરફાર જોઈ અને ચકાસી શકો છો, જ્યારે sed પોતાનો નિયમ આંખ મીંચીને લગાડે છે, એટલે તમે એને જગ્યા પર લાગુ કરતાં પહેલાં પ્રતિસ્થાપન પહેલાં ચકાસો છો (-i વગર, પડદા પરનું output જોઈને). ટૂંકમાં: એક વારના ફેરફાર માટે editor ઠીક છે; આપોઆપ, જથ્થાબંધ, કે pipeline તથા script ની અંદરના કોઈ પણ કામ માટે sed એ સાચું, શક્તિશાળી ઓજાર છે. સુધારાને આપોઆપ કરો, અને એ કોઈ પણ કદ સુધી પહોંચે છે.
Theory
BCA501 પૂરું: તમે terminal પર જીવી શકો છો
તમે Linux ના યંત્રમાં ફરી પણ ન શકતા હતા ત્યાંથી શરૂ કર્યું અને હવે તમે કરી શકો છો: file ના તંત્રમાં ફરવું, files અને પરવાનગીઓ સંભાળવી, પ્રક્રિયાઓ નિયંત્રિત કરવી, કામ સમયપત્રકમાં ગોઠવવાં, તર્ક અને loops વાળી shell ની scripts લખવી, અને લખાણ શોધવા તથા બદલવા grep અને sed સાથે regular expressions ચલાવવાં. એ આ અભ્યાસક્રમનો આખો પ્રવાસ છે. શક્તિશાળી પછીનું પગલું છે ઓજારો જોડવાં, ઉદાહરણ તરીકે grep "ERROR" log.txt | sed 's/ERROR/PROBLEM/', એટલે કે લીટીઓ શોધીને પછી એમને ફરી ઘડવી. Campus ના server પર મહાવરો ચાલુ રાખો; સરળતા રોજિંદા વપરાશથી આવે છે.
Summary
Key takeaways
- sed એ stream નું editor છે: એ લખાણ પસાર થાય તેમ એને બદલે છે, interactive થયા વગર, અને કોઈ editor ખોલ્યા વગર.
- એની ઓળખ છે પ્રતિસ્થાપન: sed 's/old/new/' દરેક લીટી પરનો પહેલો મેળ બદલે છે.
- g નું flag ઉમેરવાથી, sed 's/old/new/g', દરેક લીટી પરના બધા મેળ બદલાય છે.
- લીટીનાં સરનામાં ક્યાં કામ કરવું એ પસંદ કરે છે: 2d લીટી 2 કાઢે છે, /pattern/d મળતી લીટીઓ કાઢે છે, 1,5s/// હદ પ્રમાણે મર્યાદિત કરે છે.
- મૂળભૂત રીતે sed પોતાનું પરિણામ છાપે છે અને file બદલતું નથી; -i જગ્યા પર જ સુધારે છે (undo નહીં, એટલે પહેલાં ચકાસો).
- sed આપોઆપ, ફરી ફરી કરી શકાય એવા, મોટા પાયાના સુધારા અને pipelines માં (ઘણી વાર grep પછી) ચમકે છે.
- Memory hook: s/old/new/ પહેલો મેળ, બધા માટે g ઉમેરો; -i પહેલાં ચકાસો.