Isa sa mga bagay na lagi kong minahal tungkol sa terminal ng Linux ay kung ano ang maaari mong makamit gamit ang mga regular na expression. Kung kailangan ba nating maghanap ng kumplikadong teksto o palitan ito ng iba pa, ang paggamit ng regular na mga expression ay maaaring gawing simple ang trabaho. Hinahayaan nating magsimula sa simula:
Ano ang isang regular na pagpapahayag?
Ang isang regular na expression ay isang serye ng mga espesyal na character na nagbibigay-daan sa amin upang ilarawan ang isang teksto na nais naming hanapin. Halimbawa, kung nais naming maghanap para sa salitang "linux" sapat na upang mailagay ang salitang iyon sa program na ginagamit namin. Ang salitang mismong ito ay isang regular na pagpapahayag. Sa ngayon ito ay tila napaka-simple, ngunit paano kung nais nating hanapin ang lahat ng mga numero sa isang tiyak na file? O lahat ng mga linya na nagsisimula sa isang malaking titik? Sa mga kasong iyon hindi ka na makakapaglagay ng isang simpleng salita. Ang solusyon ay ang paggamit ng isang regular na pagpapahayag.
Mga regular na expression kumpara sa mga pattern ng file.
Bago kami makapunta sa mga regular na expression, nais kong limasin ang isang karaniwang hindi pagkakaunawaan tungkol sa mga regular na expression. Ang isang regular na expression ay hindi kung ano ang inilalagay namin bilang isang parameter sa mga utos tulad ng rm, cp, atbp upang mag-refer sa iba't ibang mga file sa hard drive. Iyon ay magiging isang pattern ng file. Ang mga regular na expression, bagaman magkatulad sa paggamit ng ilang mga karaniwang character, ay magkakaiba. Ang isang pattern ng file ay pinaputok laban sa mga file sa hard disk at ibabalik ang mga ganap na tumutugma sa pattern, habang ang isang regular na expression ay pinaputok laban sa isang teksto at ibabalik ang mga linya na naglalaman ng hinahanap na teksto. Halimbawa, ang regular na expression na naaayon sa pattern *.* ito ay magiging isang bagay tulad ng ^.*\..*$
Mga uri ng regular na expression.
Hindi lahat ng mga programa ay gumagamit ng parehong regular na mga expression. Hindi gaanong kulang. Mayroong maraming mga uri ng higit pa o mas mababa karaniwang mga regular na expression, ngunit may mga programa na binabago nang bahagya ang syntax, nagsasama ng kanilang sariling mga extension, o kahit na gumagamit ng ganap na magkakaibang mga character. Samakatuwid, kapag nais mong gumamit ng mga regular na expression sa isang programa na hindi mo alam na alam, ang unang bagay ay tingnan ang manu-manong o ang dokumentasyon ng programa upang makita kung ano ang mga regular na expression na kinikilala nito.
Una, mayroong dalawang pangunahing uri ng regular na mga expression, na nilalaman sa pamantayan ng POSIX, na ginagamit ng mga tool sa Linux. Ang mga ito ang pangunahing at pinalawak na regular na mga expression. Marami sa mga utos na gumagana sa mga regular na expression, tulad ng grep o sed, ay nagbibigay-daan sa iyo upang magamit ang dalawang uri na ito. Pag-uusapan ko ang tungkol sa kanila sa ibaba. Mayroon ding mga regular na expression ng istilong PERL, at pagkatapos ay may mga programa tulad ng vim o emacs na gumagamit ng mga pagkakaiba-iba ng mga ito. Nakasalalay sa kung ano ang nais naming gawin, maaaring mas angkop na gumamit ng isa o iba pa.
Pagsubok ng mga regular na expression.
Ang syntax ng mga regular na expression ay hindi gaanong mahalaga. Kapag kailangan nating magsulat ng isang kumplikadong regular na pagpapahayag nasa harap kami ng isang string ng mga espesyal na character na imposibleng maunawaan sa unang tingin, kaya upang malaman kung paano gamitin ang mga ito mahalaga na magkaroon ng isang paraan upang magawa ang lahat ng mga pagsubok na nais at makita. madali ang mga resulta. Iyon ang dahilan kung bakit maglalagay ako ngayon ng maraming mga utos na kung saan maaari nating gawin ang mga pagsubok at eksperimento sa lahat ng kailangan natin hanggang sa masolo natin ang regular na mga expression.
Ang una ay ang utos ng grep. Ito ang utos na gagamitin namin nang madalas upang maghanap. Ang syntax ay ang mga sumusunod:
grep [-E] 'REGEX' FICHERO
COMANDO | grep [-E] 'REGEX'
Inirerekumenda kong palaging maglagay ng regular na mga expression sa iisang mga quote upang ang shell ay hindi makarating sa amin dito. Ang unang paraan ay upang makahanap ng isang regular na expression sa isang file. Pinapayagan ng pangalawa ang pag-filter ng output ng isang utos sa pamamagitan ng isang regular na pagpapahayag. Bilang default, gumagamit ang grep ng pangunahing mga regular na expression. Ang pagpipiliang -E ay para sa paggamit ng pinalawig na regular na mga expression.
Isang trick na makakatulong sa amin na makita kung paano gumagana ang regular na mga expression upang paganahin ang paggamit ng kulay sa utos ng grep. Sa ganoong paraan, maii-highlight ang bahagi ng teksto na tumutugma sa regular na expression na ginagamit namin. Upang buhayin ang kulay sa utos ng grep, siguraduhin lamang na ang variable ng kapaligiran GREP_OPTIONS naglalaman ng halaga --color, na maaaring magawa sa utos na ito:
GREP_OPTIONS=--color
Maaari nating ilagay ito sa .bashrc upang palaging ito ay buhayin.
Ang isa pang paraan upang magamit ang mga regular na expression ay sa pamamagitan ng paggamit ng sed command. Ito ay mas angkop para sa pagpapalit ng teksto, ngunit maaari ring magamit para sa paghahanap. Ang syntax para dito ay magiging ganito:
sed -n[r] '/REGEX/p' FICHERO
COMANDO | sed -n[r] '/REGEX/p'
Gumagamit din ang sed command ng pangunahing mga regular na expression bilang default, maaari mong gamitin ang pinalawig na regular na mga expression na may pagpipiliang -r.
Ang isa pang utos na nais ko ring pangalanan ay awk. Ang utos na ito ay maaaring magamit para sa maraming mga bagay, dahil pinapayagan kang magsulat ng mga script sa iyong sariling wika sa pagprograma. Kung ang nais namin ay maghanap ng isang regular na expression sa isang file o sa output ng isang utos, ang paraan upang magamit ito ay ang mga sumusunod:
awk '/REGEX/' FICHERO
COMANDO | awk '/REGEX/'
Palaging gumagamit ng utos na regular na expression ang utos na ito.
Upang magawa ang aming mga pagsubok kakailanganin din namin ang isang teksto na magsisilbing isang halimbawa upang maghanap ito. Maaari naming gamitin ang sumusunod na teksto:
- Lista de páginas wiki: ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ - Fechas de lanzamiento: Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004 Desde Linux Rulez.
Ito ang teksto na gagamitin ko para sa mga halimbawa ng natitirang post, kaya inirerekumenda kong kopyahin mo ito sa isang file upang magamit ito mula sa terminal. Maaari mong ilagay ang pangalang nais mo. Tinawag ko itong regex.
Panimulang aralin.
Ngayon mayroon kaming lahat na kailangan mo upang simulan ang pagsubok ng mga regular na expression. Unti unti na tayo. Maglalagay ako ng maraming mga halimbawa ng mga paghahanap na may regular na mga expression kung saan ko ipapaliwanag kung para saan ang bawat character. Hindi sila masyadong mabuting mga halimbawa, ngunit dahil magkakaroon ako ng napakahabang post, hindi ko na nais na komplikahin ito. At kukunin ko na lamang ang simula ng kung ano ang maaaring gawin sa mga regular na expression.
Ang pinakasimpleng sa lahat ay maghanap para sa isang tukoy na salita, halimbawa, ipagpalagay na nais naming maghanap para sa lahat ng mga linya na naglalaman ng salitang "Linux". Ito ang pinakamadali, dahil kailangan lamang naming magsulat:
grep 'Linux' regex
At maaari nating makita ang resulta:
ArkoLinux: https://wiki.archlinux.org/ Arch Linux: 11-03-2002 Mula sa Linux Rulez.
Ito ang tatlong mga linya na naglalaman ng salitang "Linux" kung saan, kung ginamit namin ang color trick, lilitaw na naka-highlight. Tandaan na kinikilala nito ang salitang hinahanap natin kahit na bahagi ito ng mas mahabang salita tulad ng sa "ArchLinux". Gayunpaman, hindi ito naka-highlight ng salitang "linux" na lilitaw sa URL na "https://wiki.archlinux.org/". Iyon ay dahil lumilitaw doon na may maliit na "l" at hinanap namin ito sa malalaki. Ang utos ng grep ay may mga pagpipilian para dito, ngunit hindi ko pag-uusapan ang tungkol sa mga ito sa isang artikulong pagharap sa mga regular na expression.
Sa simpleng pagsubok na ito maaari nating makuha ang unang konklusyon:
- Ang isang normal na character na inilalagay sa isang regular na expression ay tumutugma sa sarili nito.
Alin ang sasabihin na kung inilagay mo ang titik na "a" hahanapin nito ang letrang "a". Parang lohikal naman di ba? 🙂
Ngayon ipagpalagay na nais naming maghanap para sa salitang "CentO" na sinusundan ng anumang character, ngunit isang solong character lamang. Para dito maaari naming gamitin ang "." Character, na isang wildcard na tumutugma sa anumang character, ngunit isa lamang:
grep 'CentO.' regex
At ang resulta ay:
CentOS: http://wiki.centos.org/ Mga CentO: 14-05-2004 03:32:38
Na nangangahulugang kasama nito ang "S" sa "CentOS" bagaman sa isang kaso ito ay malaki at sa isa pang maliit na maliit na titik. Kung may ibang character na lumitaw sa lugar na iyon, isasama rin ito. Mayroon na kaming pangalawang panuntunan:
- Ang tauhang "." tumutugma sa anumang character.
Ito ay hindi na gaanong mahalaga tulad ng tila, ngunit sa ito hindi tayo magagawa ng marami. Malayo pa tayo. Ipagpalagay natin na nais nating hanapin ang mga linya kung saan lumilitaw ang taong 2002 at 2004. Para silang dalawang paghahanap, ngunit maaari silang magawa nang sabay-sabay tulad nito:
grep '200[24]' regex
Na nangangahulugang nais naming hanapin ang bilang 200 na sinusundan ng 2 o 4. At ang resulta ay ito:
ArchLinux: 11-03-2002 Gentoo: 31/03 /2002 Mga CentO: 14-05-2004 03:32:38 Ubuntu: 20/10/2004
Na nagdadala sa amin sa pangatlong panuntunan:
- Ang mga maramihang mga character na nakapaloob sa mga braket ay tumutugma sa anuman sa mga character sa loob ng mga braket.
Ang mga braket ay nagbibigay ng higit na pag-play. maaari din silang magamit upang maibukod ang mga character. Halimbawa, ipagpalagay na nais naming maghanap para sa mga site kung saan lilitaw ang character na ":", ngunit hindi sinusundan ng "/". Ang utos ay magiging ganito:
grep ':[^/]' regex
Ito ay simpleng isang bagay lamang ng paglalagay ng isang "^" bilang unang character sa loob ng bracket. Maaari mong ilagay ang lahat ng mga character na gusto mo sa ibaba. Ang resulta ng huling utos na ito ay ang sumusunod:
Archlinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004
Ngayon ang ":" sa likod ng mga distro na pangalan ay naka-highlight, ngunit hindi ang mga nasa mga URL dahil ang mga URL ay mayroong "/" pagkatapos ng mga ito.
- Ang paglalagay ng character na "^" sa simula ng isang bracket ay tumutugma sa anumang character maliban sa iba pang mga character sa bracket.
Ang isa pang bagay na maaari nating gawin ay tukuyin ang isang saklaw ng mga character. Halimbawa, upang maghanap para sa anumang numero na sinusundan ng isang "-" ganito ang hitsura:
grep '[0-9]-' regex
Sa pamamagitan nito tinutukoy namin ang isang character sa pagitan ng 0 at 9 at pagkatapos ng isang minus sign. Tingnan natin ang resulta:
ArchLinux: 11-03-2002 CentOs: 14-05-2004 03: 32: 38
Maaaring tukuyin ang maramihang mga saklaw sa loob ng mga braket upang ihalo ang mga saklaw na may solong mga character.
- Ang paglalagay ng dalawang character na pinaghiwalay ng "-" sa loob ng mga braket ay tumutugma sa anumang character sa loob ng saklaw.
Tingnan natin ngayon kung maaari nating piliin ang unang bahagi ng mga URL. Ang nagsasabing "http" o "https". Nag-iiba lamang sila sa huling "s", kaya't gawin natin ito tulad ng sumusunod:
grep -E 'https?' regex
Ginagamit ang marka ng tanong upang gawing opsyonal ang character sa kaliwang opsyonal. Ngunit ngayon naidagdag namin ang pagpipiliang -E sa utos. Ito ay sapagkat ang interogasyon ay isang tampok ng pinalawig na regular na mga expression. Hanggang ngayon gumagamit kami ng mga pangunahing regular na expression, kaya hindi na kailangang maglagay kahit ano. Tingnan natin ang resulta:
ArchLinux: https: //wiki.archlinux.org/ Gentoo: https: //wiki.gentoo.org/wiki/Main_Page CentOS: http: //wiki.centos.org/ Debian: https: //wiki.debian.org/ Ubuntu: https: //wiki.ubuntu.com/
Kaya mayroon na kaming bagong panuntunan:
- Isang character na sinundan ng "?" tumutugma sa character na iyon o wala. Ito ay wasto lamang para sa pinalawig na regular na mga expression.
Ngayon ay titingnan namin ang dalawang ganap na magkakaibang mga salita. Tingnan natin kung paano hanapin ang mga linya na naglalaman ng parehong salitang "Debian" at "Ubuntu".
grep -E 'Debian|Ubuntu' regex
Sa pamamagitan ng patayong bar maaari naming paghiwalayin ang dalawa o higit pang magkakaibang mga regular na expression at hanapin ang mga linya na tumutugma sa anuman sa mga ito:
Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ Debian: 16 / 08 / 1993 Ubuntu: 20 / 10 / 2004
- Ang tauhang «|» naghahain upang paghiwalayin ang ilang mga regular na expression at mga tugma sa alinman sa mga ito. Tukoy din ito sa pinalawig na regular na mga expression.
Ituloy natin. Hahanapin namin ngayon ang salitang "Linux", ngunit kung saan hindi ito naka-stuck sa ibang salita sa kaliwa. Maaari nating gawin ito tulad nito:
grep '\
Dito ang mahalagang tauhan ay "<", ngunit kailangan itong makatakas sa pamamagitan ng paglalagay ng "\" sa harap nito upang mabigyang kahulugan ito ng grep bilang isang espesyal na tauhan. Ang resulta ay ang mga sumusunod:
Arko Linux: 11-03-2002 Mula sa Linux Rulez.
Maaari mo ring gamitin ang "\>" upang maghanap para sa mga salitang hindi katabi ng bawat isa. Pumunta tayo sa isang halimbawa. Subukan natin ang utos na ito:
grep 'http\>' regex
Ang output na ginagawa nito ay ito:
CentOS: http: //wiki.centos.org/
Lumabas ang "Http", ngunit hindi "https" sapagkat sa "https" mayroon pa ring character sa kanan ng "p" na maaaring maging bahagi ng isang salita.
- Ang mga character na "<" at ">" ay tumutugma sa simula at pagtatapos ng isang salita, ayon sa pagkakabanggit. Ang mga character na ito ay dapat na makatakas upang hindi sila mabibigyang kahulugan bilang literal na mga character.
Pumunta kami sa mga bagay na medyo mas kumplikado. Ang character na "+" ay tumutugma sa character sa kaliwa nito, na inuulit kahit isang beses. Magagamit lamang ang character na ito na may pinalawig na regular na expression. Sa pamamagitan nito maaari nating hanapin, halimbawa, ang mga pagkakasunud-sunod ng maraming mga numero sa isang hilera na nagsisimula sa ":".
grep -E ':[0-9]+' regex
Resulta:
Mga CentO: 14-05-2004 03: 32: 38
Ang numero 38 ay naka-highlight din dahil nagsisimula rin ito sa ":".
- Ang character na "+" ay tumutugma sa character sa kaliwa nito, na inuulit kahit isang beses.
Maaari mo ring makontrol ang bilang ng mga pag-uulit gamit ang "{" at "}". Ang ideya ay maglagay ng isang numero sa mga tirante na nagpapahiwatig ng eksaktong bilang ng mga pag-uulit na gusto namin. Maaari ka ring maglagay ng isang saklaw. Tingnan natin ang mga halimbawa ng dalawang kaso.
Una naming hahanapin ang lahat ng mga apat na digit na pagkakasunud-sunod doon:
grep '[0-9]\{4\}' regex
Tandaan na ang mga kulot na tirante ay dapat na makatakas kung gumagamit kami ng mga pangunahing regular na expression, ngunit hindi kung gumagamit kami ng mga pinalawig. Sa pinalawig magiging ganito:
grep -E '[0-9]{4}' regex
At ang resulta sa parehong kaso ay ito:
ArchLinux: 11-03-2002 Gentoo: 31/03 /2002 Mga CentO: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10 /2004
- Ang mga character na "{" at "}" na may isang numero sa pagitan nila ay tumutugma sa nakaraang character na inulit ang tinukoy na bilang ng mga beses.
Ngayon ang iba pang halimbawa sa mga tirante. Ipagpalagay na nais nating makahanap ng mga salitang mayroong pagitan ng 3 at 6 na maliliit na titik. Maaari naming gawin ang sumusunod:
grep '[a-z]\{3,6\}' regex
At ang magiging resulta ay ito:
- List de pahinas wiki: TOrchLinux: https:/ /wiki.archlinux.org/ Gpagkatapos: https:/ /wiki.gentoo.org/wiki/Main_Pedad CentOS: http:/ /wiki.centos.org/ Debian: https:/ /wiki.Debian.org/ Owakas: https:/ /wiki.Ubuntu.com/ - Fnakaligtaan mo de ilunsad: TOrch Linux: 11-03-2002 Gpagkatapos: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Uwakas: 20/10/2004 DIto ay Linux Rulez.
Alin, tulad ng nakikita mo, ay hindi katulad ng gusto namin. Iyon ay dahil ang regular na expression ay nahahanap ang mga titik sa loob ng ibang mga salita na mas mahaba. Subukan natin ang iba pang bersyon na ito:
grep '\<[a-z]\{3,6\}\>' regex
Resulta:
- Listahan ng mga pahina wiki: ArchLinux: https:/ /wiki.archlinux.org/ Gentoo: https:/ /wiki.gentoo.org/wiki/ Main_Page CentOS: http:/ /wiki.centos.org/ Debian: https:/ /wiki.Debian.org/ Ubuntu: https:/ /wiki.Ubuntu.com/
Ito ay mukhang higit na sa kung ano ang nais namin. Ang aming nagawa ay hinihiling na ang salitang magsimula bago ang unang titik at magtatapos pagkatapos lamang ng huli.
- Ang mga character na "{" at "}" na may dalawang numero sa pagitan ng mga ito na pinaghihiwalay ng isang kuwit ay tumutugma sa nakaraang character na paulit-ulit sa bilang ng beses na ipinahiwatig ng dalawang numero.
Tingnan natin ngayon ang isang character na higit sa lahat ng "+". Ito ay "*" at ang pagpapatakbo nito ay halos kapareho lamang na tumutugma ito sa anumang bilang ng mga character kasama ang zero. Iyon ay, ginagawa ito pareho sa "+" ngunit hindi kinakailangan ang character sa kaliwa nito upang lumitaw sa teksto. Halimbawa, subukang hanapin ang mga address na nagsisimula sa wiki at nagtatapos sa org:
grep 'wiki.*org' regex
Tingnan natin ang resulta:
ArchLinux: https: //wiki.archlinux.org/ Gentoo: https: //wiki.gentoo.org/ wiki / Main_Page CentOS: http: //wiki.centos.org/ Debian: https: //wiki.debian.org/
Perfecto.
Ngayon ang huling karakter na makikita natin. Ginagamit ang character na "\" upang makatakas sa character sa kanan upang mawala sa kanya ang espesyal na kahulugan. Halimbawa: Ipagpalagay na nais nating hanapin ang mga linya na nagtatapos sa isang punto. Ang unang bagay na maaaring mangyari sa amin ay maaaring ito:
grep '.$' regex
Ang resulta ay hindi kung ano ang hinahanap namin:
- Listahan ng mga pahina ng wiki: ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ - Mga petsa ng paglabas: Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004 Desde Linux Rulez.
Ito ay dahil ang "." tumutugma sa anumang bagay, upang ang regular na expression ay tumutugma sa huling karakter ng bawat linya kung ano man ito. Ang solusyon ay ito:
grep '\.$' regex
Ngayon ang resulta ay kung ano ang gusto namin:
Desde Linux Rulez.
Game Over
Bagaman ang paksa ng regular na mga expression ay napakahirap na ibibigay ko para sa isang serye ng mga artikulo, sa palagay ko nabigyan ko na kayo ng sapat na sakit. Kung nagawa mong makarating, binabati kita. At kung nabasa mo ang lahat ng ito sa isang pag-upo, kumuha ng isang aspirin o anumang bagay, dahil hindi ito maaaring maging mabuti.
Sa ngayon yun lang. Kung gusto mo ang artikulong ito, marahil maaari kang magsulat ng iba pa. Pansamantala, inirerekumenda kong subukan mo ang lahat ng mga regular na expression sa terminal upang makita nang malinaw kung paano ito gumagana. At tandaan: Ang Chuck Norris lamang ang maaaring mag-parse ng HTML gamit ang mga regular na expression.
Ano ang magiging buhay natin kung wala ang regex?
Napaka kapaki-pakinabang ng artikulo, ngunit babasahin ko ito nang paunti-unti. Maraming salamat.
Salamat sa iyong puna. Hindi pa rin ako naniniwala na lumabas ang aking artikulo. 🙂 Lumabas ito na may ilang error, ngunit inaasahan kong kapaki-pakinabang ito. 🙂
Salamat youssssssss! ..
Ilang oras na ang nakalilipas kailangan kong mag-aral ng kaunti tungkol sa mga regular na expression .. ..Salamat ako sa pagtuturo .. at ang sunud-sunod na gabay upang malaman ang bawat isa sa kanila ..
Napakahusay! .. .. Kukunin ko ang aspirin na iyon .. ee
Walang problema. Tapang at ang mga regular na expression ay hindi maaaring sa iyo. 🙂
Kamangha-manghang post! Mahusay na trabaho. Siguro kung ilang oras ang inabot mo 😀
LOL!! Ang tanong ay: Gaano karaming oras ang aabutin sa akin kung nasabi ko ang lahat na nais kong sabihin? Walang hanggan !! 🙂
isang bagay na hindi ko alam, magandang artikulo!
Salamat. Isang kasiyahan na ibahagi ito sa iyo.
mahusay na paliwanag. binabati kita! talagang kapaki-pakinabang!
Natutuwa akong nahanap mong kapaki-pakinabang ito. Kaya kasiyahan na magsulat.
Dapat itong pumunta sa isang lugar na espesyal. Tulad ng Itinatampok ngunit mayroong isang napaka-tukoy na pagiging kapaki-pakinabang. Medyo kapaki-pakinabang, kahit na nais kong makita itong inilapat sa Vim.
Iyon ay isang katanungan ng pagtatanong sa aking sarili. Mayroon akong ilang higit pang mga artikulo tungkol sa mga regular na expression sa isip. At maaari kong pag-usapan ang tungkol sa kanila. Mayroon itong ilang pagkakaiba mula sa ipinaliwanag ko sa artikulong ito. Ito ay isang bagay ng pagkuha sa dito. 🙂
Mabuti!
Napakaganda ng iyong artikulo, nakaka-curious, kamakailan lamang (ngayon) nai-publish ko sa aking website ang isang entry na ilang araw ko nang inihanda kung saan nakakolekta ako ng listahan ng mga metacharacter para sa mga regular na expression at ilang mga halimbawa. At naging patas ang pagpasok DesdeLinux at tingnan ang isang entry sa parehong paksa!
Kung ito ay anumang aliw, ang akin ay MAS MAS PUSSY 😀
Tiyak na ang regex ay isa sa mga pinaka kapaki-pakinabang na bagay, karaniwang ginagamit ko ang mga ito upang i-trim ang output ng mga utos at panatilihin ang bahagi na interesado ako, at pagkatapos ay makipag-ugnay dito sa isang bash script, halimbawa. Marami rin akong nagamit sa kanila sa unibersidad, at mahalaga ang kahalagahan nila sa pagbuo ng mga nagtitipon (sa kahulugan ng lexicographic at parsers). Sa madaling sabi, isang buong mundo.
Pagbati at napakahusay na trabaho.
Maraming salamat sa inyo.
Nagustuhan ko rin ang iyong artikulo. Mas maikli ito kaysa sa akin. Maaari itong magsilbing isang mabilis na sanggunian. Ito ay isang pagkakataon na nasulat natin ang mga ito nang sabay. Maaari mong makita na ang mga tao ay interesado sa paksa. 🙂
Mga regular na expression para sa dummies =), ngayon ay mas malinaw sa akin, sa pamamagitan ng isang paraan upang magkaroon ng output na may kulay para sa grep, ay sa pamamagitan ng paglikha ng isang alias sa .bashrc alias grep = 'grep –color = laging', kung sakaling ito gumagana para sa isang tao.
Regards
Totoo Iyon ay ibang paraan upang magawa ito. Salamat sa input. 🙂
O_O… piraso ng kontribusyon !!! O_O ...
Maraming salamat sa post, naghihintay ako para sa isang bagay tulad nito sandali lol, iniiwan kong bukas upang basahin ito nang mahinahon sa bahay na may zero abala upang pag-isiping mabuti lol.
Salamat sa artikulo, ginagawa ko talaga 😀
Alam kong magugustuhan mo ito. LOL!! Ang totoo maraming bagay ang nawawala, ngunit mayroon na akong pangalawang bahagi sa isip. 🙂
Mahusay na artikulo, kung nabasa ko lang ito kahapon, ang klase na ibinigay ko ngayon ay mas madali para sa aking mga mag-aaral!
LOL!! Sayang ako ay huli na, ngunit natutuwa na kapaki-pakinabang ito. 🙂
Sa wakas !!!, napakahusay ng post .... Sa wakas ay nakakita ako ng isang bagay na malinaw na nagpapaliwanag ng regular na mga expression ... ..
Mayroong maraming impormasyon doon, ngunit mas mahirap makahanap ng isang bagay na madaling maunawaan. Natutuwa akong napunan ko ang puwang na iyon. 🙂
Pagbati.
Hoy kailangan ko ng tulong, kailangan kong maghanap sa / var / log na may format: yymmdd, at ang mga log ay tulad nito 130901.log -130901.log, kailangan kong maghanap para sa lahat ng mga nasa pagitan ng Setyembre 1 hanggang Oktubre 11, Ang nagawa ko lang na gawin ay alisin ang lahat ng Setyembre ngunit hindi ko alam kung paano gawin ang kumpletong kadena:
hal: 1309 [0-3] ibinalik sa akin ang mga log sa pagitan ng Setyembre 1 hanggang Setyembre 30, ngunit hindi ko alam kung paano makakapunta din sa parehong kadena mula Oktubre 1 hanggang 11.
Upang gawin ito gamit ang regular na mga expression ay medyo kumplikado. Ito ay nangyayari sa akin na ang isang bagay tulad nito ay maaaring gumana:
13(09[0-3]|10(0|1[01]))
Ito ay isang pinalawig na regular na pagpapahayag. Hindi mo sasabihin kung aling tool ang ginagamit mo, kaya't hindi kita mabibigyan ng higit pang mga detalye.
Gayunpaman, sa palagay ko ito ang kaso sa halip na gumamit ng mga regular na expression mas mahusay na gawin ito sa paghahanap. Maaari mong subukan ang isang bagay tulad nito:
hanapin -newermt '01 sep '-a! -newermt '11 oct '-print
Swerte Inaasahan kong makakatulong ito sa iyo.
Kumusta! Una sa lahat, nais kong pasalamatan ka para sa iyong trabaho dahil ang pahinang ito ay kabilang sa aking "nangungunang 3" ng pinakamahusay na mga site sa Linux.
Nagsasanay ako at hindi ko alam kung bakit hindi gumana sa akin ang isang RegExp sa isang numero ng telepono at nawawala ko ang "-E" (na napagtanto kong salamat sa post na ito).
Nais kong tanungin ka kung hindi mo alam ang anumang magandang pdf o site kung saan may mga pagsasanay sa RegExp, kahit na may isang maliit na imahinasyon maaari mong magsanay na imbento sa kanila mismo.
Pagbati, Pablo.
Napakahusay, nabasa ko lang ang lahat, at oo ngayon kailangan ko ng isang aspirin 🙂
Ang pinakamagandang paliwanag na nakita ko ng mga regular na expression. Salamat sa may-akda sa pagbabahagi ng gawaing ito.
Isang pagbati.
Nagustuhan ko talaga ang isang napakahusay na paliwanag