බහු රේඛා නූලක් ප්‍රතිස්ථාපනය කිරීමට මට sed භාවිතා කරන්නේ කෙසේද?

මම \nභාවිතා කර ආදේශ කිරීම සඳහා රටාවකට එකතු කළහොත් sedඑය නොගැලපෙන බව මම දැක ඇත්තෙමි . උදාහරණයක්:

$ cat > alpha.txt
This is
a test
Please do not
be alarmed

$ sed -i'.original' 's/a test\nPlease do not/not a test\nBe/' alpha.txt

$ diff alpha.txt{,.original}

$ # No differences printed out

මෙය ක්‍රියාත්මක කිරීමට මට හැක්කේ කෙසේද?

සරලම sed කැඳවීමේදී , එය රටා අවකාශයේ එක් පෙළක් ඇත, එනම්. \nආදානයෙන් වෙන් කරන ලද පෙළ 1 පේළිය . රටා අවකාශයේ තනි පේළියට නැත \n... ඔබේ රීජෙක්ස් කිසිවක් සොයා නොගන්නේ එබැවිනි.

ඔබට රටා-අවකාශයට පේළි කිහිපයක් කියවා පුදුම සහගත ලෙස හැසිරවිය හැකිය, නමුත් සාමාන්‍ය උත්සාහයට වඩා .. සෙඩ් සතුව මේ ආකාරයේ දේවලට ඉඩ දෙන විධාන සමූහයක් ඇත ... මෙන්න sed සඳහා විධාන සාරාංශයකට සබැඳියක් . එය මම සොයාගත් හොඳම එකයි.

කෙසේ වෙතත් ඔබ sed හි ක්ෂුද්‍ර විධාන භාවිතා කිරීමට පටන් ගත් පසු "එක්-ලයිනර්" අදහස අමතක කරන්න. ව්‍යුහාත්මක වැඩසටහනක් ලෙස ඔබට හැඟීම ලැබෙන තෙක් එය තැබීම ප්‍රයෝජනවත් වේ ... එය පුදුම සහගත සරල හා සමානවම අසාමාන්‍යය. ඔබට එය පෙළ සංස්කරණයේ “එකලස් කිරීමේ භාෂාව” ලෙස සිතිය හැකිය.

සාරාංශය: සරල දේවල් සඳහා sed භාවිතා කරන්න, සමහර විට තව ටිකක් වැඩි විය හැක, නමුත් පොදුවේ ගත් කල, එය තනි පේළියක් සමඟ වැඩ කිරීමෙන් ඔබ්බට ගිය විට, බොහෝ අය වෙනත් දෙයකට වැඩි කැමැත්තක් දක්වයි ...
මම වෙනත් කෙනෙකුට වෙනත් දෙයක් යෝජනා කිරීමට ඉඩ දෙමි .. මම හොඳම තේරීම කුමක් දැයි සැබවින්ම විශ්වාස නැත (මම sed භාවිතා කරමි, නමුත් එයට හේතුව මම පර්ල් ගැන හොඳින් නොදන්නා බැවිනි.)

sed '/^a test$/{
       $!{ N        # append the next line when not on the last line
         s/^a test\nPlease do not$/not a test\nBe/
                    # now test for a successful substitution, otherwise
                    #+  unpaired "a test" lines would be mis-handled
         t sub-yes  # branch_on_substitute (goto label :sub-yes)
         :sub-not   # a label (not essential; here to self document)
                    # if no substituion, print only the first line
         P          # pattern_first_line_print
         D          # pattern_ltrunc(line+nl)_top/cycle
         :sub-yes   # a label (the goto target of the 't' branch)
                    # fall through to final auto-pattern_print (2 lines)
       }    
     }' alpha.txt  

මෙන්න එය එකම පිටපතක් වන අතර එය කියවීමට හා වැඩ කිරීමට අපහසු දෙයකට ensed නීභවනය වී ඇත, නමුත් සමහරු සැක සහිත ලෙස එක් ලයිනර් එකක් අමතනු ඇත

sed '/^a test$/{$!{N;s/^a test\nPlease do not$/not a test\nBe/;ty;P;D;:y}}' alpha.txt

මෙන්න මගේ විධානය "වංචා පත්‍රය"

:  # label
=  # line_number
a  # append_text_to_stdout_after_flush
b  # branch_unconditional             
c  # range_change                     
d  # pattern_delete_top/cycle          
D  # pattern_ltrunc(line+nl)_top/cycle 
g  # pattern=hold                      
G  # pattern+=nl+hold                  
h  # hold=pattern                      
H  # hold+=nl+pattern                  
i  # insert_text_to_stdout_now         
l  # pattern_list                       
n  # pattern_flush=nextline_continue   
N  # pattern+=nl+nextline              
p  # pattern_print                     
P  # pattern_first_line_print          
q  # flush_quit                        
r  # append_file_to_stdout_after_flush 
s  # substitute                                          
t  # branch_on_substitute              
w  # append_pattern_to_file_now         
x  # swap_pattern_and_hold             
y  # transform_chars                   

perlඒ වෙනුවට භාවිතා කරන්න sed:

$ perl -0777 -i.original -pe 's/a test\nPlease do not/not a test\nBe/igs' alpha.txt
$ diff alpha.txt{,.original}
2,3c2,3
< not a test
< Be
---
> a test
> Please do not

-pi -eඔබේ සම්මත "ප්‍රතිස්ථාපන ස්ථානය" විධාන රේඛා අනුක්‍රමය වන අතර -0777 මඟින් පර්ල් ලිපිගොනු මුලුමනින්ම ගිලිහී යයි. ඒ ගැන වැඩි විස්තර දැනගැනීම සඳහා perldoc perlrun බලන්න .

මම හිතන්නේ, \nසංකේතය වෙනත් සංකේතයකින් ආදේශ කිරීම වඩා හොඳය , පසුව සුපුරුදු පරිදි වැඩ කරන්න:

උදා: වැඩ නොකළ ප්‍රභව කේතය:

cat alpha.txt | sed -e 's/a test\nPlease do not/not a test\nBe/'

පහත පරිදි වෙනස් කළ හැකිය:

cat alpha.txt | tr '\n' '\r' | sed -e 's/a test\rPlease do not/not a test\rBe/'  | tr '\r' '\n'

කිසිවෙකු නොදන්නේ නම්, \nයුනික්ස් රේඛාව අවසන් වන්නේ, \r\n- කවුළු, \r- සම්භාව්‍ය මැක් ඕඑස්. සාමාන්‍ය යුනික්ස් පෙළ \rසංකේතය භාවිතා නොකරයි , එබැවින් මෙම නඩුව සඳහා එය භාවිතා කිරීම ආරක්ෂිතයි.

තාවකාලිකව ආදේශ කිරීම සඳහා ඔබට යම් විදේශීය සංකේතයක් ද භාවිතා කළ හැකිය. උදාහරණයක් ලෙස - feed f (පෝරම සංකේතය). ඔබට මෙහි තවත් සංකේත සොයාගත හැකිය .

cat alpha.txt | tr '\n' '\f' | sed -e 's/a test\fPlease do not/not a test\fBe/'  | tr '\f' '\n'

සලකා බැලූ සෑම දෙයක්ම, සම්පූර්ණ ගොනුවම ගොබ්බ කිරීම වේගවත්ම ක්‍රමය විය හැකිය.

මූලික වාක්‍ය ඛණ්ඩය පහත පරිදි වේ:

sed -e '1h;2,$H;$!d;g' -e 's/__YOUR_REGEX_GOES_HERE__...'

මතක තබා ගන්න, ගොනුව විශාල නම් විශාල ගොබ්බය විකල්පයක් නොවනු ඇත. එවැනි අවස්ථාවන් සඳහා, මෙහි ලබා දී ඇති වෙනත් පිළිතුරු කුඩා මතක අඩිපාරක වැඩ කිරීමට සහතික වන අභිරුචි කළ විසඳුම් ඉදිරිපත් කරයි.

අනෙක් සියලුම අනවසර හා කප්පාදු තත්වයන් සඳහා, හුදෙක් -e '1h;2,$H;$!d;g'ඔබේ මුල් sedරීජෙක්ස් තර්කය අනුගමනය කිරීමෙන් පසුව එම කාර්යය ඉටු වේ.

උදා

$ echo -e "Dog\nFox\nCat\nSnake\n" | sed -e '1h;2,$H;$!d;g' -re 's/([^\n]*)\n([^\n]*)\n/Quick \2\nLazy \1\n/g'
Quick Fox
Lazy Dog
Quick Snake
Lazy Cat

මොකද කරන්නේ -e '1h;2,$H;$!d;g'?

මෙම 1, 2,$, $!කොටස් සීමාව සෘජුවම, පහත සඳහන් විධානය මත දිවෙන රේඛා එම රේඛාව නිශ්චයකක් වේ.

• 1: පළමු පේළිය පමණි
• 2,$: දෙවන පේළියේ සිට ආරම්භ වන සියලුම රේඛා
• $!: අන්තිම හැර අනෙක් සෑම පේළියක්ම

එතරම් පුළුල් වූ විට, N රේඛා ආදානයක එක් එක් පේළියේ සිදු වන්නේ මෙයයි.

  1: h, d
  2: H, d
  3: H, d
  .
  .
N-2: H, d
N-1: H, d
  N: H, g

මෙම gවිධානය රේඛාවක් විශේෂණයක් දී නැත, නමුත් පෙර dඅණ විශේෂ වගන්තියක් "ඇත අරඹන්න ඊළඟ චක්රය. ", සහ මේ තට්ටය පෑදීම gපසුගිය හැර අන් සියලු පිලිවෙත් මත නවතයි.

එක් එක් විධානයෙහි අර්ථය සම්බන්ධයෙන්:

• පළමු hවිසින් අනුගමනය Hඑක් එක් පේලිය පිටපත් එල්ල ආදානය රේඛාවන් පවසයි sedගේ අල්ලා අවකාශය . (අත්තනෝමතික පෙළ බෆරය සිතන්න.)
• පසුව, dමෙම රේඛා ප්‍රතිදානයට ලිවීම වැළැක්වීම සඳහා එක් එක් පේළිය ඉවතලන්න. මෙම ග්රහණය අවකාශය කෙසේ වෙතත්, කල් තබා ගන්නා ඇත.
• අවසාන වශයෙන්, ඉතා පසුගිය මාර්ගයේ, gසිට සෑම රේඛාවක් සමුච්චය සුමුදු අල්ලා අවකාශය එසේ sedමුළු ආදාන (ඒ වෙනුවට රේඛාවක්-at-a-කාලය විලාසිතා වඩා) මත එහි regex ක්රියාත්මක කිරීමට හැකි වන අතර, ඒ නිසා කරන්න පුළුවන් \ns මත තරගය .

sedබහු-රේඛාව මෙහෙයුම් කළමනාකරණය කිරීමට විධාන තුනක් ඇත: N, Dසහ P(සන්සන්දනය සාමාන්ය n , dසහ p).

මෙම අවස්ථාවේදී, ඔබට ඔබේ රටාවේ පළමු පේළියට ගැලපෙන අතර N, දෙවන පේළිය රටා අවකාශයට එකතු කිරීමට භාවිතා කරන්න, ඉන්පසු sඔබේ ආදේශනය කිරීමට භාවිතා කරන්න.

වැනි දෙයක්:

/a test$/{
  N
  s/a test\nPlease do not/not a test\nBe/
}

ඔබට හැකි නමුත් එය දුෂ්කර ය . වෙනත් මෙවලමකට මාරුවීමට මම නිර්දේශ කරමි. ඔබට ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය පෙළෙහි කිසිඳු කොටසකට කිසි විටෙකත් නොගැලපෙන නිත්‍ය ප්‍රකාශනයක් තිබේ නම්, ඔබට එය GNU awk හි අමුතු වාර්තා බෙදුම්කරුවෙකු ලෙස භාවිතා කළ හැකිය.

awk -v RS='a' '{gsub(/hello/, "world"); print}'

ඔබගේ සෙවුම් තීරුවේ කිසි විටෙක අඛණ්ඩව නව රේඛා දෙකක් නොමැති නම්, ඔබට awk හි “ඡේද ප්‍රකාරය” භාවිතා කළ හැකිය (හිස් රේඛා එකක් හෝ කිහිපයක් වෙන් වෙන් වාර්තා).

awk -v RS='' '{gsub(/hello/, "world"); print}'

පහසු විසඳුමක් නම් පර්ල් භාවිතා කර ගොනුව සම්පූර්ණයෙන්ම මතකයට පටවන්න.

perl -0777 -pe 's/hello/world/g'

පේළි 2 ක් ගැලපීම සඳහා මෙය sed විසඳුම යැයි මම සිතමි.

sed -n '$!N;s@a test\nPlease do not@not a test\nBe@;P;D' alpha.txt

ඔබට පේළි 3 ක් ගැලපීමට අවශ්‍ය නම් ...

sed -n '1{$!N};$!N;s@aaa\nbbb\nccc@xxx\nyyy\nzzz@;P;D'

ඔබට පේළි 4 ක් ගැලපීමට අවශ්‍ය නම් ...

sed -n '1{$!N;$!N};$!N;s@ ... @ ... @;P;D'

"S" විධානයෙහි ප්‍රතිස්ථාපන කොටස රේඛා හැකිලෙන්නේ නම් මේ වගේ ටිකක් සංකීර්ණ වේ

# aaa\nbbb\nccc shrink to one line "xxx"

sed -n '1{$!N};$!N;/aaa\nbbb\nccc/{s@@xxx@;$!N;$!N};P;D'

ප්‍රතිස්ථාපන කොටස රේඛා වැඩෙන්නේ නම් මේ වගේ ටිකක් සංකීර්ණයි

# aaa\nbbb\nccc grow to five lines vvv\nwww\nxxx\nyyy\nzzz

sed -n '1{$!N};$!N;/aaa\nbbb\nccc/{s@@vvv\nwww\nxxx\nyyy\nzzz@;P;s/.*\n//M;P;s/.*\n//M};P;D'

මෙම දෙවන ක්‍රමය සාමාන්‍ය කුඩා ප්‍රමාණයේ පෙළ ලිපිගොනු සඳහා සරල පිටපතක් හා වාචික ආදේශකයක් වේ (ෂෙල් ස්ක්‍රිප්ට් ගොනුවක් අවශ්‍යය)

#!/bin/bash

# copy & paste content that you want to substitute

AA=$( cat <<\EOF | sed -z -e 's#\([][^$*\.#]\)#\\\1#g' -e 's#\n#\\n#g'
a test
Please do not
EOF
)

BB=$( cat <<\EOF | sed -z -e 's#\([&\#]\)#\\\1#g' -e 's#\n#\\n#g'
not a test
Be
EOF
)

sed -z -i 's#'"${AA}"'#'"${BB}"'#g' *.txt   # apply to all *.txt files

OP අයදුම් කිරීමට උත්සාහ කළ වාක්‍ය ඛණ්ඩය භාවිතා කිරීමට GNU sedහට -zවිකල්පයක් ඇත. ( මිනිසා පිටුව )

උදාහරණයක්:

$ cat alpha.txt
This is
a test
Please do not
be alarmed

$ sed -z 's/a test\nPlease do not\nbe/not a test\nBe/' -i alpha.txt

$ cat alpha.txt
This is
not a test
Be alarmed

සැලකිලිමත් වන්න: ඔබ භාවිතා කරන්නේ නම් ^සහ $ඒවා දැන් NUL අක්ෂරයකින් වෙන් කර ඇති රේඛාවල ආරම්භයට හා අවසානයට ගැලපේ (නැත \n). තවද, ඔබගේ සියලු ( \nවෙන් කළ) රේඛාවල ගැලපීම් ආදේශ කර ඇති බව සහතික කිරීම gසඳහා, ගෝලීය ආදේශක සඳහා ධජය භාවිතා කිරීමට අමතක නොකරන්න (උදා s/.../.../g).

බැර: @ stéphane-chazelas මුලින් සඳහන් කළේ -z ඉහත අදහස් දැක්වීමකදී.

sed -i'.original' '/a test/,/Please do not/c not a test \nBe' alpha.txt

මෙහි /a test/,/Please do not/(බහු රේඛා) පෙළක් ලෙස සලකනු cලැබේ, වෙනස් කිරීමේ විධානය පසුව නව පෙළnot a test \nBe

ප්‍රතිස්ථාපනය කළ යුතු පා of ය ඉතා දිගු නම්, මම යෝජනා කරන්නේ හිටපු සින්ටැක්ස් ය.

sed -e'$!N;s/^\(a test\n\)Please do not be$/not \1Be/;P;D' <in >out

ආදානය මත ඔබේ කවුළුව ටිකක් පුළුල් කරන්න.

එය ඉතා පහසු ය. සම්මත ආදේශනයට අමතරව; ඔබට අවශ්‍ය වන්නේ $!N, Pසහ Dමෙහි පමණි.

පර්ල් හැරුණු විට, ධාරාවන් සඳහා බහුකාර්ය සංස්කරණය සඳහා පොදු සහ පහසු ප්‍රවේශයක් වන්නේ (සහ ලිපිගොනු ද):

උදාහරණයක් ලෙස, ඔබ කැමති පරිදි නව UNIQUE රේඛා බෙදුම්කරයක් සාදන්න

$ S=__ABC__                     # simple
$ S=__$RANDOM$RANDOM$RANDOM__   # better
$ S=$(openssl rand -hex 16)     # ultimate

එවිට ඔබේ sed විධානයෙහි (හෝ වෙනත් මෙවලමක්) ඔබ like n වෙනුවට {{S by මගින් ආදේශ කරයි

$ cat file.txt | awk 1 ORS=$S |  sed -e "s/a test${S}Please do not/not a test\nBe/" | awk 1 RS=$S > file_new.txt

(awk ASCII රේඛා බෙදුම්කරු ඔබේ සහ අනෙක් අතට ආදේශ කරයි.)

මෙය OS X හි වැඩ කිරීමට Xara ගේ දක්ෂ පිළිතුරෙහි කුඩා වෙනස් කිරීමකි (මම 10.10 භාවිතා කරමි):

cat alpha.txt | tr '\n' '\r' | sed -e 's/a test$(printf '\r')Please do not/not a test$(printf '\r')Be/'  | tr '\r' '\n'

පැහැදිලිව භාවිතා කරනවා වෙනුවට \r, ඔබ භාවිතා කළ $(printf '\r')යුතුය.

මට අවශ්‍ය වූයේ sed භාවිතා කරමින් ගොනුවකට HTML පේළි කිහිපයක් එක් කිරීමටයි (සහ මෙහි අවසන් විය). සාමාන්‍යයෙන් මම පර්ල් භාවිතා කරමි, නමුත් මම පෙට්ටියේ සිටියේ සෙඩ්, බැෂ් සහ වෙනත් බොහෝ දේ නොවේ. මම නූල එක පේළියකට වෙනස් කර බැෂ් / සෙඩ් අතරමැදි කිරීමට ඉඩ දුන්නොත් \ t \ n සියල්ල සාර්ථක විය:

HTML_FILE='a.html' #contains an anchor in the form <a name="nchor" />
BASH_STRING_A='apples'
BASH_STRING_B='bananas'
INSERT="\t<li>$BASH_STRING_A<\/li>\n\t<li>$BASH_STRING_B<\/li>\n<a name=\"nchor\"\/>"
sed -i "s/<a name=\"nchor"\/>/$INSERT/" $HTML_FILE

ද්විත්ව උපුටා දැක්වීම් සහ ඉදිරි කප්පාදුවලින් ගැලවීම සඳහා ශ්‍රිතයක් තිබීම වඩා පිරිසිදු වනු ඇත, නමුත් සමහර විට වියුක්ත කිරීම යනු කාලය හොරා ය.

සෙඩ් නව රේඛාවල ආදානය බිඳ දමයි. එය එක් ලූපයකට එක් පේළියක් පමණක් තබා ගනී.
එබැවින් \nරටා අවකාශයේ එය නොමැති නම් (නව රේඛාවක්) ගැලපීමට ක්‍රමයක් නොමැත .

ක්‍රමයක් ඇත, නමුත්, ඔබට ලූපය භාවිතා කරමින් රටා අවකාශයේ අඛණ්ඩ පේළි දෙකක් තබා ගත හැකිය :

sed 'N;l;P;D' alpha.txt

N සහ P අතර අවශ්‍ය ඕනෑම සැකසුම් එකතු කරන්න (ආදේශ කිරීම l).

මෙම අවස්ථාවේදී (පේළි 2):

$ sed 'N;s/a test\nPlease do not/not a test\nBe/;P;D' alpha.txt
This is
not a test
Be
be alarmed

හෝ, පේළි තුනක් සඳහා:

$ sed -n '1{$!N};$!N;s@a test\nPlease do not\nbe@not a test\nDo\nBe@;P;D' alpha.txt 
This is
not a test
Do
Be alarmed

එය උපකල්පනය කරන්නේ එකම රේඛා ප්‍රමාණයක් ප්‍රතිස්ථාපනය වන බවයි.