Nikolai Ignatushko ellenőrizte a GNU sed 4.2.1-es verzióját Gentoo forgalmazása a cikkben említett összes parancsot. Nem minden szkript működött jól a sed GNU verzióján. De az eset azokra az apróságokra vonatkozott, amelyeket kijavítottak. Csak a domb hegyekkel való helyettesítésének forgatókönyvét kellett jelentősen átdolgozni.
Üdvözöljük sorozatunk második részében a sed-en, a GNU verzióban. A sed több verziója is elérhető különböző platformokon, de mi a GNU sed 4.x verziójára fogunk összpontosítani. Sokan hallottatok a sed-ről, vagy már használták is, valószínűleg csereeszközként. De ez csak az egyik célja a sednek, és megpróbáljuk bemutatni a segédprogram használatának minden vonatkozását. A neve a „Stream EDitor” és a „stream” szó jelentése ez az eset jelenthet fájlt, csövet vagy csak stdin-t. Reméljük, hogy már rendelkezik alapismeretekkel a Linuxról, és ha már dolgozott reguláris kifejezésekkel, vagy legalább tudja, mik azok, akkor minden sokkal könnyebb lesz. A cikk terjedelme nem teszi lehetővé a belefoglalást teljes útmutató a reguláris kifejezéseken ehelyett az alapfogalmakat hangozzuk, és megadjuk nagyszámú példák a sed használatára.
Itt nincs sok mondanivaló. Valószínűleg már telepítve van a sed, mivel különféle rendszerszkriptek használják, valamint Linux felhasználók akik javítani akarnak teljesítményükön. A következő paranccsal megtudhatja, hogy a sed melyik verzióját telepítette:
$ sed --verzió
A rendszeremen ez a parancs azt mutatja, hogy telepítettem a GNU sed 4.2.1-et, plusz hivatkozásokat a következőre kezdőlap programokat és egyéb hasznos információkat. A csomag neve "sed" a terjesztéstől függetlenül, kivéve a Gentoo-t, ahol implicit módon jelen van.
Mielőtt továbbmennénk, fontosnak tartjuk, hogy a „sed” tevékenységére összpontosítsunk, mivel a „stream editor” nem mond sokat a céljáról. A sed szöveget vesz bevitelként, minden soron végrehajtja a megadott műveleteket (hacsak nincs másként megadva), és kiadja a módosított szöveget. Ezek a műveletek hozzáadhatók, beszúrhatók, törölhetők vagy cserélhetők. Ez nem olyan egyszerű, mint amilyennek látszik: figyelem, számos opció és opciókombináció létezik, amelyek nagyon megnehezíthetik a sed parancs megértését. Ezért azt javasoljuk, hogy tanulja meg a reguláris kifejezések alapjait, hogy megértse, hogyan működik. Mielőtt folytatnánk az útmutatót, szeretnénk megköszönni Eric Pementnek és másoknak az inspirációt és azt, amit mindenkiért tett, aki szeretné megtanulni és használni a sed-et.
Mivel a sed parancsok (scriptek) sokak számára rejtélyek maradnak, úgy érezzük, olvasóinknak meg kell érteniük az alapfogalmakat, nem pedig vakon másolni és beilleszteni azokat a parancsokat, amelyek jelentését nem értik. Amikor az ember meg akarja érteni, hogy mi is ő reguláris kifejezések, kulcsszó egy "egyezés", pontosabban "egyezési minta". Például egy, az osztálya számára készített jelentésben a Nick nevet írta be, utalva a hálózati építészre. De Nick elment, és John vette át a helyét, így most le kell cserélnie a Nick szót Johnra. Ha a jelentésfájl neve report.txt, akkor a következő parancsot kell futtatnia:
$ cat report.txt | sed "s/Nick/John/g" > report_new.txt
A sed alapértelmezés szerint az stdout-ot használja, és használhatja a kimeneti átirányítási operátort a fenti példában látható módon. Ez egy nagyon egyszerű példa, de szemléltettünk néhány pontot: megkeressük a „Nick” minta összes egyezését, és mindegyiket „John”-ra cseréljük. Ne feledje, hogy a sed a kis- és nagybetűkre érzékeny keresést végez, ezért legyen óvatos, és ellenőrizze a kimeneti fájlt, hogy megbizonyosodjon arról, hogy minden helyettesítés megtörtént. A fenti példát így is felírhatjuk:
$ sed "s/Nick/John/g" report.txt > report_new.txt
Oké, azt mondod, de hol vannak itt a reguláris kifejezések? Igen, először példát akartunk mutatni, és most kezdődik a legérdekesebb rész.
Ha nem biztos benne, hogy "nick" vagy "Nick" írta, és mindkét esetet le akarja fedni, akkor a sed "s/Nick|nick/John/g" parancsot kell használnia. A függőleges sávnak van egy jelentése, amit tudnod kell, ha tanultad a C nyelvet, vagyis a kifejezésed megegyezik a "nick" vagy a "nick" kifejezéssel. Amint alább látni fogja, a csatorna más módon is használható, de a jelentése ugyanaz. A reguláris kifejezésekben gyakran használt egyéb operátorok a "?", amely az előző karakter nulla vagy egy ismétlődését egyezik meg (azaz a flavou?r megegyezik az ízzel és az ízzel), a "*" nulla vagy többször, a "+" egy vagy több alkalommal. A "^" a sor elejére egyezik, a "$" pedig fordítva. Ha Ön vim vagy vim felhasználó, sok dolog ismerősnek fog tűnni. Végül is ezeknek a segédprogramoknak az awk-val és a C-vel együtt gyökerei a UNIX korai időszakában vannak. Erről most nem is beszélünk, mert példákkal könnyebb megérteni ezeknek a karaktereknek a jelentését, de tudnod kell, hogy a reguláris kifejezéseknek különféle megvalósításai vannak: POSIX, POSIX Extended, Perl, valamint a fuzzy reguláris kifejezések különféle megvalósításai. , ami garantálja a fejfájást.
| Parancs szintaxis | Leírás |
|
Sed "s/Nick/John/g" report.txt |
Nick minden előfordulását Johnra cseréli a report.txt fájlban |
|
Sed "s/Nick\|nick/John/g" report.txt |
A Nick vagy a becenév minden előfordulását Johnra cseréli. |
|
Sed "s/^/ /" file.txt > file_new.txt |
8 szóközt ad a szöveg bal oldalán a nyomtatási minőség javítása érdekében. |
|
Sed -n "/Természetesen/,/figyelem fizet/p" myfile |
Kinyomtatja az összes olyan bekezdést, amely a „Természetesen” szóval kezdődik, és a „figyelem, amit fizet”. |
|
Sed -n 12,18p fájl.txt |
Csak a file.txt 12-18. sorát adja ki |
|
Sed 12,18d file.txt |
A teljes file.txt fájlt kinyomtatja, kivéve a 12–18. sorokat |
| Egy üres sort szúr be a file.txt minden sora után | |
|
sed -f script.sed fájl.txt |
Minden parancsot beír a script.sed fájlba, és végrehajtja azokat. |
|
Sed "5!s/ham/cheese/" file.txt |
A sonkát sajttal helyettesíti a file.txt fájlban, kivéve az 5. sort |
|
Sed "$d" file.txt |
Törli az utolsó sort |
|
Sed -n "/\(3\)/p" file.txt |
Csak három egymást követő számjegyből álló sorokat nyomtat |
|
Sed "/boom/s/aaa/bb/" file.txt |
Ha "boom" található, cserélje ki az aaa-t bb-re |
|
Sed "17,/disk/d" file.txt |
Törli az összes sort a 17. sortól a "lemezig". Ha több "lemez" sor van, akkor az elsőig törli. |
|
Echo ONE TWO | sed "s/one/unos/I" |
Az egyiket az unos kis- és nagybetűk közötti különbséggel helyettesíti, így az "unos TWO" lesz kinyomtatva |
|
Sed "G;G" file.txt |
Kettőt szúr be üres sorok a file.txt minden sora után |
|
Sed "s/.$//" file.txt |
A dos2unix lecserélésének módja :). Általában törli minden sor utolsó karakterét. |
|
Sed "s/^[ \t]*//" file.txt |
Eltávolítja az összes szóközt/tabulátort a file.txt sorai előtt |
|
Sed "s/[ \t]*$//" file.txt |
Eltávolítja az összes szóközt/tabulátort a file.txt minden sorának végéről |
|
Sed "s/^[ \t]*//;s/[ \t]*$//" file.txt |
Eltávolítja az összes szóközt/tabulátort a file.txt minden sorának elején és végén |
|
Sed "s/foo/bar/" file.txt |
A foo szót bar-ra cseréli csak a karakterlánc első előfordulásakor. |
|
Sed "s/foo/bar/4" file.txt |
A foo szót bar-ra cseréli csak a karakterlánc negyedik előfordulásakor. |
|
Sed "s/foo/bar/g" file.txt |
A foo szót bar-ra cseréli a karakterlánc minden előfordulásakor. |
|
Sed "/baz/s/foo/bar/g" file.txt |
Csak akkor cserélje ki a foo-t bar-ra, ha a karakterlánc tartalmaz bazt. |
|
Sed "/./,/^$/!d" file.txt |
Tömörítse az összes egymást követő üres sort egybe. A tetején nincs üres sor. |
|
Sed "/^$/N;/\n$/D" file.txt |
Az összes egymást követő üres sort tömörítse egybe, de a felső sort hagyja üresen. |
|
Sed "/./,$!d" file.txt |
Távolítsa el az összes vezető üres sort |
|
Sed -e:a -e "/^\n*$/($d;N;);/\n$/ba" file.txt |
Távolítsa el az összes utolsó üres sort |
|
Sed -e:a -e "/\\$/N; s/\\\n/ /; ta" file.txt |
Ha egy sor fordított perjelre végződik, csatlakoztassa a következőhöz (shell szkripteknél hasznos) |
|
Sed -n "/regex/,+5p" file.txt |
A szabályos kifejezést tartalmazó sor után 5 sort nyomtat |
|
Sed "1~3d" file.txt |
Töröljön minden harmadik sort, az elsővel kezdve. |
|
Sed -n "2~5p" file.txt |
Nyomtasson minden ötödik sort a másodiktól kezdve. |
|
Sed "s/ick/John/g" report.txt |
A fenti példák egy másik módja. Tudod ajánlani a sajátodat? |
|
sed -n "/RE/(p;q;)" fájl.txt |
Kinyomtatja az első RE (reguláris kifejezés) egyezésű karakterláncot |
|
Sed "0,/RE/(//d;)" file.txt |
Törli az első egyezésű sort |
|
Sed "0,/RE/s//to_that/" file.txt |
Csak az első meccsen változik |
|
Sed "s/^[^,]*,/9999,/" file.csv |
A CSV-fájl első oszlopában lévő összes értéket 9999-re cseréli |
|
S/^ *\(.*[^ ]\) *$/|\1|/; s/"*, */"|/g; :loop s/| *\([^",|][^,|]*\) *, */|\1|/g; s/| *, */||/g; t ciklus s/ *|/|/g ;s/|*/|/g;s/^|\(.*\)|$/\1/; |
Egy sed-szkript a CSV-fájlok olyan fájllá konvertálásához, amely függőleges sávot tartalmaz elválasztóként (csak bizonyos CSV-típusokkal működik, beágyazott idézőjelekkel és vesszőkkel). |
|
Sed ":a;s/\(^\|[^0-9.]\)\(\+\)\(\(3\)\)/\1\2,\3/g;ta" fájl .txt |
Módosítja a file.txt számformátumát 1234,56-ról 1 234,56-ra |
|
Sed -r "s/\<(reg|exp)+/\U&/g" |
Bármely reg vagy exp betűvel kezdődő szót nagybetűvé alakít. |
|
Sed "1.20s/Johnson/White/g" file.txt |
Csak az 1-20. sorban változtatja meg Johnsont White-ra. |
|
Sed "1,20 !s/Johnson/White/g" file.txt |
Az előző példa fordított (mindent lecserél, kivéve az 1-20. sorokat) |
|
Sed "/from/,/until/ ( s/\<red\>/magenta/g; s/<blue\>/cyan/g; )" file.txt |
Csak a "tól" és az "amíg" között helyettesíti. Ha több "tól"-"ig" terület van, mindegyikben lecseréli. |
|
Sed "/ENDNOTES:/,$ ( s/Schaff/Herzog/g; s/Kraft/Ebbing/g; )" file.txt |
Csak az "ENDNOTES:" szót helyettesíti az EOF-ig |
|
Sed "/./(H;$!d;);x;/regex/!d" file.txt |
Csak akkor nyomtat egy bekezdést, ha az tartalmaz egy szabályos kifejezést |
|
Sed -e "/./(H;$!d;)" -e "x;/RE1/!d;/RE2/!d;/RE3/!d" file.txt |
Csak akkor nyomtatja ki a bekezdéseket, ha azok tartalmazzák az RE1-et, RE2-t és az RE3-at. Az RE1, RE2 és RE3 sorrendje nem számít. |
|
Sed "s/14"/tizennégy hüvelyk/g" fájl.txt |
Így használhat dupla idézőjeleket |
|
Sed "s/\/some\/UNIX\/path/\/a\/new\/path/g" file.txt |
Munka Unix Paths |
|
Sed "s///g" file.txt |
Eltávolítja az összes a-val kezdődő és g-vel végződő karaktert a fájl.txt fájlból |
|
Sed "s/\(.*\)foo/\1bar/" file.txt |
Csak a foo utolsó egyezését cseréli le egy karakterláncban a bárral |
|
Sed "1!G;h;$!d" |
A tac parancs cseréje |
|
Sed "/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//" |
A fordulat parancs cseréje |
|
Sed 10q file.txt |
A fej parancs cseréje |
|
Sed -e:a -e "$q;N;11,$D;ba" fájl.txt |
A farok parancs cseréje |
|
Sed "$!N; /^\(.*\)\n\1$/!P; D" file.txt |
Az uniq Command cseréje |
|
Sed "$!N; s/^\(.*\)\n\1$/\1/;t; D" file.txt |
Fordított parancs (egyenértékű az uniq -d-vel) |
|
Sed "$!N;$!D" file.txt |
Egyenértékű a farok -n 2-vel |
|
sed -n "$p" fájl.txt |
... farok -n 1 (vagy farok -1) |
|
Sed "/regexp/!d" file.txt |
grep megfelelője |
|
Sed -n "/regexp/(g;1!p;);h" file.txt |
Kinyomtatja a reguláris kifejezés első egyezése előtti sort, de magát az egyezést nem tartalmazza. |
|
sed -n "/regexp/(n;p;)" fájl.txt |
A reguláris kifejezés első egyezése utáni sort nyomtatja ki, de magát az egyezést nem tartalmazza. |
|
sed "/pattern/d" fájl.txt |
Eltávolítja a mintának megfelelő vonalakat |
|
Sed "/./!d" file.txt |
Eltávolítja az összes üres sort a fájlból |
|
Sed "/^$/N;/\n$/N;//D" file.txt |
Az összes egymást követő üres sort két üres sorra tömöríti. Egyetlen üres sor nem módosul. |
|
Sed -n "/^$/(p;h;);/./(x;/./p;)" file.txt |
Törli az egyes bekezdések utolsó sorát |
| Lekéri az e-mail fejlécét. Más szóval - mindent töröl az első üres sor után. | |
Üdvözöljük sorozatunk második részében a sed-en, a GNU verzióban. A sed több verziója is elérhető különböző platformokon, de mi a GNU sed 4.x verziójára fogunk összpontosítani. Sokan hallottatok a sed-ről, vagy már használták is, valószínűleg csereeszközként. De ez csak az egyik célja a sednek, és megpróbáljuk bemutatni a segédprogram használatának minden vonatkozását. A neve a "Stream EDitor" rövidítése, és a "stream" (folyam) szó ebben az esetben fájlt, csövet vagy egyszerűen stdin-t jelenthet. Reméljük, hogy már rendelkezik alapismeretekkel a Linuxról, és ha már dolgozott reguláris kifejezésekkel, vagy legalább tudja, mik azok, akkor minden sokkal könnyebb lesz. Ez a cikk nem elég nagy ahhoz, hogy egy teljes útmutatót tartalmazzon a reguláris kifejezésekről, ehelyett az alapvető fogalmakat ismertetjük, és sok példát adunk a sed használatára.
Itt nincs sok mondanivaló. Valószínűleg már telepítve van a sed, mivel azt különféle rendszerszkriptek, valamint a hatékonyságukat növelni kívánó Linux-felhasználók használják. A következő paranccsal megtudhatja, hogy a sed melyik verzióját telepítette:
$ sed --verzió
A rendszeremen ez a parancs azt mutatja, hogy telepítettem a GNU sed 4.2.1-et, valamint egy hivatkozást a program kezdőlapjára és egyéb hasznos információkat. A csomag neve "sed" a terjesztéstől függetlenül, kivéve a Gentoo-t, ahol implicit módon jelen van.
Mielőtt továbbmennénk, fontosnak tartjuk, hogy a „sed” tevékenységére összpontosítsunk, mivel a „stream editor” nem mond sokat a céljáról. A sed szöveget vesz bevitelként, minden soron végrehajtja a megadott műveleteket (hacsak nincs másként megadva), és kiadja a módosított szöveget. Ezek a műveletek hozzáadhatók, beszúrhatók, törölhetők vagy cserélhetők. Ez nem olyan egyszerű, mint amilyennek látszik: figyelem, számos opció és opciókombináció létezik, amelyek nagyon megnehezíthetik a sed parancs megértését. Ezért azt javasoljuk, hogy tanulja meg a reguláris kifejezések alapjait, hogy megértse, hogyan működik. Mielőtt folytatnánk az útmutatót, szeretnénk megköszönni Eric Pementnek és másoknak az inspirációt és azt, amit mindenkiért tett, aki szeretné megtanulni és használni a sed-et.
Mivel a sed parancsok (scriptek) sokak számára rejtélyek maradnak, úgy érezzük, olvasóinknak meg kell érteniük az alapfogalmakat, nem pedig vakon másolni és beilleszteni azokat a parancsokat, amelyek jelentését nem értik. Ha valaki meg akarja érteni, mik azok a reguláris kifejezések, akkor a kulcsszó a „match”, pontosabban a „match pattern”. Például egy, az osztálya számára készített jelentésben a Nick nevet írta be, utalva a hálózati építészre. De Nick elment, és John vette át a helyét, így most le kell cserélnie a Nick szót Johnra. Ha a jelentésfájl neve report.txt, akkor a következő parancsot kell futtatnia:
$ cat report.txt / sed "s/Nick/John/g" > report_new.txt
A sed alapértelmezés szerint az stdout-ot használja, és használhatja a kimeneti átirányítási operátort a fenti példában látható módon. Ez egy nagyon egyszerű példa, de szemléltettünk néhány pontot: megkeressük a „Nick” minta összes egyezését, és mindegyiket „John”-ra cseréljük. Ne feledje, hogy a sed a kis- és nagybetűkre érzékeny keresést végez, ezért legyen óvatos, és ellenőrizze a kimeneti fájlt, hogy megbizonyosodjon arról, hogy minden helyettesítés megtörtént. A fenti példát így is felírhatjuk:
$ sed "s/Nick/John/g" report.txt > report_new.txt
Oké, azt mondod, de hol vannak itt a reguláris kifejezések? Igen, először példát akartunk mutatni, és most kezdődik a legérdekesebb rész.
Ha nem biztos abban, hogy "nick" vagy "Nick"-t írt, és mindkét esetet kezelni szeretné, használja a sed "s/Nick/nick/John/g" parancsot. A függőleges sávnak van egy jelentése, amit tudnod kell, ha tanultad a C nyelvet, vagyis a kifejezésed megegyezik a "nick" vagy a "nick" kifejezéssel. Amint alább látni fogja, a csatorna más módon is használható, de a jelentése ugyanaz. A reguláris kifejezésekben gyakran használt egyéb operátorok a "?", amely az előző karakter nulla vagy egy ismétlődését egyezik meg (azaz a flavou?r megegyezik az ízzel és az ízzel), a "*" nulla vagy többször, a "+" egy vagy több alkalommal. A "^" a sor elejére egyezik, a "$" pedig fordítva. Ha Ön vim vagy vim felhasználó, sok dolog ismerősnek fog tűnni. Végül is ezeknek a segédprogramoknak az awk-val és a C-vel együtt gyökerei a UNIX korai időszakában vannak. Erről most nem is beszélünk, mert példákkal könnyebb megérteni ezeknek a karaktereknek a jelentését, de tudnod kell, hogy a reguláris kifejezéseknek különféle megvalósításai vannak: POSIX, POSIX Extended, Perl, valamint a fuzzy reguláris kifejezések különféle megvalósításai. , ami garantálja a fejfájást.
| Parancs szintaxis | Leírás |
| sed "s/Nick/John/g" report.txt | Nick minden előfordulását Johnra cseréli a report.txt fájlban |
| sed "s/Nick/nick/John/g" report.txt | A Nick vagy a becenév minden előfordulását Johnra cseréli. |
| sed "s/^/ /" file.txt >file_new.txt | 8 szóközt ad a szöveg bal oldalán a nyomtatási minőség javítása érdekében. |
| sed -n "/Természetesen/,/figyelem \ pay/p" myfile |
Kiad egy bekezdést, amely a „Természetesen” szóval kezdődik, és a „figyelem, amit fizet” kifejezéssel végződik. |
| sed -n 12.18p fájl.txt | Csak a file.txt 12-18. sorát adja ki |
| sed12,18d fájl.txt | A teljes file.txt fájlt kinyomtatja, kivéve a 12–18. sorokat |
| sed G fájl.txt | Megduplázza a szóközöket a file.txt fájlban |
| sed -f script.sed fájl.txt | Minden parancsot beír a script.sed fájlba, és végrehajtja azokat. |
| sed "5!s/ham/cheese/" file.txt | A sonkát sajttal helyettesíti a file.txt fájlban, kivéve az 5. sort |
| sed "$d" fájl.txt | Törli az utolsó sort |
| sed "/\(3\)/p" fájl.txt | Csak három egymást követő számjegyből álló sorokat nyomtat |
| sed "/boom/!s/aaa/bb/" file.txt | Ha "boom" található, cserélje ki az aaa-t bb-re |
| sed "17,/lemez/d" file.txt | Törli az összes sort a 17. sortól a "lemezig" |
| echo ONE TWO / sed "s/one/unos/I" | Az egyiket az unos kis- és nagybetűk közötti különbséggel helyettesíti, így az "unos TWO" lesz kinyomtatva |
| sed "G;G" file.txt | Három szóköz egy fájlban |
| sed "s/.$//" file.txt | dos2unix csere módja :) |
| sed "s/^[ ^t]*//" fájl.txt | Eltávolítja az összes szóközt a file.txt sorai előtt |
| sed "s/[ ^t]*$//" file.txt | Eltávolítja az összes szóközt a file.txt minden sorának végéről |
| sed "s/^[ ^t]*//;s/[ ^]*$//" file.txt | Eltávolítja az összes szóközt a file.txt minden sorának elejéről és végéről |
| sed "s/foo/bar/" file.txt | A foo szót bar-ra cseréli csak a karakterlánc első előfordulásakor. |
| sed "s/foo/bar/4" file.txt | A foo szót bar-ra cseréli csak a karakterlánc negyedik előfordulásakor. |
| sed "s/foo/bar/g" file.txt | A foo szót bar-ra cseréli a karakterlánc minden előfordulásakor. |
| sed "/baz/s/foo/bar/g" file.txt | Csak akkor cserélje ki a foo-t bar-ra, ha a karakterlánc tartalmaz bazt. |
| sed "/./,/^$/!d" fájl.txt | Törölje az összes egymást követő üres sort, kivéve az EOF-t |
| sed "/^$/N;/\n$/D" file.txt | Törölje az összes egymást követő üres sort, de a felső sort hagyja üresen. |
| sed "/./,$!d" fájl.txt | Távolítsa el az összes vezető üres sort |
| sed -e:a -e "/^\n*$/($d;N;);/\n$/ba" \ fájl.txt |
Távolítsa el az összes utolsó üres sort |
| sed -e:a -e "/\\$/N; s/\\\n//; ta" \ fájl.txt |
Ha egy fájl fordított perjelre végződik, csatlakoztassa a következőhöz (shell szkripteknél hasznos) |
| sed "/regex/,+5/expr/" | Megfelel a reguláris kifejezésnek és a következő 5 sornak |
| sed "1~3d" file.txt | Töröljön minden harmadik sort, az elsővel kezdve. |
| sed -n "2~5p" fájl.txt | Nyomtasson minden ötödik sort a másodiktól kezdve. |
| sed "s/ick/John/g" report.txt | A fenti példák egy másik módja. Tudod ajánlani a sajátodat? |
| sed -n "/RE/(p;q;)" fájl.txt | Csak az RE (reguláris kifejezés) első egyezését nyomtatja ki |
| sed "0,/RE/(//d;)" fájl.txt | Csak az első egyezést távolítja el |
| sed "0,/RE/s//to_that/" file.txt | Csak az első meccsen változik |
| sed "s/^[^,]*,/9999,/" file.csv | Az első mezőt 9999-re módosítja a CSV-fájlban |
| s/^ *\(.*[^ ]\) *$//\1//; s/"*, */"//g; : ciklus s// *\([^",/][^,/]*\) *, *//\1//g; s// *, *//\1//g; t ciklus s / *////g;s// *///g;s/^/\(.*\)/$/\1/; | Egy sed-szkript a CSV-fájlok olyan fájllá konvertálásához, amely függőleges sávot tartalmaz elválasztóként (csak bizonyos CSV-típusokkal működik, beágyazott idézőjelekkel és vesszőkkel). |
| sed ":a;s/\(^\/[^0-9.]\)\(\+\)\(\(3\)\)/\1\2,\3/g;ta" fájl .txt | Módosítja a file.txt számformátumát 1234,56-ról 1 234,56-ra |
| sed -r "s/\<(reg/exp)+/\U&/g" | Bármely reg vagy exp betűvel kezdődő szót nagybetűvé alakít. |
| sed "1.20s/Johnson/White/g" file.txt | Csak az 1-20. sorban változtatja meg Johnsont White-ra. |
| sed "1,20 !s/Johnson/White/g" file.txt | Az előző példa fordított (mindent lecserél, kivéve az 1-20. sorokat) |
| sed "/from/,/amig/ ( s/\ /magenta/g; \ s/\ /cyan/g; )" file.txt | Csak a "tól" és az "amíg" között helyettesíti |
| sed "/ENDNOTES:/,$ ( s/Schaff/Herzog/g; \ s/Kraft/Ebbing/g; )" file.txt | Csak az "ENDNOTES:" szót helyettesíti az EOF-ig |
| sed "/./(H;$!d;);x;/regex/!d" fájl.txt | Csak akkor nyomtat egy bekezdést, ha az tartalmaz egy szabályos kifejezést |
| sed -e "/./(H;$!d;)" -e "x;/RE1/!d;/RE2/!d;/RE3/!d" fájl.txt | Csak akkor nyomtasson bekezdéseket, ha azok tartalmazzák az RE1-et, RE2-t és az RE3-at |
| sed "s/14"/tizennégy hüvelyk/g" fájl.txt | Így használhat dupla idézőjeleket |
| sed "s/\/some\/UNIX\/path/\/a\/new\/path/g" file.txt | Munka Unix Paths |
| sed "s///g" file.txt | Eltávolítja az összes a-val kezdődő és g-vel végződő karaktert a fájl.txt fájlból |
| sed "s/\(.*\)foo/\1bar/" file.txt | Csak a foo utolsó egyezését cseréli le bárra |
| sed "1!G;h;$!d" | A tac parancs cseréje |
| sed "/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//" | A fordulat parancs cseréje |
| sed 10q fájl.txt | A fej parancs cseréje |
| sed -e:a -e "$q;N;11,$D;ba" \ file.txt | A farok parancs cseréje |
| sed "$!N; /^\(.*\)\n\1$/!P; D" \ fájl.txt | Az uniq Command cseréje |
| sed "$!N; s/^\(.*\)\n\1$/\1/;\ t; D" file.txt | Fordított parancs (egyenértékű az uniq -d-vel) |
| sed "$!N;$!D" fájl.txt | Egyenértékű a farok -n 2-vel |
| sed -n "$p" fájl.txt | ... farok -n 1 (vagy farok -1) |
| sed "/regexp/!d" fájl.txt | grep megfelelője |
| sed -n "/regexp/(g;1!p;);h" fájl.txt | Kinyomtatja a reguláris kifejezés első egyezése előtti sort, de magát az egyezést nem tartalmazza. |
| sed -n "/regexp/(n;p;)" fájl.txt | A reguláris kifejezés első egyezése utáni sort nyomtatja ki, de magát az egyezést nem tartalmazza. |
| sed "/pattern/d" fájl.txt | Eltávolítja a mintának megfelelő vonalakat |
| sed "/./!d" fájl.txt | Eltávolítja az összes üres sort a fájlból |
| sed "/^$/N;/\n$/N;//D" file.txt | Törli az összes egymást követő üres sort, kivéve az első kettőt |
| sed -n "/^$/(p;h;);/./(x;/./p;)"\ file.txt | Törli az egyes bekezdések utolsó sorát |
| sed "/^$/q" | Lekéri az e-mail fejlécét |
| "1,/^$/d" | Megkapja az üzenet törzsét |
| sed "/^Tárgy: */!d; s///;q" | Lekéri az e-mail tárgyát |
| sed "s/^/> /" | Idéz egy üzenetet a "> " karakter beszúrásával minden sor elé |
| sed "s/^> //" | Fordított parancs (eltávolítja az idézetet az üzenetből) |
| sed -e:a -e "s/<[^>]*>//g;/ | Eltávolítja a HTML címkéket |
| sed "/./(H;d;);x;s/\n/=(NL)=/g" file.txt / sort \ / sed "1s/=(NL)=//;s/=( NL)=/\n/g" | A file.txt bekezdéseit ábécé szerint rendezi |
| sed "s@/usr/bin@&/ [e-mail védett]"útvonal.txt | A /usr/bin lecseréli a /usr/bin/local fájlt a path.txt fájlban |
| sed "s@^.*$@<<<&>>>@g"path.txt | Próbáld ki és meglátod :) |
| sed "s/\(\/[^:]*\).*/\1/g" path.txt | Feltéve, hogy a path.txt tartalmazza a $PATH-t, minden sorba csak az első elérési utat írja ki |
| sed "s/\([^:]*\).*/\1/" /etc/passwd | awk csere - csak a passwd fájlból jelenítse meg a felhasználókat |
| echo "Welcome To The Geek Stuff" / sed \ "s/\(\b\)/\(\1\)/g" (W)welcome (T)o (T)he (G)eek (S)tuff | Magyarázat nélkül is érthető |
| sed -e "/^$/,/^END/s/hills/\ mountains/g" file.txt | A „dombokat” a „hegyekkel” helyettesíti, de csak az üres sorral kezdődő és három „END” karakterrel végződő szövegtömbökben. |
| sed -e "/^#/d" /etc/services/more | Megjeleníti a szolgáltatásfájlt kommentált sorok nélkül |
| sed "$s@\([^:]*\):\([^:]*\):\([^:]*\)@\3:\2:\ [e-mail védett]"útvonal.txt | Megfordítja az elemek sorrendjét a path.txt fájl utolsó sorában |
| sed "/regex/(x;p;x;)" fájl.txt | Minden, a reguláris kifejezésnek megfelelő sor fölé új sort szúr be |
| sed "/AAA/!d; /BBB/!d; /CCC/!d" file.txt | Az AAA, BBB és CCC betűket bármilyen sorrendben keresi |
| sed "/AAA.*BBB.*CCC/!d" fájl.txt | Az AAA, BBB és CCC feliratokat a megadott sorrendben keresi |
| sed -n "/^.\(65\)/p" fájl.txt | 65 vagy több karakterből álló sorokat nyomtat |
| sed -n "/^.\(65\)/!p" fájl.txt | Legfeljebb 65 karakterből álló sorokat nyomtat |
| sed "/regex/G" fájl.txt | Minden sor alá beszúr egy üres sort |
| sed "/regex/(x;p;x;G;)" fájl.txt | Minden sor fölé és alá egy üres sort szúr be |
| sed = fájl.txt / sed "N;s/\n/\t/" | Sorok számozása a file.txt fájlban |
| sed -e:a -e "s/^.\(1,78\)$/ &/;ta" file.txt | Igazítsa jobbra a szöveget |
| sed -e:a -e "s/^.\(1,77\)$/ &/;ta" -e "s/\(*\)\1/\1/" file.txt | Szöveg igazítása középre |
Ez csak egy része annak, amit a sed-ről elmondhatunk, de ez a cikksorozat inkább egy útmutató, amely reméljük, hogy segít értékelni a Unix segédprogramok teljes erejét, és hatékonyabbá teszi a munkáját.
Legutóbb a bash szkriptekben lévő függvényekről beszéltünk, konkrétan arról, hogyan hívhatjuk meg őket parancssorból. Mai témánk egy nagyon hasznos eszköz a karakterlánc-adatok feldolgozására - egy sed nevű Linux segédprogram. Gyakran használják olyan szövegek kezelésére, amelyek naplófájloknak, konfigurációs fájloknak és egyéb fájloknak tűnnek.
Ha valamilyen módon kezeli az adatokat a bash szkriptekben, akkor ismernie kell a sed és gawk eszközöket. Itt a sed-re és a szövegekkel való munkára fogunk összpontosítani, mivel ez egy nagyon fontos lépés a bash szkriptek fejlesztésének hatalmas kiterjedésein keresztüli utazásunk során.
Most elemezzük a sed-vel való munkavégzés alapjait, és több mint három tucat példát tekintünk meg ennek az eszköznek a használatára.
$ sed beállítási fájl
Alapértelmezés szerint a sed a meghívásakor megadott szabályokat alkalmazza, parancsok halmazaként kifejezve az STDIN-re. Ez lehetővé teszi az adatok közvetlen továbbítását a sed számára.
Például így:
$ echo "Ez egy teszt" | sed "s/teszt/egy másik teszt/"
Íme, mi történik a parancs futtatásakor.
Ebben az esetben a sed a "teszt" szót a feldolgozásra átadott karakterláncban az "egy másik teszt" szavakra cseréli. Egyenes perjelek segítségével formázható az idézőjelbe tett szöveg feldolgozási szabály. Esetünkben egy s/minta1/minta2/ parancsot használtunk. Az "s" betű a "helyettesítő" szó rövidítése, vagyis van egy cserecsapatunk. A Sed ezt a parancsot végrehajtva megnézi az átvitt szöveget, és lecseréli a benne talált töredékeket (arról, hogy melyikről lesz szó, alább), a minta1-nek megfelelő minta2-re cseréli.
A fenti egy primitív példa a sed használatára, csak az induláshoz. Valójában a sed sokkal összetettebb szövegszerkesztési forgatókönyvekben használható, például fájlokkal való munkavégzés során.
Az alábbiakban egy szöveget tartalmazó fájl található, és az ezzel a paranccsal végzett feldolgozás eredménye:
$ sed "s/teszt/egy másik teszt" ./myfile
Itt a fentebb használt megközelítést alkalmazzuk, de most a sed feldolgozza a fájlban tárolt szöveget. Ha azonban a fájl elég nagy, akkor észre fogja venni, hogy a sed az adatokat darabokban dolgozza fel, és a feldolgozott adatokat megjeleníti a képernyőn anélkül, hogy megvárná a teljes fájl feldolgozását.
A Sed nem változtatja meg a feldolgozott fájl adatait. A szerkesztő beolvassa a fájlt, feldolgozza az olvasottakat, és elküldi a kimenetet az STDOUT-nak. Annak érdekében, hogy megbizonyosodjunk arról, hogy a forrásfájl nem változott, elegendő megnyitni, miután átadtuk a sed-nek. Ha szükséges, a sed kimenete átirányítható egy fájlba, esetleg felülírva a régi fájlt. Ha ismeri a sorozat egyik korábbi cikkét, amely a bemeneti és kimeneti adatfolyamok átirányításával foglalkozik, akkor ezt meg kell tudnia tenni.
$ sed -e "s/Ez/az/; s/teszt/egy másik teszt/" ./myfile
Mindkét parancs a fájl minden sorára vonatkozik. Pontosvesszővel kell elválasztani őket, és nem lehet szóköz a parancs vége és a pontosvessző között.
Ha több szövegfeldolgozási mintát szeretne megadni a sed hívásakor, az első egyetlen idézőjel beírása után nyomja meg az Enter billentyűt, majd írja be az egyes szabályokat egy új sorba, a záró idézetet sem felejtve el:
$ sed -e "> s/Ez/az/ > s/teszt/egy másik teszt/" ./myfile
Ez történik az ebben a formában bemutatott parancs végrehajtása után.
Íme a mycommands fájl tartalma:
S/Ez/az/s/teszt/egy másik teszt/
Hívjuk a sed-et, átadva a szerkesztőnek egy fájlt parancsokkal és egy feldolgozandó fájlt:
$ sed -f mycommands myfile
Egy ilyen parancs meghívásának eredménye hasonló az előző példákban kapott eredményhez.
$ sed "s/teszt/egy másik teszt/" myfile
Íme, mi van a fájlban, és mit fog előállítani, amikor a sed feldolgozza.
A csere parancs általában egy több sorból álló fájlt dolgoz fel, de az egyes sorban csak a keresett szövegrész első előfordulásait cseréli le. A minta minden előfordulásának cseréjéhez a megfelelő jelzőt kell használni.
A helyettesítő parancs írásának szintaxisa zászlók használatakor így néz ki:
S/minta/csere/zászlók
Ennek a parancsnak a végrehajtása többféleképpen módosítható.
$ sed "s/teszt/egy másik teszt/2" myfile
A csere parancs meghívása, amely megadja a cserélni kívánt töredék pozícióját
Itt a 2-es számot adtuk meg helyettesítő jelzőként, ami oda vezetett, hogy minden sorban csak a kívánt minta második előfordulása került cserére. Most próbáljuk meg a globális helyettesítő jelzőt - g:
$ sed "s/teszt/egy másik teszt/g" myfile
Amint a kimenetből látható, ez a parancs a minta minden előfordulását helyettesítette a szövegben.
A p helyettesítési parancs jelzője lehetővé teszi az illesztett sorok kimenetét, míg a sed meghívásakor megadott -n opció elnyomja a normál kimenetet:
$ sed -n "s/teszt/egy másik teszt/p" saját fájl
Ennek eredményeként, ha a sed ebben a konfigurációban fut, csak azok a sorok (esetünkben egy sor) jelennek meg a képernyőn, amelyekben az adott szövegrész található.
Használjuk a w jelzőt, amellyel a szövegfeldolgozás eredményeit fájlba menthetjük:
$ sed "s/teszt/egy másik teszt/w kimenet" myfile
Jól látható, hogy a parancs működése során az adatok az STDOUT -ba kerülnek, míg a feldolgozott sorok a w után megadott fájlba íródnak.
$ sed "s/\/bin\/bash/\/bin\/csh/" /etc/passwd
Azonban nem néz ki túl jól. A helyzet az, hogy mivel a perjeleket elválasztó karakterként használjuk, a sed-nek átadott sorokban ugyanazokat a karaktereket kell kihagyni. Ennek eredményeként a parancs olvashatósága romlik.
Szerencsére a sed lehetővé teszi, hogy magunk állítsuk be a határoló karaktereket a helyettesítő parancsban. A határoló az s után megjelenő első karakter:
$ sed "s!/bin/bash!/bin/csh!" /etc/passwd
Ebben az esetben egy felkiáltójelet használunk határolóként, így a kód könnyebben olvasható és sokkal tisztább, mint korábban.
$ sed "2s/test/ather test/" myfile
A második lehetőség egy sor karakterlánc:
$ sed "2,3s/teszt/egy másik teszt/" myfile
Ezenkívül meghívhatja a csere parancsot, hogy a fájl egy bizonyos sortól a végéig kerüljön feldolgozásra:
$ sed "2,$s/teszt/egyéb teszt/" myfile
Ha csak a megadott szűrőnek megfelelő sorokat akarja feldolgozni a csere paranccsal, a parancsot a következőképpen kell meghívni:
$ sed "/likegeeks/s/bash/csh/" /etc/passwd
A fentiekkel analóg módon a sablon az s parancsnév előtt kerül átadásra.
Itt egy nagyon egyszerű szűrőt használtunk. Ennek a megközelítésnek a lehetőségeinek teljes körű feltárása érdekében használhat reguláris kifejezéseket. Az egyikben beszélünk róluk a következő anyagokat ezt a sorozatot.
A parancshívás így néz ki:
$ sed "3d" myfile
A harmadik sort szeretnénk eltávolítani a szövegből. Vegye figyelembe, hogy ez nem fájl. A fájl változatlan marad, a törlés csak a sed által generált kimenetet érinti.
Ha a d parancs meghívásakor nem adja meg a törölni kívánt sor számát, a folyam összes sora törlődik.
A következőképpen alkalmazhatja a d parancsot számos sorra:
$ sed "2,3d" myfile
És itt van a sorok törlése, az adott sortól kezdve - a fájl végéig:
$ sed "3,$d" myfile
A sorok a minta szerint is törölhetők:
$ sed "/test/d" saját fájl
A d hívásakor megadhat néhány mintát - a sorok, amelyekben a minta előfordul, és a közöttük lévő sorok törlődnek:
$ sed "/second/,/fourth/d" myfile
$ echo "Másik teszt" | sed "i\First teszt"
Most nézzük meg az a parancsot:
$ echo "Másik teszt" | sed "a\First teszt"
Amint láthatja, ezek a parancsok szöveget adnak az adatfolyamból származó adatok elé vagy után. Mi van, ha hozzá kell adni egy sort valahol a közepén?
Itt a segítségünkre lesz a folyamban található hivatkozási sor, illetve a sablon számának megadása. Vegye figyelembe, hogy a karakterláncok tartományként történő címzése itt nem működik. Hívjuk meg az i parancsot, megadva azt a sorszámot, amely elé új sort szeretnénk beszúrni:
$ sed "2i\Ez a beillesztett sor." saját fájl
Tegyük ugyanezt az a paranccsal:
$ sed "2a\Ez a hozzáfűzött sor." saját fájl
Jegyezze meg a különbséget az i és a parancs működésében. Az első új sort szúr be a megadott elé, a második után.
$ sed "3c\Ez egy módosított sor." saját fájl
Ha egy mintát egyszerű szöveg vagy reguláris kifejezés formájában használ a parancs meghívásakor, akkor a mintának megfelelő összes sor lecserélődik:
$ sed "/This is/c Ez egy megváltozott szövegsor." saját fájl
$ sed "y/123/567/" myfile
A parancs használatakor ügyeljen arra, hogy mindenre vonatkozik szövegfolyam, nem korlátozhatja a karakterek meghatározott előfordulására.
$ sed "=" saját fájl
stream szerkesztő sorszámokat jelenített meg a tartalmuk előtt.
Ha mintát ad át ennek a parancsnak, és a sed -n kapcsolót használja, csak a mintának megfelelő sorszámok kerülnek kinyomtatásra:
$ sed -n "/teszt/=" saját fájl
Vegyünk egy példát:
$ sed "3r newfile" myfile
Itt a newfile tartalma a myfile harmadik sora után lett beszúrva.
Íme, mi történik, ha sablont használ az r parancs meghívásakor:
$ sed "/test/r newfile" myfile
A fájl tartalma minden, a mintának megfelelő sor után beszúrásra kerül.
Ezt a problémát a sed folyamszerkesztő r és d parancsaival oldhatja meg:
$ Sed "/DATA>/ ( r newfile d)" myfile
Mint látható, a DATA helyőrző helyett a sed két sort adott az adatfájlból a kimeneti adatfolyamhoz.
Ez minden mára. Legközelebb az awk adatfeldolgozó nyelvről fogunk beszélni.
Kedves olvasóink! Használod a sed-et a mindennapi munkád során? Ha igen, kérem ossza meg tapasztalatait.
A sed stream szerkesztő nem interaktív szöveg szerkesztő A, amely szabványos bemenetről vagy fájlból származó adatokon hajt végre műveleteket. A Sed soronként szerkeszti az információkat.
A sed szerkesztővel való munka alapjait ismertettük. Ez az útmutató a fejlettebb technikákat ismerteti.
Néha szükségessé válik több parancs egyidejű átadása a sed szerkesztőnek. Ez többféleképpen történik.
Ha még nem rendelkezik tesztfájllal a sed használatához, hozza létre a következő környezetet:
CD
cp /usr/share/common-licenses/BSD .
cp /usr/share/common-licenses/GPL-3.
echo "ez az a dal, ami soha nem ér véget
nem tudni, mi volt az
csak azért, mert..." > bosszantó.txt
Mivel a sed szabványos bemenettel és kimenettel működik, természetesen csak hívható különféle csapatok egy sorban összerakva:
sed "s/and/\&/" bosszantó.txt | sed "s/emberek/lovak/"
igen, ez megy tovább, barátom
néhány ló elkezdte énekelni
nem tudni, mi volt az
és örökké énekelni fogják
csak mert...
Ez a módszer működik, de a sed több hívása többletköltséggel jár, több helyet foglal el, és nem használja a sed beépített funkcióit.
Egyszerre több parancsot is átadhat a sed-nek a -e kapcsolóval, amelyet minden parancs elé be kell szúrni:
sed -e "s/and/\&/" -e "s/people/horses/" bosszantó.txt
A parancsokat a pontosvessző karakterrel is összefűzheti egy karakterláncba. Ez a módszer pontosan ugyanúgy működik, mint az előző.
sed "s/and/\&/;s/people/horses/" bosszantó.txt
Vegye figyelembe, hogy az -e jelző használatakor törni kell egyetlen idézőjel, pontosvessző használatakor pedig az összes parancs idézőjelek között szerepelhet.
Ez a két módszer több parancs egyidejű meghívására meglehetősen kényelmes, de vannak esetek, amikor egyszerű parancssort kell használnia.
Meg kell ismerkednie az = operátorral is. Ez az utasítás sorszámot szúr be minden létező sor közé. Az eredmény így néz ki:
sed "=" bosszantó.txt
1
ez az a dal, ami soha nem ér véget
2
igen, ez folytatódik, barátom
3
néhányan elkezdték énekelni
4
nem tudni, mi volt az
5
és örökké énekelni fogják
6
csak mert...
Most próbálja meg szerkeszteni a szöveget, hogy lássa, hogyan változik a számozási formátum.
A G parancs alapértelmezés szerint egy üres sort ad a már meglévő sorok közé.
sed "G" bosszantó.txt
_
ez az a dal, ami soha nem ér véget
_
igen, ez folytatódik, barátom
_
néhányan elkezdték énekelni
_
nem tudni, mi volt az
_
és örökké énekelni fogják
_
csak mert...
Próbálja meg kombinálni ezt a két parancsot. Első pillantásra úgy tűnhet, hogy ezeknek a parancsoknak a kimenete egy üres sort tartalmaz a szövegsor és a számsor között. A kimenet azonban így néz ki:
sed "=;G" bosszantó.txt
1
ez az a dal, ami soha nem ér véget
_
2
igen, ez folytatódik, barátom
_
3
néhányan elkezdték énekelni
_
4
nem tudni, mi volt az
. . .
. . .
Ennek az az oka, hogy az = operátor megváltoztatja a kimeneti adatfolyamot (ami azt jelenti, hogy az eredményül kapott kimenet nem használható fel további szerkesztésre).
Ez megkerülhető a sed két hívásával, ahol az első hívás a második egyszerű szöveges adatfolyamaként lesz kezelve.
sed "=" bosszantó.txt | sed "G"
1
_
ez az a dal, ami soha nem ér véget
_
2
_
igen, ez folytatódik, barátom
_
3
_
néhányan elkezdték énekelni
. . .
. . .
Ne feledje, hogy néhány parancs hasonló módon működik, különösen, ha több parancsot fűz össze, és a kimenet eltér a várttól.
A címezhető sed parancsok egyik előnye, hogy reguláris kifejezéseket is használhatnak kritériumként. Ez azt jelenti, hogy olyan fájlokkal dolgozhat, amelyek tartalma nem pontosan ismert.
sed "1,3s/.*/Hello/" bosszantó.txt
Helló
Helló
Helló
nem tudni, mi volt az
és örökké énekelni fogják
csak mert...
Ehelyett használhat olyan reguláris kifejezést, amely csak az adott mintát tartalmazó sorokat találja meg. Ehhez a keresési mintát két perjel (/) közé kell tenni a parancs elé.
sed "/singing/s/it/& loudly/" bosszantó.txt
ez az a dal, ami soha nem ér véget
igen, ez folytatódik, barátom
néhányan hangosan énekelni kezdték
nem tudni, mi volt az
és örökké hangosan fogják énekelni
csak mert...
Ez a példa a szót hangosan az első elé helyezi minden sorban, amely az énekszót tartalmazza. Vegye figyelembe, hogy a második és a negyedik sor változatlan marad, mert nem egyezik a mintával.
A kifejezések megszólítása bonyolult lehet. Ez rugalmasabbá teszi a parancsokat.
A következő példa bemutatja, hogyan használhatók reguláris kifejezések címek generálására más parancsokhoz. Ez a parancs megkeresi és eltávolítja az összes üres sort:
sed "/^$/d" GPL-3
GNU ÁLTALÁNOS NYILVÁNOS LICENC
3. verzió, 2007. június 29
Copyright (C) 2007 Free Software Foundation, Inc.
Mindenki másolhat és szó szerinti másolatokat terjeszthet
pontjában található, de megváltoztatása nem megengedett.
Preambulum
A GNU General Public License egy ingyenes, copyleft licenc
. . .
. . .
Ne feledje, hogy a reguláris kifejezések a tartomány bármely részében használhatók.
Például törölheti a START és END sorok közötti sorokat:
sed "/^START$/,/^END$/d" bemeneti fájl
Ügyeljen arra, hogy ez a parancs törli az összes sort az első START szótól a talált első END szóig, és ha ismét találkozik a START szóval, akkor folytatja az adatok törlését.
A címzés megfordításához (vagyis a mintának nem megfelelő sorok kiválasztásához) használjon felkiáltójelet (!).
Például egy befejezett sor törléséhez írja be:
sed "/^$/!d" GPL-3
A címnek nem kell összetett kifejezésnek lennie ahhoz, hogy megfordítható legyen. Az inverzió ugyanúgy működik normál számozással.
Az extra tartási puffer növeli a sed többsoros szerkesztési képességét.
Az extra puffer egy ideiglenes tárolóterület, amely bizonyos parancsokkal módosítható.
Ez az extra puffer lehetővé teszi a karakterláncok tárolását, miközben más karakterláncokon dolgozik.
Parancsok a pufferrel való munkához:
A kiegészítő puffer tartalma mindaddig nem módosítható, amíg át nem helyezi a feldolgozási pufferbe.
Nézzünk egy összetett példát.
Próbálja meg összekapcsolni a szomszédos sorokat a következő paranccsal:
sed -n "1~2h;2~2(H;g;s/\n/ /;p)" bosszantó.txt
jegyzet: Valójában a sed külön beépített N parancsot biztosít ehhez; de a gyakorlat szempontjából hasznos megfontolni ezt a példát.
Az -n opció elnyomja az automatikus kimenetet.
1~2h - címdefiníció, amely a szöveg minden második sorát szekvenciálisan helyettesíti, az elsőtől kezdve (vagyis minden páratlan soron). A h parancs az egyező sorokat egy további pufferbe másolja.
A parancs többi része kapcsos zárójelek között van. Ez azt jelenti, hogy a parancs ezen része örökli az imént megadott címet. E zárójelek nélkül csak a H parancs örökli a címet, és a többi parancs végrehajtásra kerül soronként.
Természetesen a korábban említett N beépített sokkal rövidebb és egyszerűbb, és ugyanazt az eredményt adja:
sed -n "N;s/\n/ /p" bosszantó.txt
ez az a dal, aminek soha nincs vége, igen, ez megy tovább és tovább, barátom
néhányan úgy kezdték énekelni, hogy nem tudták, mi az
és örökké énekelni fogják, csak mert...
A parancsok szkriptekké kombinálhatók. Ez lehetővé teszi a parancsok teljes készletének végrehajtását egyetlen célsablonon.
Például írhat egy szkriptet egyszerű szöveges üzenetek létrehozásához, amelyeket előre formázni kell.
Ekkor nem kell folyamatosan ugyanazokat a parancsokat ismételnie minden üzenethez. A sed szkript lényegében egy adott objektumra alkalmazandó parancsok listája.
Például:
s/this/hat/g
s/hó/eső/g
1,5 s/fenyőtoboz/barack/g
Ezután meghívhatja a fájlt:
sed -f sedScriptName fileToEdit
Most már ismeri a sed-vel végzett munka fejlettebb módszereit.
Eleinte a sed parancsokat nehéz megérteni, és könnyen összekeverhetők. Ezért ajánlatos kísérletezni velük, mielőtt fontos adatokon használná őket.
Címkék: ,A sed parancs egy Stream EDitor a szövegek automatikus szerkesztéséhez. "Stream editor" - abban az értelemben, hogy folyamatosan tudja szerkeszteni a bejövő adatfolyamot, mondjuk egy programcsatorna (pipe) részeként. Automatikus – ez azt jelenti, hogy amint beállítja a szerkesztési szabályokat, a többi megtörténik az Ön unalmas részvétele nélkül. Más szóval, a sed nem interaktív.
A sed program összetettebb, mint azok a parancsok, amelyeket a HuMan sorozat korábbi cikkeiben már tárgyaltunk. Saját parancsok arzenáljával rendelkezik, így a tautológia és a félreértés elkerülése érdekében ebben a cikkben a sed parancsot ezentúl "programnak" vagy "szerkesztőnek" nevezzük, a sed szerkesztő parancsait pedig egyszerűen parancsoknak.
A sed program összetett feladatok elvégzésére képes, és időbe telik, amíg megtanulják ezeket a feladatokat megfogalmazni.
De az összetett műveletek mellett a sed parancs egyszerű, de nagyon hasznos funkciókkal rendelkezik, amelyeket semmivel sem nehezebb elsajátítani, mint a többi Unix parancsot. Ne engedje meg magának, hogy a teljes program elsajátításának bonyolultsága miatt elhagyja annak egyszerű aspektusait.
Kezdjük az egyszerűtől a bonyolultig, így mindig kitalálhatja, hol álljon meg.
A sed programnak sok natív parancsa van. A legtöbb felhasználó csak az s parancsot ismeri, és ez elég a sed szerkesztővel való együttműködéshez. Az s parancs a PATTERN-t a REPLACE-ra cseréli:
sed s /SAMPLE/REPLACE/
$ echo nap | sed s /nap/éj/ (Enter) éjszaka
Nem lesz könnyebb. És itt van egy példa a zar.txt fájl bevitelére:
Reggelente gyakorlatokat végzett. A villám elektromos töltés. $ sed s/charge/discharge/ zar.txt Reggel lemerült. A villámlás elektromos kisülés.
Nem idéztem s/MINTA/CSERE/ mert adott példa nem igényel idézőjeleket, de ha metakarakterek szerepelnének benne, akkor idézőjelek kellenek. Annak érdekében, hogy ne törje a fejét minden alkalommal, és ne hibázzon véletlenül, mindig tegyen idézőjeleket, jobb, mint az "erősebb" egyedülállók, ez egy jó szokás. Olajjal nem rontod el a zabkását. Én sem fogok fukarkodni minden további példában az idézetekkel.
Amint látjuk, az s helyettesítő parancsnak négy összetevője van:
Maga az S parancs /.../.../ elválasztja a PATTERN mintát, hogy megkeresse, majd lecserélje a REPLACE kifejezést, amely lecseréli a PATTERN kifejezést, ha talál ilyet.
A perjelet (/) hagyományosan határolóként használják, mivel a sed ős ed használja őket (a vi-hez hasonlóan). Egyes esetekben egy ilyen elválasztó nagyon kényelmetlen, például amikor meg kell változtatni az elérési utat (útvonalat) olyan könyvtárakhoz, amelyek perjelet is tartalmaznak (/usr/local/bin). Ebben az esetben az előre dőlt perjeleket fordított perjelekkel kell elválasztani:
Sed "s/\/usr\/local\/bin/\/common\/bin/"
Ezt "palisádnak" hívják, és nagyon csúnyán néz ki, és ami a legfontosabb, érthetetlen.
A sed különlegessége, hogy lehetővé teszi bármilyen határoló használatát, például az aláhúzást:
$ echo nap | sed s_day_night_ night
vagy kettőspont:
$ echo nap | sed s:day:night: night
Ha egy tetszőleges határolót keres, a "hiányos parancs `s" üzenetet kapja, akkor ez a karakter nem alkalmas határolónak, vagy egyszerűen elfelejtett egy-két határolót beírni.
Ebben a cikkben kénytelen vagyok a hagyományos elválasztót (/) használni, hogy ne zavarjam meg az olvasót, de ha szükséges, elválasztóként a tilde-t (~) használom.
(Reguláris kifejezések, reguláris kifejezés, RE)
A reguláris kifejezések témája annyira kiterjedt, hogy egész könyveket szentelnek neki (lásd a cikk végén található hivatkozásokat). Azonban a sed-ről komolyan beszélni reguláris kifejezések használata nélkül ugyanolyan terméketlen, mint a trigonometriáról beszélni számlálópálcákkal. Ezért beszélni kell legalább azokról a reguláris kifejezésekről, amelyeket gyakran használnak a sed programmal.
Val vel Vagy bármilyen más levél. A legtöbb betűt, számot és egyéb nem speciális karaktert a rendszer önmagukat reprezentáló reguláris kifejezésként kezeli.
* A karakter vagy reguláris kifejezés utáni csillag a karakter vagy reguláris kifejezés tetszőleges számú ismétlődését jelenti (beleértve a nullát is).
\+ Egy karakter vagy reguláris kifejezés egy vagy több ismétlését jelenti.
\? Azt jelenti, hogy nincs vagy egy ismétlés.
\(én\) Pontosan i ismétlést jelent.
\(i,j\) Az ismétlések száma i-től j-ig terjedő tartományban van.
\(én,\) Az ismétlések száma nagyobb vagy egyenlő, mint i.
\(,j\) Az ismétlések száma kisebb vagy egyenlő, mint j.
\(ÚJRA\) Emlékezzen a reguláris kifejezésre vagy annak egy részére a további felhasználás céljából. Például az \(a-z\)* bármilyen kisbetűs szám (beleértve a nullát is) bármilyen kombinációjával megegyezik.
. Bármely karaktert jelent, beleértve az újsor karaktert is.
^ A karakterlánc elején lévő null kifejezést jelenti. Más szóval, amit ez a karakter előz meg, annak a sor elején kell szerepelnie. Például az ^#include az #include karakterrel kezdődő sorokat keresi.
$ Ugyanaz, mint fent, csak a sor végére vonatkozik.
[LISTA] A LIST bármely karakterét jelenti. Például bármilyen angol magánhangzót keres.
[^LIST] Bármely karaktert jelent, kivéve a listán szereplőket. Például [^aeiou] bármilyen mássalhangzót keres. Megjegyzés: A LIST lehet intervallum, például [a-z], ami bármilyen kisbetűt jelent. Ha egy ]-t (szögletes zárójelet) szeretne felvenni a LIST-be, tegye a lista első helyére; ha a - (kötőjelet) szeretné szerepeltetni a LISTÁBAN, akkor először vagy utolsóként adja meg a listában.
RE1\|RE2 Azt jelenti, hogy PB1 vagy PB2.
RE1RE2 A PB1 és PB2 reguláris kifejezések egyesülését jelenti.
\nÚjsor karaktert jelöl.
\$; \*; \.; \[; \\; \^ Ezek rendre azt jelentik: $; *; .; [; \; ^
Figyelem: Pihenés egyezmények a C nyelvben elfogadott fordított perjel (\) alapján nem támogatja a sed program.
\1 \2 \3 \4 \5 \6 \7 \8 \9 A reguláris kifejezés egyező részét jelenti, a \(és \) használatával tárolva.
Néhány példa:
abcdef Azt jelenti, hogy abcdef
a*b Nullát vagy tetszőleges számú a és egy b betűt jelent. Például aaaaaab; ab; vagy b.
a\?b Jelentése b vagy ab
a\+b\+ jelentése egy vagy több levelet a és egy vagy több b. Például: ab; aaaab; abbbbbb; vagy aaaaabbbbbb.
.* A sorban lévő összes karaktert jelenti, minden sorban, beleértve az üreseket is.
.\+ Egy karakterlánc összes karakterét jelenti, de csak a legalább egy karaktert tartalmazó karakterláncokon. Az üres sorok nem egyeznek a megadott reguláris kifejezéssel.
^fő.*(.*) Megkeresi a main szóval kezdődő sorokat, valamint azokat, amelyek nyitó és záró zárójelet tartalmaznak, és tetszőleges számú karakter lehet a nyitó zárójel előtt és után.
^# Megkeresi a # jellel kezdődő sorokat (például megjegyzéseket).
\\$ A fordított perjelre (\) végződő sorokat keresi.
Bármilyen betű vagy szám
[^ ]\+ (A szögletes zárójel a ^ karakteren kívül szóközt és tabulátort is tartalmaz) -- Egy vagy tetszőleges számú karaktert jelent, kivéve a szóközt és a tabulátort. Általában szót jelent.
^.*A.*$ Eszközök nagybetű Pont a sor közepén.
A.\(9\)$ Egy nagy A betűt jelöl, pontosan a tizedik része a sor végétől.
^.\(,15\)A Nagy A betűt jelent, pontosan a tizenhatodik a sor elejétől.
Most, hogy láttunk néhány reguláris kifejezést, térjünk vissza a sed parancsához.
A & használatával, amikor a PATTERN ismeretlen „Hogyan van ez ismeretlen?”, akkor megkérdezi: „Nem tudja, mit szeretne lecserélni?” Válasz: A szövegben található számokat zárójelbe szeretném tenni. Hogyan kell csinálni? Válasz: használja a & szimbólumot.
Az & (és) karakter, ha a REPLACEMENT-ben van elhelyezve, a szövegben található bármely MINTÁT jelent. Például:
$ echo 1234 | sed "s/*/(&)/" (1234)
Az intervallum után egy csillag (csillag) szükséges a mintában található összes számjegy helyettesítéséhez. Anélkül ez lenne:
$ echo 1234 | sed "s//(&)/" (1)234
Vagyis az első talált számjegyet vettük mintának.
Íme egy példa egy teljesen értelmes betöltésre: hozzunk létre egy formula.txt fájlt:
A+432-10=n
és alkalmazd rá a parancsot:
$ sed "s/*-*/(&)/" formula.txt a+(432-10)=n
A matematikai képlet egyértelmű jelentést kapott.
Egy másik "és" karakter is használható a MINTÁZAT megduplázására:
$ echo 123 | sed "s/*/& &/" 123 123
Van itt egy finomság. Ha egy kicsit bonyolítjuk a példát:
$ echo "123 abc" | sed "s/*/& &/" 123 123 abc
ahogy az várható volt, csak a számok duplázódnak, mivel a PATTERN-ben nincsenek betűk. De ha felcseréljük a szövegrészeket:
$ echo "abc 123" | sed "s/*/& &/" abc 123
akkor a számok megkettőzése nem fog működni. Ez a * reguláris kifejezés jellemzője – csak a karakterlánc első karakterével egyezik. Ha meg akarjuk duplázni a számjegyeket, bárhol is legyenek, módosítanunk kell a REPLACE reguláris kifejezést:
$ echo "abc defg 123" | sed "s/*/& &/" abc defg 123 123
akkor a számjegyek megduplázódnak, függetlenül a megelőző "szavak" számától.
A \(, \) és \1 escape karakterek használata a PATTERN rész kezelésére A \( és \) escape karakterek (megtisztított zárójelek) a reguláris kifejezés részeinek emlékezésére szolgálnak.
A \1 szimbólum az első megjegyzett részt jelenti, a \2 a második, és így tovább, legfeljebb kilenc megjegyzett részt ( több program nem támogatja). Vegyünk egy példát:
$ echo abcd123 | sed "s/\(*\).*/\1/" abcd
Itt a \(*\) azt jelenti, hogy a programnak bármilyen mennyiségben meg kell emlékeznie az összes alfabetikus karakterre; .* jelentése tetszőleges számú karakter az első megjegyzett rész után; és a \1 azt jelenti, hogy csak az első memorizált részt akarjuk látni. Így is van: a program kimenetében csak betűket látunk, számokat nem.
A szavak felcseréléséhez meg kell jegyeznie két alMINTÁT, majd fel kell cserélnie őket:
$ echo hülye pingvin |sed "s/\([a-z]*\) \([a-z]*\)/\2 \1/" hülye pingvin
Itt a \2 a második almintát, a \1 pedig az elsőt jelenti. Figyelje meg az első \([a-z]*\) és a második \([a-z]*\) kifejezés közötti távolságot. Két szót kell találni.
A \1 jelnek nem kell csak a REPLACEMENT-ben lennie, hanem jelen lehet a PATTERN-ben is, például ha a duplikált szavakat szeretnénk eltávolítani:
$ echo pingvin pingvin | sed "s/\([a-z]*\) \1/\1/" pingvin
A cseremódosítók az utolsó határoló után kerülnek elhelyezésre. Ezek a módosítók határozzák meg, hogy a program mit fog tenni, ha egy karakterláncban egynél több PATTERN egyezés található, és hogyan cserélje le.
/g módosító
Globális csere
A sed program, mint a legtöbb Unix segédprogram, egy sort olvas be, amikor fájlokkal dolgozik. Ha egy szó cseréjét rendeljük el, akkor a program csak az első egyező szót cseréli le az adott sorban. Ha meg akarunk változtatni minden szót, ami megfelel a mintának, akkor a /g módosítót kell beírni.
/g módosító nélkül:
$ echo ez a macska volt a leggyakoribb macska | sed "s / macska / cica /" ez a cica volt a legközönségesebb macska
A szerkesztő csak az első egyező szót cserélte ki.
És most a globális helyettesítő módosítóval:
$ echo ez a macska volt a leggyakoribb macska | sed "s/cat/kitten/g" ez a cica volt a leggyakoribb cica
A megadott karakterláncban szereplő összes találat le lett cserélve.
És ha meg kell változtatni az összes szót, mondjuk, tegye zárójelbe? Ezután ismét a reguláris kifejezések jönnek a segítségre. Az összes alfabetikus karakter kiválasztásához használhatja az [A-Zaa-z] konstrukciót, de az olyan szavak, mint a „valami” vagy a „valamivel” nem fognak beletartozni. Sokkal kényelmesebb a szerkezet [ ^ ]*, amely a szóköz kivételével minden karakterrel megegyezik, tehát:
$ visszhang hülye pingvin félénken elbújik | sed "s/[^ ]*/(&)/g" (buta) (pingvin) (félénken) (bújik)
Hogyan válasszuk ki a kívánt egyezést több közül
Ha nem alkalmazunk módosítókat, a sed csak a PATTERN-nek megfelelő első szót cseréli le. Ha alkalmazza a /g módosítót, a program minden egyező szót lecserél. És hogyan lehet kiválasztani egy egyezést, ha több is van egy vonalon? - A számunkra már ismert \ (és \) szimbólumok segítségével emlékezzen az alMINTÁKRA, és válassza ki a kívántat a \ 1 - \ 9 szimbólumok segítségével.
$ visszhang hülye pingvin | sed "s/\([a-z]*\) \([a-z]*\)/\2 /" pingvin
Ebben a példában mindkét szót megjegyeztük, és a másodikat (pingvin) az első helyre helyezve töröltük az elsőt (hülye) úgy, hogy szóközt tettünk a CSERE részben. Ha szóköz helyett tetszőleges szót teszünk, akkor ez lecseréli az elsőt (hülye):
$ visszhang hülye pingvin | sed "s/\([a-z]*\) \([a-z]*\)/\2 smart /" penguin smart
Numerikus módosító
Ez egy egy/két/háromjegyű szám, amely az utolsó határoló után jön, és jelzi, hogy melyik egyezést kell cserélni.
$ echo nagyon hülye pingvin | sed "s/[a-z]*/good/2" nagyon jó pingvin
Ebben a példában minden szó egyezést jelent, és a CSERE rész után 2-es módosítóval közöltük a szerkesztővel, hogy melyik szót szeretnénk lecserélni.
A digitális módosítót kombinálhatja a /g módosítóval. Ha az első szót változatlanul kell hagynia, és a második és az azt követő szavakat a "(törölt)" szóra kell cserélnie, akkor a parancs a következő lesz:
$ echo nagyon hülye pingvin | sed "s/[a-z]*/(törölt)/2g" nagyon (törölt) (törölt)
Ha valóban el szeretné távolítani az összes következő egyezést, kivéve az elsőt, akkor tegyen szóközt a CSERE részben:
$ echo nagyon hülye pingvin | sed "s/[a-z]*/ /2g" nagyon
Vagy ne csinálj semmit:
$ echo nagyon hülye pingvin | sed "s/[^ ]*//2g" nagyon
A numerikus módosító tetszőleges egész szám lehet 1-től 512-ig. Például, ha az egyes sorok 80. karaktere után kettőspontot kell tenni, akkor a parancs segít:
$ sed "s/./&:/80" fájlnévvel
Módosító /p - kimenet szabványos kimenetre (nyomtatás - nyomtatás)
A sed program alapértelmezés szerint az eredményt a szabványos kimenetre (például a monitor képernyőjére) adja ki. Ez a módosító csak a sed -n kapcsolóval használható, amely csak blokkolja az eredmény kimenetét a képernyőn.
/w módosító
Lehetővé teszi a szövegfeldolgozás eredményeinek a megadott fájlba írását:
$ sed "s /PATTERN/REPLACE /w fájlnév
/e módosító (GNU kiterjesztés)
Lehetővé teszi egy shell parancs (nem a sed program) megadását REPLACEMENT-ként. Ha a PATTERN egyezést talál, akkor azt a CSERE szakaszban megadott parancs kimenete váltja fel. Példa:
$ visszhang éjszaka | sed "s/night/echo day/e" day
/I és /i módosítók (GNU kiterjesztés)
Tegye a csere folyamatát a kis- és nagybetűk megkülönböztetésére.
$echo Night | sed "s/éj/nap/i" nap
Módosító kombinációk
A módosítók kombinálhatók, ha van értelme. Ebben az esetben a w módosítót utoljára kell elhelyezni.
Konvenciók (GNU kiterjesztés) Csak öt van belőlük:
\L a REPLACEMENT karaktereket kisbetűssé alakítja \l a következő REPLACE karaktert kisbetűvé alakítja \U a REPLACEMENT karaktereket nagybetűssé alakítja \u a következő REPLACE karaktert nagybetűssé alakítja \E megszakítja a \L vagy \U által indított fordítást. Nyilvánvaló okokból ezek a konvenciók önmagukban használatosak. Például:
$ visszhang hülye pingvin | sed "s/stupid/\u&/" Hülye pingvin
$ visszhang kiskutya | sed "s/[a-z]*/\u&/2" kiskutya
A sed parancsának szinte minden vonatkozásával foglalkoztunk. Most itt a sor, hogy mérlegeljük a program lehetőségeit.
A program meglepően kevés lehetőséget tartalmaz. (Ami némileg kompenzálja a parancsok, módosítók és egyéb funkciók túlsúlyát). A jól ismert --help (-h) és --version (-V) opciókon kívül, amelyeket nem fogunk figyelembe venni, csak három van belőlük:
Opció -e--expression=parancskészlet
Több parancs futtatásának egyik módja az -e kapcsoló használata. Például:
Sed -e "s/a/A/" -e "s/b/B/" fájlnév
A cikkben szereplő összes korábbi példa nem igényelte az -e kapcsolót csak azért, mert egyetlen parancsot tartalmazott. A példákba beletehetnénk az -e opciót, az nem változtatna semmit.
Opció -f Ha sok parancsot kell végrehajtania, kényelmesebb, ha fájlba írja őket, és használja az -f kapcsolót:
sed -f sedscript fájlnév
A Sedscript itt a parancsokat tartalmazó fájl neve. Ezt a fájlt sed program szkriptnek (a továbbiakban egyszerűen script) nevezik. Minden script parancsnak külön sort kell foglalnia. Például:
# megjegyzés – Ez a szkript minden kisbetűs magánhangzót nagybetűre cserél s/a/A/g s/e/E/g s/i/I/g s/o/O/g s/u/U/g
A szkriptet tetszés szerint nevezheti el, fontos, hogy ne keverje össze a szkriptfájlt a feldolgozás alatt álló fájllal.
Opció -n A sed -n program nem ad ki semmit a szabványos kimenetre. A kimenet megszerzéséhez speciális utasításra van szüksége. Láttuk már a /p módosítót, amivel ilyen jelzést lehet adni. Emlékezzünk a zar.txt fájlra:
$ sed "s/1-9/&/p" zar.txt Reggel elvégezte a gyakorlatait. A villám elektromos töltés.
Mivel nem találtunk egyezést a PATTERN-nel (nincs szám a fájlban), az s parancs a /p módosítóval és a & jellel CSERE (ne feledje, hogy az és jel magát a MINTÁT jelenti) úgy működik, mint a cat parancs.
Ha a fájlban PATTERN található, akkor a PATTERN-t tartalmazó sorok megduplázódnak:
$ sed "s/exercises/&/p" zar.txt Reggelente gyakorlatokat végzett. Reggelente gyakorlatokat végzett. A villám elektromos töltés.
Most adjuk hozzá az -n opciót:
$ sed -n "s/charge/&/p" zar.txt Reggel elvégezte a gyakorlatait.
A programunk most úgy működik, mint egy grep parancs – csak a PATTERN-t tartalmazó sorokat adja vissza.
Egyetlen paranccsal, s, láthattuk a sed szerkesztő elképesztő erejét. De ez nem más, mint a keresés és a csere. Sőt, a munka során a sed egyesével szerkeszti az egyes sorokat, nem figyelve másokra. Kényelmes lenne korlátozni a módosítandó sorok tartományát, például:
A sed program mindezt és még sok mást is megtesz. Bármely sed szerkesztő parancs alkalmazható címenként, egy címtartományra, vagy a fenti sortartomány-korlátozásokkal. A címnek vagy megszorításnak közvetlenül a parancs előtt kell lennie:
Sed "cím/korlát parancs"
Válassza ki a sorokat számok alapján
Ez a legegyszerűbb eset. Csak adja meg a kívánt sor számát a parancs előtt:
$ sed "4 s/[a-z]*//i" gumilev.txt Milyen különös boldogság A hajnali szürkületben, Tavaszi hó olvadásában, mindennek, ami elvész és bölcs.
$ sed "3 s/B/(B)/" gumilev.txt Milyen különös boldogság A hajnali kora alkonyatban, (Ben) tavaszi hó olvadásában, Mindenben, ami elvész és bölcs.
Sorok kiválasztása számtartományban
A tartományt nem meglepő módon vesszővel választjuk el:
$ sed "2.3 s/B/(B)/" gumilev.txt Micsoda különös boldogság (Ben) a hajnali szürkület, (Ben) tavaszi hó olvadása, Mindenben, ami elvész és bölcs.
Ha egy tartományt kell megadnia a fájl utolsó soráig, és nem tudja, hány sort tartalmaz, akkor használja a $ jelet:
$ sed "2,$ s/in/(in)/i" gumilev.txt Milyen különös boldogság (benne) a hajnali szürkületben, (ben) a tavaszi hó olvadása, (benne) minden, ami elpusztul és van bölcs.
Kifejezést tartalmazó sorok kiválasztása
A keresési kifejezés perjelekbe (/) kerül, és a parancs elé kerül:
$ sed "/morning/ s/in/(in)/i" gumilev.txt Milyen különös boldogság (benne) a hajnali szürkületben, Tavaszi hó olvadásában, Mindenben, ami elvész és bölcs.
Sorok kijelölése két kifejezés közötti tartományban
A sorszámokhoz hasonlóan a tartományt vesszővel elválasztva adjuk meg:
$ sed "/reggel/,/wise/ s/in/(in)/i" gumilev.txt Milyen különös boldogság (ben) a hajnali kora szürkületben, (ben) a tavaszi hó olvadása, (ben) minden ami elvész és bölcs .
Sorok kijelölése egy fájl elejétől valamilyen kifejezésig
$ sed "1,/snow/ s/in/(in)/i" gumilev.txt Milyen különös boldogság (benne) a hajnali kora alkonyatban, (ben) a tavaszi hó olvadásában, Mindenben, ami elvész és van bölcs.
Sorok kijelölése valamelyik kifejezéstől a fájl végéig
$ sed "/snow/,$ s/in/(in)/i" gumilev.txt Milyen különös boldogság A hajnali kora szürkületben, (ben) a tavaszi hó olvadása, (benne) minden, ami elpusztul és van bölcs.
d parancs (törlés)
Eltávolítja a megadott sorokat a szabványos kimenetből:
$ sed "2 d" gumilev.txt Milyen különös boldogság Tavaszi hó olvadásában, Mindenben, ami elvész és bölcs.
És gyakrabban írnak könnyebben (szóköz nélkül):
Sed "2d" gumilev.txt
Minden, amit az előző részben a sorcímzésről elmondtunk, a d parancsra vonatkozik (ahogy szinte minden sed szerkesztő parancsra).
A d paranccsal célszerű kidobni néhány levél felesleges "fejlécét":
$ sed "1,/^$/ d" fájlnév
(Sorok törlése az elsőtől az első üres sorig).
Szabadulj meg a megjegyzésektől konfigurációs fájl:
$ sed "/^#/d" /boot/grub/menu.lst
És soha nem tudhatod, hol kell eltávolítani a felesleges vonalakat!
p parancs (nyomtatás)
Az angol "print" szót "nyomtatásnak" fordítják, amely oroszul nyomtatóhoz vagy legalábbis billentyűzethez kapcsolódik. Valójában az angol szövegkörnyezetben ez a szó gyakran azt jelenti, hogy egyszerűen a monitor képernyőjén jelenik meg. Tehát a p parancs nem ír ki semmit, csak a megadott sorokat írja ki a képernyőre.
Önmagában használva a p parancs megduplázza a sorokat a kimenetben (mivel a sed program alapértelmezés szerint egy sort nyomtat a képernyőre, a p parancs pedig másodszor is kiírja ugyanazt a sort).
$ echo van egy macskám | sed "p" van egy macskám van egy macskám
Ez a tulajdonság például az üres sorok megkettőzésére használható a szöveg megjelenésének javítása érdekében:
$ sed "/^$/ p fájlnév
De a p parancs felfedi valódi arcát az -n kapcsolóval kombinálva, amely, mint emlékszel, megtiltja a sorok képernyőre való kiírását. Az -n kapcsolót a p paranccsal kombinálva csak a szükséges sorokat kaphatja meg a kimenetben.
Például nézze meg az egytől tízig terjedő sort:
$ sed -n "1,10 p" fájlnév
Vagy csak kommentek:
$ sed -n "/^#/ p" /boot/grub/menu.lst # GRUB konfigurációs fájl "/boot/grub/menu.lst". # generálta a "grubconfig". V. 2008. március 23. 21:45:41 # # GRUB globális szekció indítása # GRUB globális szakasz vége # Linux rendszerindító partíció konfigurációja kezdődik # Linux rendszerindító partíció konfigurációja véget ér # Linux rendszerindító partíció konfigurációja kezdődik # Linux rendszerindító partíció konfigurációja véget ér
Ami nagyon hasonlít a grep-re, amellyel már akkor találkoztunk, amikor az -n opcióról beszéltünk a /p módosítóval. De a grep paranccsal ellentétben a sed szerkesztő lehetővé teszi, hogy ne csak megtalálja ezeket a sorokat, hanem módosítsa is őket, például minden Linuxot lecserélve Unixra:
$ sed -n "/^#/p" /boot/grub/menu.lst | sed "s/Linux/Unix/" # GRUB konfigurációs fájl "/boot/grub/menu.lst". # generálta a "grubconfig". V. 2008. március 23. 21:45:41 # # GRUB globális szakasz indítása # GRUB globális szakasz vége # Unix rendszerindító partíció konfigurációja kezdődik # Unix rendszerindító partíció konfigurációja véget ér # Unix rendszerindító partíció konfigurációja kezdődik # Unix rendszerindító partíció konfigurációja véget ér
Csapat!
Néha az összes sort szerkesztenie kell, kivéve azokat, amelyek megfelelnek a PATTERN-nek vagy egy kijelölésnek. Szimbólum felkiáltójel(!) megfordítja a kijelölést. Például töröljük ki az összes sort, kivéve a másodikat Gumiljov négysorából:
$ sed "2 !d" gumilev.txt A hajnali szürkületben,
Vagy jelölje ki az összes sort, kivéve a megjegyzéseket a /boot/grub/menu.lst fájlból:
$ sed -n "/^#/ !p" /boot/grub/menu.lst alapértelmezett 1 időtúllépés 20 gfxmenu (hd0,3)/boot/message title SuSe on (/dev/hda3) root (hd0,2) kernel /boot/vmlinuz root=/dev/hda3 ro vga=773 acpi=off title Linux on (/dev/hda4) root (hd0,3) kernel /boot/vmlinuz root=/dev/hda4 ro vga=0x317
q parancs (kilépés)
A q parancs leállítja a sed programot a megadott sor után. Ez akkor hasznos, ha le szeretné állítani a szerkesztést, miután elért egy bizonyos pontot a szövegben:
$ sed "11 q" fájlnév
Ez a parancs a 11. sor elérésekor fejezi be a munkát.
A q parancs azon kevés sed parancsok egyike, amelyek nem fogadnak el sortartományokat. A csapat nem hagyhatja abba a munkát 10-szer egymás után, ha beírjuk:
Sed "1.10 q" Abszurd!
w (írási) parancs
Az s parancs w módosítójához hasonlóan ez a parancs lehetővé teszi a program kimenetének fájlba írását:
$ sed -n "3,$w gum.txt" gumilev.txt
A gumilev.txt fájlból megkapjuk a Gumilev-négysor utolsó két sorát tartalmazó gum.txt fájlt. Sőt, ha már létezik ilyen fájl, akkor felülírja. Ha nem adjuk meg az -n opciót, akkor a program a gum.txt fájl létrehozása mellett a gumilev.txt fájl teljes tartalmát is megjeleníti a képernyőn.
Bedolgozni parancs sor, kényelmesebb a normál kimeneti átirányítást (> vagy >>) használni, de a sed szkriptekben a w parancs valószínűleg megtalálja a használatát.
r parancs (olvasás)
Ez a parancs nem csak a megadott fájlt olvassa be, hanem annak tartalmát is beszúrja a kívánt helyre a szerkesztett fájlban. A "szükséges hely" kijelölése már ismerős számunkra (sorszámok, kifejezések stb. alapján). Példa:
$ visszhang Gumilev verséből: | sed "rgumilev.txt"
Gumiljov verséből:
Milyen különös boldogság A hajnali szürkületben, A tavaszi hó olvadásában, Mindenben, ami elvész és bölcs.
Parancs =
Megadja a megadott sor számát:
$ sed "/snow/=" gumilev.txt Milyen különös boldogság A hajnali szürkületben, 3 A tavaszi hó olvadásában, Mindenben, ami elvész és bölcs.
$ sed -n "/snow/=" gumilev.txt 3
A parancs csak egy címet fogad el, intervallumokat nem.
Csapat y
Ez a parancs lecseréli a PATTERN szakasz karaktereit a REPLACE részben lévő karakterekre, programként működik tr.
$ echo Autó - a múlt öröksége | sed "y/Auto/Paro/" Paromobile – a múlt öröksége
Csapat y csak akkor működik, ha a PATTERN karakterek száma megegyezik a REPLACE karakterek számával.
A sed teljes szövegszerkesztőként való használatához meg kell tanulnia sed szkriptek írását. A sed programnak saját egyszerű programozási nyelve van, amely lehetővé teszi olyan szkriptek írását, amelyek csodákra képesek.
Ez a cikk nem tartalmazhatja a sed szkriptek leírását, és a szerzője sem a sed programozási nyelv elsajátítását tűzte ki maga elé. Ebben a cikkben a sed szerkesztő parancssori használatára összpontosítottam, különös tekintettel a csövek szűrőjeként való használatára. Emiatt számos sed parancsot kihagytam, amelyeket csak a szkriptjei használnak.
Sok rajongója van a sed szerkesztőnek, és sok cikk található a szkriptek témájában, beleértve a Runetet is. Így azoknak, akiket érdekel ez a csodálatos program, nem lesz nehéz tudásukat feltölteni.
Amint a cikkben szereplő példákból látható, a sed program egy megfelelően oroszosított rendszeren folyékonyan beszéli a "nagy és hatalmas" nyelvet.
A sed program egy többfunkciós adatfolyam-szerkesztő, amely nélkülözhetetlen:
Hetekig vagy akár hónapokig tart a sed program teljes elsajátítása, mivel ehhez:
Másrészt a leggyakoribb sed parancsok közül néhány olyan könnyen elsajátítható, mint bármely Unix parancs; Remélem, ez a cikk segít ebben.
Eddig a HuMan sorozat cikkeiben igyekeztem legalább röviden felfedni a leírt parancs minden opcióját, minden paraméterét, hogy a cikk lecserélhesse a manát. A jövőben is ragaszkodom ehhez az elvhez.
Ez a cikk kivétel, mivel nem írja le a program összes funkcióját. Teljes leírásukhoz nem cikkre, hanem könyvre lenne szükség. A cikk azonban lehetővé teszi, hogy képet kapjon a sed szerkesztőről, és elkezdje használni ezt a csodálatos programot a leggyakoribb parancsok segítségével.
