Grep का उपयोग करके कई लाइनों में पैटर्न कैसे खोजें?

Question

मैं उन फ़ाइलों को ढूंढना चाहता हूं जिनमें उस क्रम में "एबीसी" और "एफईजी" है, और वे दो तार उस फाइल में अलग-अलग लाइनों पर हैं। जैसे: सामग्री वाली फ़ाइल:

blah blah..
blah blah..
blah abc blah
blah blah..
blah blah..
blah blah..
blah efg blah blah
blah blah..
blah blah..

मिलना चाहिए।

Comments

के संभावित डुप्लिकेट कैसे मैं एक फ़ाइल में एक बहु पैटर्न की खोज कर सकते हैं?

— सिरो सेंटिल्ली 郝海东 i i i 法轮功 ''

Answer 1

इस ऑपरेशन के लिए ग्रीप पर्याप्त नहीं है।

pcregrep जो कि अधिकांश आधुनिक Linux सिस्टम में पाया जाता है, का उपयोग किया जा सकता है

pcregrep -M  'abc.*(\n|.)*efg' test.txt

जहाँ -M, --multiline प्रतिमानों को एक से अधिक पंक्ति से मेल खाने की अनुमति दें

एक नया pcre2grep भी है। दोनों को PCRE प्रोजेक्ट द्वारा प्रदान किया गया है ।

pcre2grep मैक ओएस एक्स के लिए मैक पोर्ट के माध्यम से पोर्ट के भाग के रूप में उपलब्ध है pcre2:

% sudo port install pcre2 

और Homebrew के माध्यम से के रूप में:

% brew install pcre

या pcre2 के लिए

% brew install pcre2

pcre2grep लिनक्स पर भी उपलब्ध है (उबंटू 18.04+)

$ sudo apt install pcre2-utils # PCRE2
$ sudo apt install pcregrep    # Older PCRE

Comments

@StevenLu -M, --multiline- पैटर्न को एक से अधिक पंक्ति से मेल खाने की अनुमति दें।

— रिंग बियर

ध्यान दें। * (\ n |) * * (\ n।) के बराबर है। * और बाद वाला छोटा है। मेरे सिस्टम पर इसके अलावा, "pcre_exec () त्रुटि -8" तब होता है जब मैं लंबा संस्करण चलाता हूं। तो इसके बजाय 'abc (\ n |) * * efg' आज़माएं!

— daveagp

आपको उस मामले में अभिव्यक्ति को गैर-लालची बनाने की आवश्यकता है:'abc.*(\n|.)*?efg'

— रिंग बियरर

और आप पहले छोड़ सकते हैं .*-> 'abc(\n|.)*?efg'regex कम करने के लिए (और पंडिताऊ होने के लिए)

— Michi

pcregrepचीजों को आसान बनाता है, लेकिन grepकाम भी करेगा। उदाहरण के लिए, stackoverflow.com/a/7167115/123695

— माइकल मिओर

Answer 2

मुझे यकीन नहीं है कि अगर यह grep के साथ संभव है, लेकिन sed इसे बहुत आसान बनाता है:

sed -e '/abc/,/efg/!d' [file-with-content]

Comments

यह फ़ाइलों को नहीं

— ढूंढता है

@Lj। कृपया आप इस आदेश की व्याख्या कर सकते हैं? मैं परिचित हूं sed, लेकिन अगर पहले कभी इस तरह की अभिव्यक्ति नहीं देखी है।

— एंथोनी

@ एंथनी, यह पते के तहत, sed के मैन पेज में प्रलेखित है। यह जानना महत्वपूर्ण है कि / abc / & / efg / एक पता है।

— स्क्वीली

मुझे लगता है कि यह उत्तर उपयोगी होता अगर यह थोड़ा और स्पष्टीकरण होता और उस स्थिति में, मैंने इसे एक बार और वोट दिया होता। मैं थोड़ा सीड जानता हूं, लेकिन इस जवाब का उपयोग करने के लिए पर्याप्त नहीं है कि फिडलिंग के आधे घंटे के बाद एक सार्थक निकास कोड का उत्पादन किया जाए। युक्ति: 'RTFM' को शायद ही कभी StackOverflow पर वोट मिलते हैं, जैसा कि आपकी पिछली टिप्पणी से पता चलता है।

— माइकल शेपर

उदाहरण द्वारा त्वरित व्याख्या: sed '1,5d': 1 और 5. के बीच की पंक्तियों को हटाएं। '1,5-d': 1 और 5 के बीच की रेखाओं को न हटाएं (यानी बीच की पंक्तियों को रखें) तो एक संख्या के बजाय, आप कर सकते हैं / पैटर्न / के साथ एक लाइन के लिए खोज। नीचे दिए गए सरल को भी देखें: sed -n '/ abc /, / efg / p' p प्रिंट के लिए है और -n ध्वज सभी लाइनों को प्रदर्शित नहीं करता है

— phil_w

Answer 3

इस उत्तर से प्रेरित एक समाधान है :

• यदि 'abc' और 'efg' एक ही पंक्ति में हो सकते हैं:

  grep -zl 'abc.*efg' <your list of files>

• अगर 'abc' और 'efg' अलग-अलग लाइनों में होना चाहिए:

  grep -Pzl '(?s)abc.*\n.*efg' <your list of files>

पैरामीटर:

• -zइनपुट को लाइनों के एक सेट के रूप में मानें, प्रत्येक को एक नई बाइट के बजाय एक शून्य बाइट द्वारा समाप्त किया जाता है। यानी grep इनपुट को एक बड़ी लाइन के रूप में मानता है।

• -l प्रत्येक इनपुट फ़ाइल का प्रिंट नाम, जिसमें से आउटपुट आम तौर पर मुद्रित किया जाता था।

• (?s)PCRE_DOTALL को सक्रिय करें, जिसका अर्थ है कि ''। किसी भी चरित्र या newline पाता है।

Comments

@syntaxerror नहीं, मुझे लगता है कि यह सिर्फ एक निचला मामला है l। AFAIK कोई संख्या -1विकल्प नहीं है।

— 1

लगता है कि आप बिल्कुल सही हैं, हो सकता है कि मैंने परीक्षण करते समय एक टाइपो बनाया हो। किसी भी मामले में एक झूठी राह बिछाने के लिए खेद है।

— वाक्य रचना

यह उत्कृष्ट है। इस संबंध में मेरा सिर्फ एक सवाल है। यदि -zविकल्प नए सिरे से उपचार करने के लिए grep को निर्दिष्ट करता है zero byte charactersतो हमें (?s)regex की आवश्यकता क्यों है ? यदि यह पहले से ही एक नॉन-न्यूलाइन कैरेक्टर है, तो .इसे सीधे मैच नहीं कर सकता?

— दुर्गा स्वरूप

-z (aka --null-data) और (?) ठीक वही हैं जो आपको एक मानक grep के साथ मल्टी-लाइन से मेल खाना चाहिए। MacOS पर लोग, कृपया अपने सिस्टम पर -z या -null-data विकल्पों की उपलब्धता के बारे में टिप्पणी छोड़ दें!

— ज़ेके उपवास

-Z निश्चित रूप से MacOS पर उपलब्ध नहीं है

— डायलन निकोल्सन

Answer 4

जैसा कि पोस्टर LJ ऊपर कहा गया है, sed को पर्याप्त होना चाहिए,

इसके बजाय! d आप बस प्रिंट करने के लिए p का उपयोग कर सकते हैं:

sed -n '/abc/,/efg/p' file

Answer 5

मैं pcregrep पर बहुत अधिक निर्भर था, लेकिन नए grep के साथ आपको इसके कई विशेषताओं के लिए pcregrep को स्थापित करने की आवश्यकता नहीं है। बस उपयोग करें grep -P।

ओपी के प्रश्न के उदाहरण में, मुझे लगता है कि निम्नलिखित विकल्प अच्छी तरह से काम करते हैं, दूसरा सबसे अच्छा मिलान के साथ कि मैं प्रश्न को कैसे समझता हूं:

grep -Pzo "abc(.|\n)*efg" /tmp/tes*
grep -Pzl "abc(.|\n)*efg" /tmp/tes*

मैंने टेक्स्ट को / tmp / test1 के रूप में कॉपी किया और 'g' को हटा दिया और / tmp / test2 के रूप में सहेज लिया। यहाँ आउटपुट दिखा रहा है कि पहला मिलान स्ट्रिंग दिखाता है और दूसरा केवल फ़ाइल नाम दिखाता है (ठेठ -o मैच दिखाना है और ठेठ -l केवल फ़ाइल नाम दिखाना है)। ध्यान दें कि 'z' मल्टीलाइन के लिए आवश्यक है और '(। | \ N)' का अर्थ 'न्यूलाइन के अलावा' या 'न्यूलाइन' के अलावा किसी भी चीज़ से मेल खाता है - यानी कुछ भी:

user@host:~$ grep -Pzo "abc(.|\n)*efg" /tmp/tes*
/tmp/test1:abc blah
blah blah..
blah blah..
blah blah..
blah efg
user@host:~$ grep -Pzl "abc(.|\n)*efg" /tmp/tes*
/tmp/test1

यह निर्धारित करने के लिए कि आपका संस्करण पर्याप्त नया है, चलाएं man grepऔर देखें कि क्या ऐसा ही कुछ शीर्ष के पास दिखाई देता है:

   -P, --perl-regexp
          Interpret  PATTERN  as a Perl regular expression (PCRE, see
          below).  This is highly experimental and grep -P may warn of
          unimplemented features.

वह GNU grep 2.10 से है।

Answer 6

यह आसानी से trकुछ अन्य चरित्र के साथ newlines को बदलने के लिए पहले का उपयोग करके किया जा सकता है :

tr '\n' '\a' | grep -o 'abc.*def' | tr '\a' '\n'

यहां, मैं \aएक नई पंक्ति के स्थान पर अलार्म वर्ण, (ASCII 7) का उपयोग कर रहा हूं । यह आपके पाठ में लगभग कभी नहीं पाया जाता है, और इसे विशेष रूप से grepइसके साथ मेल कर सकता है ., या मेल कर सकता है \a।

Comments

यह मेरा दृष्टिकोण था, लेकिन मैं उपयोग कर रहा था \0और इस तरह की जरूरत थी grep -aऔर इस पर मेल कर रहा था \x00... आपने मुझे सरल बनाने में मदद की है! echo $log | tr '\n' '\0' | grep -aoE "Error: .*?\x00Installing .*? has failed\!" | tr '\0' '\n'अब हैecho $log | tr '\n' '\a' | grep -oE "Error: .*?\aInstalling .*? has failed\!" | tr '\a' '\n'

— चार्ली गोरीचांज़

का उपयोग करें grep -o।

— कीब

Answer 7

awk वन-लाइनर:

awk '/abc/,/efg/' [file-with-content]

Comments

abcयदि फाइल में एंडिंग पैटर्न मौजूद नहीं है, या अंतिम एंडिंग पैटर्न गायब है, तो यह खुशी से फाइल के अंत तक प्रिंट करेगा । आप इसे ठीक कर सकते हैं, लेकिन यह स्क्रिप्ट को काफी जटिल बना देगा।

— ट्रिपल

/efg/आउटपुट से बाहर कैसे करें ?

— कीब

Answer 8

यदि आप पर्ल का उपयोग कर सकते हैं तो आप बहुत आसानी से कर सकते हैं।

perl -ne 'if (/abc/) { $abc = 1; next }; print "Found in $ARGV\n" if ($abc && /efg/); }' yourfilename.txt

आप एक एकल नियमित अभिव्यक्ति के साथ भी ऐसा कर सकते हैं, लेकिन इसमें फ़ाइल की संपूर्ण सामग्री को एक स्ट्रिंग में शामिल करना शामिल है, जो बड़ी फ़ाइलों के साथ बहुत अधिक मेमोरी लेने का अंत कर सकता है। पूर्णता के लिए, यहाँ वह विधि है:

perl -e '@lines = <>; $content = join("", @lines); print "Found in $ARGV\n" if ($content =~ /abc.*efg/s);' yourfilename.txt

Comments

मिला दूसरा उत्तर कुछ लाइनों के मेल से पूरे मल्टी-लाइन ब्लॉक को निकालने के लिए उपयोगी था - .*?न्यूनतम मैच प्राप्त करने के लिए गैर-लालची मिलान ( ) का उपयोग करना था ।

— रिचवेल

Answer 9

मुझे नहीं पता कि मैं grep के साथ ऐसा कैसे करूंगा, लेकिन मैं कुछ इस तरह से करूंगा:

awk '/abc/{ln1=NR} /efg/{ln2=NR} END{if(ln1 && ln2 && ln1 < ln2){print "found"}else{print "not found"}}' foo

आपको सावधान रहना होगा कि आप यह कैसे करते हैं, हालांकि। क्या आप चाहते हैं कि रेगेक्स सबस्ट्रिंग या पूरे शब्द से मेल खाए? उपयुक्त के रूप में \ w टैग जोड़ें। इसके अलावा, जबकि यह कड़ाई से आपके द्वारा बताए गए उदाहरण के अनुरूप है, यह तब बहुत काम नहीं करता है जब एबीसी एफईजी के बाद दूसरी बार प्रकट होता है। यदि आप उसे संभालना चाहते हैं, तो यदि उपयुक्त हो तो / abc / case आदि में जोड़ें।

Answer 10

अफसोस की बात है, आप नहीं कर सकते। से grepडॉक्स:

grep दिए गए इनपुट FILE को खोजता है (या मानक इनपुट अगर कोई फाइल नाम नहीं है, या यदि दिए गए PATTERN से मेल खाने वाली लाइनों के लिए एकल हाइफ़न-माइनस (-) फ़ाइल नाम के रूप में दिया गया है) ।

Comments

किस बारे मेंgrep -Pz

— Navaro

Answer 11

यदि आप संदर्भों का उपयोग करने के इच्छुक हैं, तो इसे टाइप करके प्राप्त किया जा सकता है

grep -A 500 abc test.txt | grep -B 500 efg

यह "एबीसी" और "एफईजी" के बीच सब कुछ प्रदर्शित करेगा , जब तक कि वे एक दूसरे की 500 लाइनों के भीतर न हों।

Answer 12

यदि आपको जरूरत है कि दोनों शब्द एक-दूसरे के करीब हों, उदाहरण के लिए 3 से अधिक लाइनें नहीं हैं, तो आप ऐसा कर सकते हैं:

find . -exec grep -Hn -C 3 "abc" {} \; | grep -C 3 "efg"

एक ही उदाहरण है, लेकिन केवल * .txt फ़ाइलों को फ़िल्टर करना:

find . -name *.txt -exec grep -Hn -C 3 "abc" {} \; | grep -C 3 "efg"

और यह भी कि आप grepकमांड को रिप्लेस कर सकते हैं egrepयदि आप नियमित एक्सप्रेशन के साथ भी चाहें।

Answer 13

मैंने कुछ दिन पहले एक grep विकल्प जारी किया था जो सीधे मल्टीलाइन मिलान या शर्तों का उपयोग करके इसका समर्थन करता है - उम्मीद है कि यह यहां खोज रहे कुछ लोगों के लिए उपयोगी है। उदाहरण के लिए यह कैसा दिखेगा:

बहुपंक्ति:

sift -lm 'abc.*efg' testfile

शर्तेँ:

sift -l 'abc' testfile --followed-by 'efg'

आप यह भी निर्दिष्ट कर सकते हैं कि 'efg' को एक निश्चित संख्या में लाइनों के भीतर 'abc' का अनुसरण करना है:

sift -l 'abc' testfile --followed-within 5:'efg'

आप sift-tool.org पर अधिक जानकारी प्राप्त कर सकते हैं ।

Comments

मुझे नहीं लगता कि पहला उदाहरण sift -lm 'abc.*efg' testfileकाम करता है, क्योंकि मैच लालची है और efgफाइल में आखिरी तक सभी लाइनों को जकड़ लेता है ।

— डॉ। एलेक्स

Answer 14

जबकि सेड विकल्प सबसे सरल और आसान है, एलजे का वन-लाइनर दुख की बात है कि सबसे पोर्टेबल नहीं है। सी शेल के एक संस्करण के साथ फंसे लोगों को अपने बैंग्स से बचने की आवश्यकता होगी:

sed -e '/abc/,/efg/\!d' [file]

यह दुर्भाग्य से बैश एट अल में काम नहीं करता है।

Answer 15

#!/bin/bash
shopt -s nullglob
for file in *
do
 r=$(awk '/abc/{f=1}/efg/{g=1;exit}END{print g&&f ?1:0}' file)
 if [ "$r" -eq 1 ];then
   echo "Found pattern in $file"
 else
   echo "not found"
 fi
done

Answer 16

आप grep incase का उपयोग कर सकते हैं आप पैटर्न के अनुक्रम में उत्सुक नहीं हैं।

grep -l "pattern1" filepattern*.* | xargs grep "pattern2"

उदाहरण

grep -l "vector" *.cpp | xargs grep "map"

grep -lपहले पैटर्न से मेल खाती सभी फाइलों को खोजेगा, और xargs दूसरे पैटर्न के लिए grep करेगा। उम्मीद है की यह मदद करेगा।

Comments

यह फ़ाइल में दिखाई देने वाले ऑर्डर "पैटर्न 1" और "पैटर्न 2" को नजरअंदाज करेगा, हालांकि - ओपी विशेष रूप से निर्दिष्ट करता है कि केवल फाइलें जहां "पैटर्न 2" दिखाई देती हैं "पैटर्न 1" का मिलान किया जाना चाहिए।

— एमिल लुंडबर्ग

Answer 17

चांदी खोजक के साथ :

ag 'abc.*(\n|.)*efg'

रिंग बियरर के जवाब के समान, लेकिन इसके बजाय एजी के साथ। चांदी खोजक के गति लाभ संभवतः यहाँ चमक सकते हैं।

Comments

इससे काम नहीं लगता है। (echo abctest; echo efg)|ag 'abc.*(\n|.)*efg'से मेल नहीं खाता

— phiresky

Answer 18

मैंने इसका उपयोग मल्टी फास्टा फ़ाइल से grep के लिए -P विकल्प का उपयोग करके एक फास्टा अनुक्रम निकालने के लिए किया है:

grep -Pzo ">tig00000034[^>]+"  file.fasta > desired_sequence.fasta

• पीएल आधारित खोजों के लिए पी
• newline char के बजाय 0 बाइट्स में लाइन एंड बनाने के लिए z
• ओ बस पकड़ क्या मैच के बाद से grep पूरी लाइन लौटाता है (जो इस मामले में जब से आपने -z पूरी फ़ाइल है)।

रेगेक्सप का मूल वह है [^>]जो "प्रतीक से अधिक नहीं" का अनुवाद करता है

Answer 19

बालू मोहन के उत्तर के विकल्प के रूप में grep, केवल उपयोग करने वाले पैटर्न के क्रम को लागू करना संभव है , headऔर tail:

for f in FILEGLOB; do tail $f -n +$(grep -n "pattern1" $f | head -n1 | cut -d : -f 1) 2>/dev/null | grep "pattern2" &>/dev/null && echo $f; done

यह बहुत सुंदर नहीं है, हालांकि। अधिक आसानी से प्रारूपित:

for f in FILEGLOB; do
    tail $f -n +$(grep -n "pattern1" $f | head -n1 | cut -d : -f 1) 2>/dev/null \
    | grep -q "pattern2" \
    && echo $f
done

यह जहां सभी फ़ाइलों के नाम प्रिंट होगा "pattern2"बाद दिखाई देता है "pattern1", या जहां दोनों एक ही लाइन पर दिखाई देते हैं :

$ echo "abc
def" > a.txt
$ echo "def
abc" > b.txt
$ echo "abcdef" > c.txt; echo "defabc" > d.txt
$ for f in *.txt; do tail $f -n +$(grep -n "abc" $f | head -n1 | cut -d : -f 1) 2>/dev/null | grep -q "def" && echo $f; done
a.txt
c.txt
d.txt

व्याख्या

• tail -n +i- iवें के बाद सभी लाइनों को प्रिंट करें , समावेशी
• grep -n - उनके लाइन नंबरों के साथ मिलान लाइनों को प्रीपेन्ड करें
• head -n1 - केवल पहली पंक्ति प्रिंट करें
• cut -d : -f 1- :सीमांकक के रूप में उपयोग करके पहले कट कॉलम को प्रिंट करें
• 2>/dev/null- अभिव्यक्ति tailत्रुटि $()खाली होने पर मौन त्रुटि आउटपुट होती है
• grep -q- grepएक मैच मिलने पर मौन और तुरंत वापस, क्योंकि हम केवल निकास कोड में रुचि रखते हैं

Comments

किसी को भी समझा सकते हैं &>? मैं भी इसका उपयोग कर रहा हूं, लेकिन मैंने कभी भी इसे कहीं भी प्रलेखित नहीं देखा। BTW, हम वास्तव में इस तरह से चुप क्यों हैं? grep -qचाल भी नहीं चलेगा?

— वाक्य रचना

&>बैश को मानक आउटपुट और मानक त्रुटि दोनों को रीडायरेक्ट करने के लिए कहता है, बैश मैनुअल में REDIRECTION देखें। आप इसमें बहुत सही हैं कि हम बस के grep -q ...बजाय grep ... &>/dev/nullअच्छा पकड़ कर सकते हैं!

— एमिल लुंडबर्ग

ऐसा ही सोचा था। बहुत सारी अजीब अतिरिक्त टाइपिंग के दर्द को दूर करेगा। स्पष्टीकरण के लिए धन्यवाद - तो मैं मैनुअल में थोड़ा छोड़ दिया जाना चाहिए। (कुछ समय पहले दूर से संबंधित कुछ देखा था।) --- आप इसे अपने उत्तर में बदलने पर भी विचार कर सकते हैं। :)

— वाक्य रचना

Answer 20

यह भी काम करना चाहिए ?!

perl -lpne 'print $ARGV if /abc.*?efg/s' file_list

$ARGVfile_list /sनई फ़ाइल में संशोधक खोजों से पढ़ते समय वर्तमान फ़ाइल का नाम होता है ।

Answer 21

फ़ाइलपार्टन *.shको निर्देशिकाओं का निरीक्षण करने से रोकने के लिए महत्वपूर्ण है। बेशक कुछ परीक्षण भी इसे रोक सकते हैं।

for f in *.sh
do
  a=$( grep -n -m1 abc $f )
  test -n "${a}" && z=$( grep -n efg $f | tail -n 1) || continue 
  (( ((${z/:*/}-${a/:*/})) > 0 )) && echo $f
done

The

grep -n -m1 abc $f 

अधिकतम 1 मिलान और रिटर्न (-n) लिननम्बर खोजता है। यदि कोई मैच पाया गया था (परीक्षण -n ...) एफईजी का अंतिम मैच खोजें (सभी को ढूंढें और पूंछ-एन 1 के साथ अंतिम लें)।

z=$( grep -n efg $f | tail -n 1)

जारी रखें।

चूंकि परिणाम कुछ ऐसा है कि 18:foofile.sh String alf="abc";हमें लाइन से अंत तक ":" से दूर रहने की आवश्यकता है।

((${z/:*/}-${a/:*/}))

एक सकारात्मक परिणाम लौटना चाहिए यदि दूसरा अभिव्यक्ति का आखिरी मैच पहले के पहले मैच से आगे है।

फिर हम फ़ाइल नाम की रिपोर्ट करते हैं echo $f।

Answer 22

क्यों कुछ सरल नहीं है जैसे:

egrep -o 'abc|efg' $file | grep -A1 abc | grep efg | wc -l

0 या सकारात्मक पूर्णांक देता है।

egrep -o (केवल मैच दिखाता है, चाल: एक ही लाइन पर कई मैच मल्टी-लाइन आउटपुट उत्पन्न करते हैं जैसे कि वे अलग-अलग लाइनों पर हैं)

• grep -A1 abc (प्रिंट एबीसी और इसके बाद की पंक्ति)

• grep efg | wc -l उसी या निम्न पंक्तियों पर एबीसी के बाद मिली एफईजी लाइनों की (0-एन काउंट, परिणाम को 'यदि "में इस्तेमाल किया जा सकता है)

• पैटर्न मिलान की आवश्यकता होने पर grep को egrep आदि में बदला जा सकता है

Answer 23

यदि आपके पास 2 स्ट्रिंग्स 'एबीसी' और 'एफईजी' के बीच की दूरी के बारे में कुछ अनुमान है, तो आप देख सकते हैं:

grep -r . -e 'abc' -A num1 -B num2 | grep 'efg'

इस तरह, पहला grep 'abc' प्लस # num1 लाइनों के साथ और उसके बाद # num2 लाइनों के साथ लाइन लौटाएगा, और दूसरा grep उन सभी के माध्यम से 'efg' प्राप्त करेगा। तब आपको पता चलेगा कि वे किन फाइलों में एक साथ दिखाई देते हैं।

Answer 24

कुछ महीने पहले जारी किए गए बदसूरत के साथ :

ugrep 'abc(\n|.)+?efg'

यह उपकरण गति के लिए अत्यधिक अनुकूलित है। यह GNU / BSD / PCRE-grep संगत भी है।

ध्यान दें कि हमें एक आलसी पुनरावृत्ति का उपयोग करना चाहिए +?, जब तक कि आप फ़ाइल में efgअंतिम तक सभी लाइनों को एक साथ मैच नहीं करना चाहते efg।

Answer 25

यह काम करना चाहिए:

cat FILE | egrep 'abc|efg'

अगर एक से अधिक मैच हैं, तो आप grep -v का उपयोग करके फ़िल्टर कर सकते हैं

Comments

जबकि इस कोड स्निपेट का स्वागत है, और कुछ मदद प्रदान कर सकता है, यह हो जाएगा काफी सुधार हुआ है, तो यह उसका स्पष्टीकरण शामिल की कैसे और क्यों इस को हल करती है समस्या। याद रखें कि आप भविष्य में पाठकों के लिए सवाल का जवाब दे रहे हैं, न कि केवल उस व्यक्ति से जो अब पूछ रहा है! कृपया स्पष्टीकरण जोड़ने के लिए अपने उत्तर को संपादित करें, और इस बात का संकेत दें कि क्या सीमाएँ और मान्यताएँ लागू होती हैं।

— स्पाइट

यह वास्तव में कई लाइनों में खोज नहीं करता है , जैसा कि प्रश्न में कहा गया है।

— n.st