Buon momento, ospiti!
Nell'articolo di oggi voglio toccare un argomento così vasto come Espressioni regolari. Penso che tutti sappiano che l'argomento delle espressioni regolari (come vengono chiamate le espressioni regolari in gergo) è immenso nel volume di un post. Pertanto, cercherò di raccogliere brevemente, ma nel modo più chiaro possibile, i miei pensieri e trasmetterveli.
Per cominciare, ci sono diverse varietà di espressioni regolari:
Espressioni regolari consiste in schemi, o meglio impostare uno schema ricerca. Il modello consiste da regole ricerche, che sono costituite da caratteri E metacaratteri.
Regole di ricerca determinato da quanto segue operazioni:
Barra verticale (|) separa le opzioni valide, possiamo dire - OR logico. Ad esempio, "grigio|grigio" corrisponde grigio O grigio.
Parentesi tonde vengono utilizzati per determinare l'ambito e la precedenza degli operatori. Ad esempio, "gray|grey" e "gr(a|e)y" sono modelli diversi, ma entrambi descrivono un insieme contenente grigio E grigio.
Quantificatore dopo che un personaggio o un gruppo determina quante volte precedente può verificarsi l'espressione.
espressione generale, le ripetizioni possono essere da m a n compreso.
espressione generale, m o più ripetizioni.
espressione generale, non più di n ripetizioni.
liscion ripetizioni.
Punto interrogativo significa 0 o 1 volte, lo stesso di {0,1} . Ad esempio, "colou?r" corrisponde a e colore, E colore.
Stella significa 0, 1 o qualsiasi numero una volta ( {0,} ). Ad esempio, "go*gle" corrisponde ggle, Google, Google e così via.
Più significa almeno 1 una volta ( {1,} ). Ad esempio, "go+gle" corrisponde Google, Google ecc. (ma non ggle).
La sintassi esatta per queste espressioni regolari dipende dall'implementazione. (cioè dentro espressioni regolari di base simboli ( E )- sfuggito con una barra rovesciata)
Metacaratteri, detto linguaggio semplice sono simboli che non corrispondono al loro vero significato, cioè un simbolo. (punto) non è un punto, ma un qualsiasi carattere, ecc. Ti chiedo di familiarizzare con i metacaratteri e i loro significati:
| . | corrisponde solo qualsiasi personaggio |
| [qualcosa] | Corrisponde qualsiasi individuo carattere tra quelli racchiusi tra parentesi. In questo caso: Il carattere "-" viene interpretato letteralmente solo se si trova immediatamente dopo la parentesi di apertura o prima della parentesi di chiusura: oppure [-abc]. In caso contrario, denota un intervallo di caratteri, ad esempio corrisponde a "a", "b" o "c". corrisponde alle lettere minuscole dell'alfabeto latino. Queste notazioni possono anche essere combinate: corrisponde a, b, c, q, r, s, t, u, v, w, x, y, z. Per abbinare i caratteri "[" o "]", è sufficiente che la parentesi di chiusura era il primo carattere dopo il carattere di apertura: corrisponde a "]", "[", "a" o "b". singolo carattere tra quelli che non sono tra parentesi. Ad esempio, [^abc] corrisponde a qualsiasi carattere diverso da "a", "b" o "c". [^a-z] corrisponde a qualsiasi carattere tranne i caratteri minuscoli dell'alfabeto latino. |
| ^ | Corrisponde all'inizio del testo (o all'inizio di qualsiasi riga se la modalità è riga per riga). |
| $ | Corrisponde alla fine del testo (o alla fine di qualsiasi riga se la modalità è in linea). |
| \(\) O () | Dichiara una "sottoespressione contrassegnata" (espressione raggruppata) che può essere utilizzata in seguito (vedere l'elemento successivo: \ N). Una "sottoespressione contrassegnata" è anche un "blocco". A differenza degli altri operatori, questo (nella sintassi tradizionale) richiede una barra rovesciata, in esteso e Perl, il carattere \ - non è necessario. |
| \N | Dove Nè un numero da 1 a 9; corrisponde N esima sottoespressione contrassegnata (ad es. (abcd)\0, ovvero i caratteri abcd sono contrassegnati con zero). Questo disegno è teorico irregolare, non è stato accettato nella sintassi estesa delle espressioni regolari. |
| * |
Un'espressione racchiusa tra "\(" e "\)" e seguita da "*" deve essere considerata non valida. In alcuni casi, corrisponde a zero o più occorrenze della stringa tra parentesi. In altri, corrisponde all'espressione tra parentesi, dato il carattere "*". |
| \{X,si\} | Corrisponde all'ultimo ( imminente) a un blocco che si verifica almeno X e non più si una volta. Ad esempio, "a\(3,5\)" corrisponde a "aaa", "aaaa" o "aaaaa". A differenza degli altri operatori, questo (nella sintassi tradizionale) richiede una barra rovesciata. |
| .* | Denota qualsiasi numero di qualsiasi carattere tra due parti di un'espressione regolare. |
I metacaratteri ci aiutano a usare varie corrispondenze. Ma come può un metacarattere essere rappresentato da un carattere ordinario, cioè il carattere [ (parentesi quadra) dal valore di una parentesi quadra? Appena:
Per semplificare il compito di alcuni set di caratteri, sono stati combinati nel cosiddetto. classi e categorie di caratteri. POSIX ha standardizzato la dichiarazione di determinate classi e categorie di caratteri, come mostrato nella tabella seguente:
| Classe POSIX | allo stesso modo | designazione |
| [:superiore:] | caratteri maiuscoli | |
| [:inferiore:] | caratteri minuscoli | |
| [:alfa:] | caratteri maiuscoli e minuscoli | |
| [:alnum:] | numeri, caratteri maiuscoli e minuscoli | |
| [:cifra:] | numeri | |
| [:xdigit:] | cifre esadecimali | |
| [:punto:] | [.,!?:…] | segni di punteggiatura |
| [:vuoto:] | [\T] | spazio e TAB |
| [:spazio:] | [\t\n\r\f\v] | salta caratteri |
| [:ctrl:] | simboli di controllo | |
| [:grafico:] | [^ \t\n\r\f\v] | simboli di sigillo |
| [:stampa:] | [^\t\n\r\f\v] | stampa caratteri e salta caratteri |
In regex c'è una cosa come:
Cercherò di descrivere nel modo più chiaro possibile. Diciamo che vogliamo trovare tutto Tag HTML in qualche testo. Dopo aver localizzato il problema, vogliamo trovare i valori tra< и >, insieme a quelle parentesi. Ma sappiamo che i tag hanno lunghezze diverse e che i tag stessi sono almeno 50. Elencarli tutti, racchiudendoli in metacaratteri, è un'operazione troppo laboriosa. Ma sappiamo di avere un'espressione.* (punto asterisco) che caratterizza qualsiasi numero di qualsiasi carattere in una stringa. Usando questa espressione, cercheremo di trovare nel testo (
COSÌ, Come creare livello RAID 10/50 sul controller LSI MegaRAID (rilevante anche per: Intel SRCU42x, Intel SRCS16):
) tutti i valori tra< и >. Di conseguenza, l'INTERA stringa corrisponderà a questa espressione. perché, perché la regex è avida e cerca di catturare QUALSIASI TUTTO il numero di caratteri tra< и >, rispettivamente, l'intera linea, a partire < p> Allora... e finendo ...> apparterrà a questa regola!Spero che l'esempio chiarisca cos'è l'avidità. Per sbarazzarti di questa avidità, puoi procedere nel modo seguente:
Vorrei aggiungere tutto quanto sopra. sintassi estesa delle espressioni regolari:
Le espressioni regolari in POSIX sono simili alla sintassi Unix tradizionale, ma con l'aggiunta di alcuni metacaratteri:
Più indica che precedente simbolo o gruppo può ripetere una o più volte. A differenza di un asterisco, è richiesta almeno una ripetizione.
Punto interrogativo fa precedente carattere o gruppo facoltativo. In altre parole, nella riga corrispondente it può essere assente o presente liscio uno una volta.
barra verticale azioni alternative espressioni regolari. Un carattere specifica due alternative, ma potrebbero essercene di più, è sufficiente utilizzare più linee verticali. Va ricordato che questo operatore utilizza la massima parte possibile dell'espressione. Per questo motivo, l'operatore alternativo viene spesso utilizzato all'interno delle parentesi.
Anche l'uso delle barre rovesciate è stato deprecato: \(…\) diventa (…) e \(…\) diventa (…).
Alla fine del post, ecco alcuni esempi di utilizzo di espressioni regolari:
$ cat testo1 1 mela 2 pera 3 banana $ grep p testo1 1 mela 2 pera $ grep "pp*" testo1 1 mela 2 pera $ cat testo1 | grep "l\|n" 1 mela 3 banana $ echo -e "trova un\n* qui" | grep "\*" * qui $ grep "pl\?.*r" testo1 # p, su righe con r 2 pera $ grep "a.." testo1 # righe con a seguito da almeno 2 caratteri 1 mela 3 banana $ grep "" text1 # cerca righe contenenti 3 o p 1 mela 2 pera 3 banana $ echo -e "trova un\n* qui\nda qualche parte." | grep "[.*]" * qui da qualche parte..nome]$ echo -e "123\n456\n789\n0" | grep "" 123 456 789 $ sed -e "/\(a.*a\)\|\(p.*p\)/s/a/A/g" text1 # sostituisci a con A in tutte le righe where after a viene a o dopo p viene p 1 Mela 2 pera 3 bAnAnA *\./ ULTIMA PAROLA./g" Prima. UN'ULTIMA PAROLA. Questa è un'ULTIMA PAROLA.
Sinceramente, Mc.Sim!
Per elaborare completamente i testi negli script bash con sed e awk, devi solo comprendere le espressioni regolari. Implementazioni di questo strumento più utile si possono trovare letteralmente ovunque, e sebbene tutte le espressioni regolari siano disposte in modo simile, basate sulle stesse idee, lavorare con esse ha determinate caratteristiche in ambienti diversi. Qui parleremo di espressioni regolari adatte per l'uso negli script della riga di comando di Linux.
Questo materiale è inteso come un'introduzione alle espressioni regolari per coloro che potrebbero non sapere cosa sono le espressioni regolari. Pertanto, iniziamo dall'inizio.
A nostro avviso, anche un principiante assoluto capirà immediatamente come funziona e perché è necessario :) Se non capisci bene, continua a leggere e tutto andrà a posto.
Un'espressione regolare è un modello utilizzato da programmi come sed o awk per filtrare il testo. I modelli utilizzano normali caratteri ASCII che rappresentano se stessi e i cosiddetti metacaratteri che svolgono un ruolo speciale, ad esempio consentendo di fare riferimento a determinati gruppi di caratteri.
Lo standard POSIX ERE è spesso implementato nei linguaggi di programmazione. Ti consente di utilizzare molti strumenti durante lo sviluppo di espressioni regolari. Ad esempio, queste possono essere sequenze di caratteri speciali per modelli utilizzati di frequente, come la ricerca di singole parole o serie di numeri nel testo. Awk supporta lo standard ERE.
Esistono molti modi per sviluppare espressioni regolari, a seconda dell'opinione del programmatore e delle caratteristiche del motore con cui vengono create. Non è facile scrivere espressioni regolari generiche comprensibili a qualsiasi motore. Pertanto, ci concentreremo sulle espressioni regolari più comunemente utilizzate e osserveremo le specifiche della loro implementazione per sed e awk.
$ echo "Questo è un test" | sed -n "/test/p" $ echo "Questo è un test" | awk "/test/(stampa $0)"
Trovare testo per modello in sed
Potresti notare che la ricerca di un dato modello viene eseguita senza tener conto della posizione esatta del testo nella stringa. Inoltre, il numero di occorrenze non ha importanza. Dopo che l'espressione regolare trova il testo specificato in qualsiasi punto della stringa, la stringa viene considerata idonea e viene passata per un'ulteriore elaborazione.
Quando lavori con le espressioni regolari, tieni presente che fanno distinzione tra maiuscole e minuscole:
$ echo "Questo è un test" | awk "/Test/(print $0)" $ echo "Questo è un test" | awk "/test/(stampa $0)"
Le espressioni regolari fanno distinzione tra maiuscole e minuscole
La prima espressione regolare non ha trovato corrispondenze, poiché la parola "test", che inizia con una lettera maiuscola, non compare nel testo. Il secondo, configurato per cercare una parola scritta in maiuscolo, ha trovato una stringa adatta nello stream.
Nelle espressioni regolari, puoi usare non solo lettere, ma anche spazi e numeri:
$ echo "Questo è di nuovo un test 2" | awk "/test 2/(stampa $0)"
Trovare una parte di testo contenente spazi e numeri
Gli spazi vengono trattati dal motore delle espressioni regolari come caratteri normali.
.*^${}\+?|()
Se uno di questi è necessario nel modello, dovrà essere sfuggito con una barra rovesciata (barra rovesciata) - \ .
Ad esempio, se è necessario trovare un segno di dollaro nel testo, deve essere incluso nel modello, preceduto da un carattere di escape. Diciamo che c'è un file myfile con il seguente testo:
Ci sono 10$ sulla mia tasca
Il simbolo del dollaro può essere rilevato con uno schema come questo:
$ awk "/\$/(print $0)" miofile
Utilizzo di un carattere speciale in un modello
Inoltre, anche la barra rovesciata è un carattere speciale, quindi se vuoi usarla in un modello, dovrai anche usare l'escape. Sembra che due barre si susseguono:
$ echo "\ è un carattere speciale" | awk "/\\/(stampa $0)"
Barra rovesciata in fuga
Sebbene la barra non sia nell'elenco di caratteri speciali sopra, il tentativo di utilizzarla in un'espressione regolare scritta per sed o awk genererà un errore:
$ echo "3/2" | awk "///(stampa $0)"
Uso errato di una barra in avanti in un modello
Se è necessario, deve anche essere sfuggito:
$ echo "3/2" | awk "/\//(stampa $0)"
Sfuggire a una barra in avanti
$ echo "benvenuto nel sito di likegeeks" | awk "/^likegeeks/(print $0)" $ echo "sito web likegeeks" | awk "/^likegeeks/(stampa $0)"
Cerca uno schema all'inizio di una stringa
Il simbolo ^ è progettato per cercare uno schema all'inizio di una riga, mentre viene preso in considerazione anche il caso dei caratteri. Vediamo come questo influenzerà l'elaborazione di un file di testo:
$ awk "/^this/(print $0)" miofile
Quando si utilizza sed, se si inserisce una fuga in qualsiasi punto all'interno di uno schema, verrà trattato come qualsiasi altro carattere normale:
$ echo "Questo ^ è un test" | sed -n "/s ^/p"
Cap non all'inizio del motivo in sed
In awk, quando si utilizza lo stesso modello, il carattere specificato deve essere sottoposto a escape:
$ echo "Questo ^ è un test" | awk "/s \^/(stampa $0)"
Un coperchio non all'inizio di uno schema in awk
Con la ricerca di frammenti di testo all'inizio della riga, l'abbiamo capito. E se avessi bisogno di trovare qualcosa alla fine di una riga?
Il simbolo del dollaro - $ , che è il carattere di ancoraggio per la fine della riga, ci aiuterà in questo:
$ echo "Questo è un test" | awk "/prova$/(stampa $0)"
Ricerca di testo alla fine di una riga
Entrambi i caratteri di ancoraggio possono essere utilizzati nello stesso modello. Elaboriamo il file myfile , il cui contenuto è mostrato nella figura sottostante, utilizzando la seguente espressione regolare:
$ awk "/^questo è un test$/(print $0)" miofile
Come puoi vedere, il modello ha reagito solo a una stringa che corrispondeva completamente alla sequenza di caratteri data e alla loro posizione.
Ecco come filtrare le righe vuote utilizzando i caratteri di ancoraggio:
$ awk "!/^$/(print $0)" miofile
In questo modello ho utilizzato il simbolo di negazione, il punto esclamativo - ! . Grazie all'utilizzo di tale pattern si ricercano stringhe che non contengono nulla tra l'inizio e la fine della stringa, e grazie a punto esclamativo vengono stampate solo le righe che non corrispondono a questo motivo.
$ awk "/.st/(print $0)" miofile
Come si può vedere dall'output, solo le prime due righe del file corrispondono al pattern, poiché contengono la sequenza di caratteri "st" preceduta da un altro carattere, mentre la terza riga non contiene una sequenza adatta e la quarta riga fa, ma è proprio all'inizio della riga.
Grazie a questo approccio, puoi organizzare una ricerca per qualsiasi personaggio da un determinato set. Per descrivere una classe di caratteri, vengono utilizzate le parentesi quadre -:
$ awk "/th/(print $0)" miofile
Qui stiamo cercando una sequenza di caratteri "th" preceduti dal carattere "o" o dal carattere "i".
Le classi sono utili quando si cercano parole che possono iniziare con una lettera maiuscola o minuscola:
$ echo "questo è un test" | awk "/questo è un test/(print $0)" $ echo "Questo è un test" | awk "/il suo è un test/(print $0)"
Cerca parole che possono iniziare con una lettera minuscola o maiuscola
Le classi di caratteri non sono limitate alle lettere. Anche altri caratteri possono essere usati qui. È impossibile dire in anticipo in quale situazione saranno necessarie le lezioni: tutto dipende dal problema da risolvere.
$ awk "/[^oi]th/(print $0)" miofile
IN questo caso troverà sequenze di caratteri 'th' che non sono preceduti da 'o' o 'i'.
$ awk "/st/(print $0)" miofile
IN questo esempio l'espressione regolare corrisponde alla sequenza di caratteri "st" preceduta da qualsiasi carattere situato, in ordine alfabetico, tra i caratteri "e" e "p".
Gli intervalli possono anche essere creati da numeri:
$ eco "123" | awk "//" $ echo "12a" | awk "//"
Espressione regolare per cercane tre eventuali numeri
Una classe di caratteri può contenere più intervalli:
$ awk "/st/(print $0)" miofile
Questa espressione regolare corrisponderà a tutte le sequenze "st" precedute dai caratteri from intervalli a-f e m-z.
$ echo "abc" | awk "/[[:alpha:]]/(print $0)" $ echo "abc" | awk "/[[:digit:]]/(print $0)" $ echo "abc123" | awk "/[[:digit:]]/(stampa $0)"
$ echo "prova" | awk "/tes*t/(print $0)" $ echo "tessst" | awk "/tes*t/(stampa $0)"
Questo carattere jolly viene solitamente utilizzato per lavorare con parole che sono costantemente scritte in modo errato o per parole che lo consentono diverse varianti Spelling corretto:
$ echo "Mi piace il colore verde" | awk "/colou*r/(print $0)" $ echo "Mi piace il colore verde " | awk "/colore*r/(stampa $0)"
Trovare una parola che ha ortografie diverse
In questo esempio, la stessa espressione regolare corrisponde sia alla parola "colore" che alla parola "colore". Ciò è dovuto al fatto che il carattere "u", seguito da un asterisco, può essere assente o comparire più volte di seguito.
Un'altra caratteristica utile derivante dal carattere asterisco è combinarlo con un punto. Questa combinazione consente all'espressione regolare di rispondere a qualsiasi numero di qualsiasi carattere:
$ awk "/this.*test/(print $0)" miofile
In questo caso, non importa quanti e quali caratteri ci sono tra le parole "questo" e "test".
L'asterisco può essere utilizzato anche con le classi di caratteri:
$ echo "st" | awk "/s*t/(print $0)" $ echo "sat" | awk "/s*t/(print $0)" $ echo "imposta" | awk "/s*t/(stampa $0)"
In tutti e tre gli esempi, l'espressione regolare funziona perché l'asterisco dopo la classe di caratteri significa che se viene trovato un qualsiasi numero di caratteri "a" o "e", o se non vengono trovati, la stringa corrisponderà al modello dato.
Qui esamineremo i caratteri più comunemente usati nei modelli ERE, che ti saranno utili quando crei le tue espressioni regolari.
$ echo "tet" | awk "/tes?t/(print $0)" $ echo "test" | awk "/tes?t/(print $0)" $ echo "test" | awk "/tes?t/(stampa $0)"
Come puoi vedere, nel terzo caso, la lettera "s" ricorre due volte, quindi l'espressione regolare non risponde alla parola "test".
Il punto interrogativo può essere utilizzato anche con le classi di caratteri:
$ echo "tst" | awk "/t?st/(print $0)" $ echo "test" | awk "/t?st/(print $0)" $ echo "tast" | awk "/t?st/(print $0)" $ echo "taest" | awk "/t?st/(print $0)" $ echo "teest" | awk "/t?st/(stampa $0)"
Se non ci sono caratteri della classe nella stringa, o uno di essi ricorre una volta, l'espressione regolare funziona, ma non appena compaiono due caratteri nella parola, il sistema non trova più una corrispondenza per il modello nel testo.
$ echo "prova" | awk "/te+st/(print $0)" $ echo "teest" | awk "/te+st/(print $0)" $ echo "tst" | awk "/te+st/(stampa $0)"
In questo esempio, se nella parola non è presente il carattere "e", il motore delle espressioni regolari non troverà corrispondenze nel testo. Il simbolo più funziona anche con le classi di caratteri, in questo modo è simile all'asterisco e al punto interrogativo:
$ echo "tst" | awk "/t+st/(print $0)" $ echo "test" | awk "/t+st/(print $0)" $ echo "teast" | awk "/t+st/(print $0)" $ echo "teeast" | awk "/t+st/(stampa $0)"
In questo caso, se la stringa contiene qualsiasi carattere della classe, il testo verrà considerato corrispondente al pattern.
$ echo "tst" | awk "/te(1)st/(print $0)" $ echo "test" | awk "/te(1)st/(print $0)"
Parentesi graffe nei modelli, trovare il numero esatto di occorrenze
Nelle versioni precedenti di awk, dovevi usare l'opzione della riga di comando --re-interval affinché il programma riconoscesse gli intervalli nelle espressioni regolari, ma nelle versioni più recenti non lo fai.
$ echo "tst" | awk "/te(1,2)st/(print $0)" $ echo "test" | awk "/te(1,2)st/(print $0)" $ echo "teest" | awk "/te(1,2)st/(print $0)" $ echo "teeest" | awk "/te(1,2)st/(print $0)"
In questo esempio, il carattere "e" deve comparire 1 o 2 volte nella stringa, quindi l'espressione regolare risponderà al testo.
Le parentesi graffe possono essere utilizzate anche con le classi di caratteri. I principi che ti sono già familiari si applicano qui:
$ echo "tst" | awk "/t(1,2)st/(print $0)" $ echo "test" | awk "/t(1,2)st/(print $0)" $ echo "teest" | awk "/t(1,2)st/(print $0)" $ echo "teeast" | awk "/t(1,2)st/(stampa $0)"
Il modello reagirà al testo se il carattere "a" o il carattere "e" compare una o due volte al suo interno.
$ echo "Questo è un test" | awk "/test|esame/(print $0)" $ echo "Questo è un esame" | awk "/test|esame/(print $0)" $ echo "Questo è qualcos'altro" | awk "/prova|esame/(stampa $0)"
In questo esempio, l'espressione regolare è configurata per cercare le parole "test" o "esame" nel testo. Prestare attenzione al fatto che tra i frammenti del modello e il simbolo | che li separa. non dovrebbero esserci spazi.
I frammenti di espressioni regolari possono essere raggruppati utilizzando le parentesi. Se raggruppi una certa sequenza di caratteri, verrà percepita dal sistema come un carattere normale. Cioè, ad esempio, i metacaratteri di ripetizione possono essere applicati ad esso. Ecco come appare:$ echo "Mi piace" | awk "/Like(Geeks)?/(print $0)" $ echo "LikeGeeks" | awk "/Mi piace(Geeks)?/(print $0)"
In questi esempi, la parola "Geeks" è racchiusa tra parentesi, seguita da un punto interrogativo. Ricordiamo che il punto interrogativo significa "0 o 1 ripetizione", di conseguenza l'espressione regolare corrisponderà sia alla stringa "Like" che alla stringa "LikeGeeks".
$ echo $PERCORSO | sed "s/:/ /g"
Il comando replace supporta le espressioni regolari come modelli per la ricerca di testo. In questo caso, tutto è estremamente semplice, stiamo cercando il simbolo dei due punti, ma nessuno si preoccupa di usare qualcos'altro qui: tutto dipende dall'attività specifica.
Ora dobbiamo scorrere l'elenco risultante in un ciclo ed eseguire le azioni necessarie per contare il numero di file presenti. Schema generale lo script sarà così:
miopercorso=$(echo $PERCORSO | sed "s/:/ /g") for directory in $miopercorso do done
Ora scriviamo il testo completo dello script, utilizzando il comando ls per ottenere informazioni sul numero di file in ciascuna delle directory:
#!/bin/bash miopercorso=$(echo $PERCORSO | sed "s/:/ /g") count=0 per la directory in $miopercorso do check=$(ls $directory) per l'elemento in $check do count=$ [ $count + 1 ] done echo "$directory - $count" count=0 done
Quando si esegue lo script, potrebbe risultare che alcune directory di PATH non esistono, tuttavia, ciò non gli impedirà di contare i file nelle directory esistenti.
Il valore principale di questo esempio è che utilizzando lo stesso approccio è possibile risolvere problemi molto più complessi. Quale dipende dalle tue esigenze.
[e-mail protetta]
Il nome utente, username , può essere composto da caratteri alfanumerici e da alcuni altri caratteri. Vale a dire, questo è un punto, un trattino, un trattino basso e un segno più. Il nome utente è seguito dal segno @.
Armati di questa conoscenza, iniziamo ad assemblare l'espressione regolare dal suo lato sinistro, che serve per controllare il nome utente. Ecco cosa abbiamo ottenuto:
^(+)@
Questa espressione regolare può essere letta come segue: "All'inizio della riga deve esserci almeno un carattere tra quelli del gruppo indicato tra parentesi quadre, dopodiché deve esserci un segno @".
Ora è la coda del nome host - hostname . Le stesse regole si applicano qui come per il nome utente, quindi il modello per esso sarebbe simile a questo:
(+)
Il nome di dominio di primo livello è soggetto a regole speciali. Possono essere presenti solo caratteri alfabetici, che devono essere almeno due (ad esempio, tali domini di solito contengono un codice paese) e non più di cinque. Tutto ciò significa che il modello per il controllo dell'ultima parte dell'indirizzo sarà così:
\.({2,5})$
Puoi leggerlo così: "Prima deve esserci un punto, poi - da 2 a 5 caratteri alfabetici, dopodiché la riga finisce".
Dopo aver preparato i modelli per le singole parti dell'espressione regolare, mettiamoli insieme:
^(+)@(+)\.({2,5})$
Ora resta solo da testare cosa è successo:
$eco" [e-mail protetta]" | awk "/^(+)@(+)\.((2,5))$/(print $0)" $ echo " [e-mail protetta]" | awk "/^(+)@(+)\.((2,5))$/(print $0)"
Il fatto che il testo passato ad awk venga visualizzato sullo schermo significa che il sistema lo ha riconosciuto come indirizzo email.
In questa serie di materiali, di solito abbiamo mostrato esempi molto semplici di script bash che consistevano letteralmente in poche righe. Diamo un'occhiata a qualcosa di più grande la prossima volta.
Cari lettori! Usi espressioni regolari durante l'elaborazione del testo negli script della riga di comando?
Uno dei comandi più utili e versatili in Terminale Linux- comando "grep". Grep è un acronimo che sta per "global regular expression print" (ovvero, "cerca ovunque linee di espressioni regolari corrispondenti e visualizzale"). Ciò significa che grep può essere utilizzato per vedere se l'input corrisponde a determinati modelli.
Questo programma apparentemente banale è molto potente se usato correttamente. La sua capacità di ordinare l'input in base a regole complesse lo rende un raccoglitore popolare in molte catene di comandi.
Questo tutorial esamina alcune delle funzionalità del comando grep e poi passa all'uso delle espressioni regolari. Tutte le tecniche descritte in questa guida possono essere applicate alla gestione di un server virtuale.
Nella sua forma più semplice, grep viene utilizzato per abbinare modelli letterali in file di testo. Ciò significa che se il comando grep riceve una parola di ricerca, stamperà ogni riga del file che contiene quella parola.
Ad esempio, puoi usare grep per cercare righe contenenti la parola "GNU" nella versione 3 della GNU General Public License su un sistema Ubuntu.
cd /usr/share/licenze-comuni
grep "GNU" GPL-3
LICENZA PUBBLICA GENERALE GNU
13. Utilizzo con la GNU Affero General Public License.
sotto la versione 3 della GNU Affero General Public License in un singolo
...
...
Il primo argomento, "GNU", è il modello da cercare, e il secondo argomento, "GPL-3", è il file di input da cercare.
Di conseguenza, verranno visualizzate tutte le righe contenenti il modello di testo. In qualche Distribuzioni Linux il motivo cercato verrà evidenziato nelle righe visualizzate.
Per impostazione predefinita, grep cerca semplicemente modelli fortemente specificati nel file di input e stampa le righe che trova. Tuttavia, il comportamento di grep può essere modificato aggiungendo alcuni flag aggiuntivi.
Se vuoi ignorare le maiuscole e minuscole del parametro di ricerca e cercare variazioni sia maiuscole che minuscole del pattern, puoi usare le utility "-i" o "--ignore-case".
Ad esempio, puoi utilizzare grep per cercare nello stesso file la parola "licenza" in lettere maiuscole, minuscole o miste.
grep -i "licenza" GPL-3
LICENZA PUBBLICA GENERALE GNU
di questo documento di licenza, ma non è consentito modificarlo.
La GNU General Public License è una licenza libera con copyleft per
Le licenze per la maggior parte del software e altri lavori pratici sono progettate
la GNU General Public License ha lo scopo di garantire la tua libertà di
GNU General Public License per la maggior parte del nostro software; si applica anche a
"Questa Licenza" si riferisce alla versione 3 della GNU General Public License.
"Il Programma" si riferisce a qualsiasi opera protetta da copyright concessa in licenza ai sensi del presente
...
...
Come puoi vedere, l'output contiene "LICENSE", "license" e "License". Se c'era un'istanza di "LiCeNsE" nel file, sarebbe stata emessa anch'essa.
Se vuoi trovare tutte le righe che non contengono il modello specificato, puoi usare i flag "-v" o "--invert-match".
Ad esempio, puoi utilizzare il seguente comando per cercare nella licenza BSD tutte le righe che non contengono la parola "the":
grep -v "il" BSD
Tutti i diritti riservati.
Redistribuzione e utilizzo in forma sorgente e binaria, con o senza
sono soddisfatte:
può essere utilizzato per approvare o promuovere prodotti derivati da questo software
senza specifica preventiva autorizzazione scritta.
QUESTO SOFTWARE VIENE FORNITO DAI REGENTI E CONTRIBUTORI "COSÌ COM'È"" E
QUALSIASI GARANZIA ESPRESSA O IMPLICITA, INCLUSE, MA NON LIMITATE A, THE
...
...
Come puoi vedere, le ultime due righe sono state restituite come non contenenti la parola "the" perché il comando "ignore case" non è stato utilizzato.
È sempre utile conoscere i numeri di riga in cui sono state trovate corrispondenze. Possono essere trovati usando i flag "-n" o "--line-number".
Se applichi questo flag nell'esempio precedente, verrà visualizzato il seguente output:
grep -vn "il" BSD
2:Tutti i diritti riservati.
3:
4: Ridistribuzione e utilizzo in forma sorgente e binaria, con o senza
6: sono soddisfatte:
13: può essere utilizzato per approvare o promuovere prodotti derivati da questo software
14: senza specifica preventiva autorizzazione scritta.
15:
16:QUESTO SOFTWARE VIENE FORNITO DAI REGENTI E CONTRIBUTORI ``COSÌ COM'È"" E
17: QUALSIASI GARANZIA ESPLICITA O IMPLICITA, INCLUSE, MA NON LIMITATE A, LE
...
...
È ora possibile fare riferimento al numero di riga secondo necessità per apportare modifiche a ogni riga che non contiene "il".
Come accennato nell'introduzione, grep sta per "global regular expression print". Un'espressione regolare è una stringa di testo che descrive uno specifico modello di ricerca.
Diverse applicazioni e linguaggi di programmazione utilizzano le espressioni regolari in modi leggermente diversi. Questa guida copre solo un piccolo sottoinsieme di come vengono descritti i modelli Grep.
Gli esempi precedenti di ricerca delle parole "GNU" e "the" cercavano espressioni regolari molto semplici che corrispondessero esattamente alla stringa di caratteri "GNU" e "the".
È più corretto rappresentarli come corrispondenze di stringhe di caratteri che come corrispondenze di parole. Man mano che acquisisci familiarità con schemi più complessi, questa distinzione diventerà più significativa.
I pattern che corrispondono esattamente ai caratteri dati sono chiamati "alfabetici" perché corrispondono al pattern lettera per lettera, carattere per carattere.
Tutti i caratteri alfabetici e numerici (così come alcuni altri caratteri) corrispondono letteralmente a meno che non siano stati modificati da altri motori di espressione.
Le ancore sono caratteri speciali che indicano la posizione in una stringa di una corrispondenza desiderata.
Ad esempio, puoi specificare che la ricerca cerchi solo stringhe contenenti la parola "GNU" proprio all'inizio. Per fare ciò, devi usare l'ancora "^" prima della stringa letterale.
In questo esempio, vengono emesse solo le righe che contengono la parola "GNU" all'inizio.
grep "^GNU" GPL-3
GNU General Public License per la maggior parte del nostro software; si applica anche a
GNU General Public License, puoi scegliere qualsiasi versione mai pubblicata
Analogamente, l'ancora "$" può essere utilizzata dopo una stringa letterale per indicare che la corrispondenza è valida solo se la stringa di caratteri cercata si trova alla fine della stringa di testo.
La seguente espressione regolare emette solo quelle righe che contengono "e" alla fine:
grep "e$" GPL-3
che non esiste alcuna garanzia per questo software gratuito. Per entrambi gli utenti" e
I termini e le condizioni precisi per la copia, la distribuzione e
l'alternativa è consentita solo occasionalmente e non commercialmente, e
rete può essere negata quando la modifica stessa materialmente e
influisce negativamente sul funzionamento della rete o viola le regole e
provvisoriamente, a meno che e fino a quando il titolare del copyright esplicitamente e
riceve una licenza dai licenzianti originali, per eseguire, modificare e
produrre, utilizzare, vendere, offrire in vendita, importare e altrimenti eseguire, modificare e
Il punto (.) viene utilizzato nelle espressioni regolari per indicare che qualsiasi carattere può apparire nella posizione specificata.
Ad esempio, se desideri trovare corrispondenze contenenti due caratteri e quindi la sequenza "cept", utilizzerai il seguente modello:
grep "..cept" GPL-3
uso, che è proprio dove è più inaccettabile. Pertanto, noi
violazione ai sensi della legge sul copyright applicabile, ad eccezione dell'esecuzione su a
informa l'utente che non vi è alcuna garanzia per il lavoro (tranne che per il
sotto forma di una licenza scritta separatamente, o indicate come eccezioni;
Non puoi propagare o modificare un'opera coperta se non espressamente
9. Accettazione non richiesta per avere copie.
...
...
Come puoi vedere, nei risultati vengono visualizzate le parole "accetta" e "tranne", così come le varianti di queste parole. Il modello corrisponderebbe anche alla sequenza "z2cept" se ce n'era una nel testo.
Inserendo un gruppo di caratteri tra parentesi quadre (""), è possibile indicare che qualsiasi carattere tra parentesi può trovarsi in questa posizione.
Ciò significa che se hai bisogno di trovare stringhe contenenti "too" o "two", puoi specificare brevemente queste variazioni usando il seguente schema:
grep "a" GPL-3
anche i tuoi programmi.
Gli sviluppatori che utilizzano la GNU GPL proteggono i tuoi diritti in due passaggi:
una rete di computer, senza trasferimento di una copia, non sta trasmettendo.
Sorgente corrispondente da un server di rete senza alcun costo.
...
...
Come puoi vedere, entrambe le varianti sono state trovate nel file.
I caratteri tra parentesi forniscono anche diverse funzioni utili. È possibile specificare che il modello corrisponda a tutto tranne i caratteri tra parentesi iniziando l'elenco di caratteri tra parentesi con il carattere "^".
In questo esempio viene utilizzato il template ".ode", che non deve corrispondere alla sequenza "code".
grep "[^c]ode" GPL-3
1. Codice sorgente.
modello, per dare a chiunque possieda il codice oggetto sia (1) a
l'unica significativa modalità di utilizzo del prodotto.
notare come questo quando si avvia in una modalità interattiva:
Vale la pena notare che la seconda riga di output contiene la parola "codice". Questo non è un errore regex o grep.
Piuttosto, questa riga è stata dedotta perché contiene anche la sequenza di "modalità" di corrispondenza del modello che si trova nella parola "modello". Cioè, la stringa è stata emessa perché corrispondeva al modello.
Un'altra caratteristica utile delle parentesi è la possibilità di specificare un intervallo di caratteri invece di digitare ciascun carattere separatamente.
Ciò significa che se vuoi trovare ogni riga che inizia con una lettera maiuscola, puoi utilizzare il seguente schema:
grep "^" GPL-3
GNU General Public License per la maggior parte del nostro software; si applica anche a
licenza. Ogni licenziatario viene chiamato "tu". "Licenze" e
Librerie di sistema o strumenti generici o generalmente disponibili gratuitamente
fonte.
...
...
A causa di alcuni problemi di ordinamento intrinseci, è preferibile utilizzare le classi di caratteri standard POSIX anziché l'intervallo di caratteri utilizzato nell'esempio precedente per un risultato più accurato.
Ci sono molte classi di personaggi non trattate in questa guida; ad esempio, per eseguire la stessa procedura dell'esempio precedente, è possibile utilizzare la classe di caratteri "[:upper:]" tra parentesi.
grep "^[[:upper:]]" GPL-3
GNU General Public License per la maggior parte del nostro software; si applica anche a
Gli Stati non dovrebbero consentire ai brevetti di limitare lo sviluppo e l'uso di
licenza. Ogni licenziatario viene chiamato "tu". "Licenze" e
Componente, e (b) serve solo per consentire l'uso del lavoro con quello
Componente principale o per implementare un'interfaccia standard per la quale un
Librerie di sistema o strumenti generici o generalmente disponibili gratuitamente
fonte.
Il Prodotto dell'utente viene trasferito al destinatario in perpetuo o per a
...
...
Uno dei metacaratteri più comunemente usati è il carattere "*", che significa "ripeti il carattere o l'espressione precedente 0 o più volte".
Ad esempio, se vuoi trovare ogni riga con parentesi aperte o chiuse che contengono solo lettere e singoli spazi tra loro, puoi usare la seguente espressione:
grep "(*)" GPL-3
distribuzione (con o senza modifiche), mettendo a disposizione del
rispetto all'opera nel suo insieme, che (a) è inclusa nella forma normale di
Componente, e (b) serve solo per consentire l'uso del lavoro con quello
(se presente) su cui viene eseguito il lavoro eseguibile o un compilatore utilizzato per farlo
(incluso un mezzo di distribuzione fisico), accompagnato dal file
(compreso un supporto fisico di distribuzione), accompagnato da a
posto (gratis o a pagamento) e offrire un accesso equivalente al
...
...
A volte potresti voler cercare un punto letterale o una parentesi aperta letterale. Perché questi personaggi lo sono certo valore nelle espressioni regolari, devi "sfuggirle" dicendo a grep di non usare il loro significato speciale in questo caso.
È possibile eseguire l'escape di questi caratteri utilizzando una barra rovesciata (\) prima di un carattere che di solito ha un significato speciale.
Ad esempio, se vuoi trovare una stringa che inizia con una lettera maiuscola e termina con un punto, puoi utilizzare la seguente espressione. La barra rovesciata prima dell'ultimo punto dice al comando di "evitarla", in modo che l'ultimo punto rappresenti un punto letterale e non abbia il significato di "qualsiasi carattere":
grep "^.*\.$" GPL-3
fonte.
Licenza facendo eccezioni da una o più delle sue condizioni.
La licenza consiste nell'astenersi completamente dal trasmettere il Programma.
TUTTA LA MANUTENZIONE NECESSARIA, LA RIPARAZIONE O LA CORREZIONE.
TALI DANNI.
Aggiungi anche informazioni su come contattarti tramite posta elettronica e cartacea.
Il comando grep può essere utilizzato anche con il linguaggio delle espressioni regolari esteso utilizzando il flag "-E" o chiamando il comando "egrep" invece di "grep".
Questi comandi aprono le possibilità delle "espressioni regolari estese". Le espressioni regolari estese includono tutti i metacaratteri di base, oltre a metacaratteri aggiuntivi per esprimere corrispondenze più complesse.
Una delle caratteristiche più semplici e utili delle espressioni regolari estese è la capacità di raggruppare le espressioni e usarle nel loro insieme.
Le parentesi vengono utilizzate per raggruppare le espressioni. Se è necessario utilizzare le parentesi al di fuori delle espressioni regolari estese, è possibile "sfuggirle" con una barra rovesciata
grep "\(raggruppamento\)" file.txt
grep -E "(raggruppamento)" file.txt
egrep "(raggruppamento)" file.txt
Le espressioni precedenti sono equivalenti.
Proprio come le parentesi quadre specificano diverse corrispondenze possibili per un singolo carattere, l'alternanza consente di specificare corrispondenze alternative per stringhe di caratteri o insiemi di espressioni.
Il carattere della barra verticale "|" viene utilizzato per indicare l'alternanza. L'alternanza è spesso usata nel raggruppamento per indicare che uno di due o più opzioni dovrebbe essere considerata una coincidenza.
In questo esempio, devi trovare "GPL" o "General Public License":
grep -E "(GPL|Licenza pubblica generica)" GPL-3
La GNU General Public License è una licenza libera con copyleft per
la GNU General Public License ha lo scopo di garantire la tua libertà di
GNU General Public License per la maggior parte del nostro software; si applica anche a
prezzo. Le nostre licenze per il pubblico generico sono progettate per assicurarti che tu
Gli sviluppatori che utilizzano la GNU GPL proteggono i tuoi diritti in due passaggi:
Per la protezione degli "sviluppatori" e degli autori, la GPL spiega chiaramente
autori", la GPL richiede che le versioni modificate siano contrassegnate come
hanno progettato questa versione della GPL per proibire la pratica per coloro
...
...
L'alternanza può essere utilizzata per scegliere tra due o più opzioni; per fare ciò, è necessario inserire le restanti opzioni nel gruppo di selezione, separandole ciascuna con il carattere barra verticale "|".
Nelle espressioni regolari estese, ci sono metacaratteri che indicano la frequenza con cui un carattere si ripete, proprio come il metacarattere "*" indica le corrispondenze del carattere o della stringa di caratteri precedente 0 o più volte.
Per indicare che un carattere corrisponde 0 o più volte, puoi utilizzare il carattere "?". Renderà il carattere o il set di caratteri precedente essenzialmente opzionale.
In questo esempio, aggiungendo la sequenza "copy" al gruppo facoltativo, vengono visualizzate le corrispondenze "copyright" e "right":
grep -E "(copia)?giusto" GPL-3
Copyright (C) 2007 Free Software Foundation, Inc.
Per proteggere i tuoi diritti, dobbiamo impedire ad altri di negarti
questi diritti o chiedendoti di rinunciare ai diritti. Pertanto, hai
conoscere i propri diritti.
Gli sviluppatori che utilizzano la GNU GPL proteggono i tuoi diritti in due passaggi:
(1) far valere il copyright sul software e (2) offrirvi questa Licenza
"Copyright" significa anche leggi simili al copyright che si applicano ad altri tipi di
...
...
Il simbolo "+" corrisponde alle espressioni 1 o più volte. Funziona quasi come il carattere "*", ma quando si utilizza "+", l'espressione deve corrispondere almeno 1 volta.
La seguente espressione corrisponde alla stringa "free" più 1 o più caratteri diversi da spazi bianchi:
grep -E "libero[^[:spazio:]]+" GPL-3
La GNU General Public License è una licenza libera con copyleft per
per toglierti la libertà di condividere e modificare le opere. Al contrario,
la GNU General Public License ha lo scopo di garantire la tua libertà di
Quando parliamo di software libero, ci riferiamo alla libertà, no
avere la libertà di distribuire copie di software libero (e far pagare per
libertà che hai ricevuto. Devi assicurarti che anche loro ricevano
proteggere la libertà degli utenti di modificare il software
della GPL, come necessario per proteggere la libertà degli utenti.
i brevetti non possono essere usati per rendere il programma non libero.
Le parentesi graffe ("( )") possono essere utilizzate per specificare il numero di ripetizioni delle corrispondenze. Questi caratteri vengono utilizzati per indicare il numero esatto, l'intervallo e i limiti superiore e inferiore del numero di volte in cui un'espressione può corrispondere.
Se vuoi trovare tutte le stringhe che contengono una combinazione di tre vocali, puoi usare la seguente espressione:
grep -E "(3)" GPL-3
cambiato, in modo che i loro problemi non vengano attribuiti erroneamente a
autori delle versioni precedenti.
riceverlo, con qualsiasi mezzo, a condizione che tu lo faccia in modo evidente e
conferire ai sensi del comma precedente, oltre al diritto al possesso dell'
lavoro coperto in modo da soddisfare contemporaneamente i tuoi obblighi ai sensi del presente
Se devi trovare tutte le parole lunghe 16-20 caratteri, usa la seguente espressione:
grep -E "[[:alpha:]](16,20)" GPL-3
determinate responsabilità se si distribuiscono copie del software o se
lo modifichi: responsabilità di rispettare la libertà altrui.
c) Proibire false dichiarazioni sull'origine di quel materiale, o
In molti casi, il comando grep è utile per trovare modelli all'interno di file o all'interno di una gerarchia. sistema di file. Risparmia molto tempo, quindi dovresti familiarizzare con i suoi parametri e la sintassi.
Le espressioni regolari sono ancora più versatili e possono essere utilizzate in molti programmi popolari. Ad esempio, molti editori di testo utilizzare le espressioni regolari per trovare e sostituire il testo.
Inoltre, i linguaggi di programmazione avanzati utilizzano espressioni regolari per eseguire procedure su dati specifici. La capacità di lavorare con le espressioni regolari sarà utile per risolvere problemi comuni legati al computer.
Tag: ,Le espressioni regolari sono uno strumento molto potente per la corrispondenza di modelli, l'elaborazione e la modifica di stringhe che possono essere utilizzate per risolvere una varietà di problemi. Ecco i principali:
Questo non è un elenco completo, le espressioni regolari ti permettono di fare molto di più. Ma per i nuovi utenti, possono sembrare troppo complicati, dal momento che sono formati usando linguaggio speciale. Ma date le possibilità offerte, le espressioni regolari di Linux dovrebbero essere conosciute e utilizzate da tutti. Amministratore di sistema.
In questo articolo tratteremo le espressioni regolari bash per principianti in modo che tu possa comprendere tutte le funzionalità di questo strumento.
Nelle espressioni regolari possono essere utilizzati due tipi di caratteri:
I caratteri regolari sono lettere, numeri e segni di punteggiatura che compongono qualsiasi stringa. Tutti i testi sono composti da lettere e puoi usarle nelle espressioni regolari per trovare la posizione desiderata nel testo.
I metacaratteri sono qualcos'altro, sono ciò che dà potere alle espressioni regolari. Con i metacaratteri puoi fare molto di più che cercare un singolo carattere. Puoi cercare combinazioni di caratteri, utilizzare un numero dinamico di caratteri e selezionare intervalli. Tutti i caratteri speciali possono essere divisi in due tipi, si tratta di caratteri sostitutivi che sostituiscono i caratteri ordinari, oppure operatori che indicano quante volte un carattere può essere ripetuto. La sintassi per un'espressione regolare sarebbe simile a questa:
simbolo_regolare carattere_operatore speciale
jolly_sostituzione carattere_operatore speciale
È importante notare che una barra deve essere utilizzata prima dei caratteri speciali letterali per indicare che il carattere speciale segue. È vero anche il contrario, se vuoi usare un carattere speciale che viene usato senza una barra come carattere normale, allora devi aggiungere una barra.
Ad esempio, vuoi trovare la stringa 1+ 2=3 nel testo. Se usi questa stringa come espressione regolare, non troverai nulla, perché il sistema interpreta il più come un carattere speciale che dice che il precedente deve essere ripetuto una o più volte. Quindi deve essere sottoposto a escape: 1 + 2 = 3. Senza escape, la nostra espressione regolare corrisponderebbe solo alla stringa 11=3 o 111=3 e così via. Non è necessario mettere un trattino prima dell'uguale, perché non è un carattere speciale.
Ora che abbiamo coperto le basi e sai come funziona tutto, resta da consolidare nella pratica le conoscenze acquisite sulle espressioni regolari di linux grep. Due caratteri speciali molto utili sono ^ e $, che indicano l'inizio e la fine di una riga. Ad esempio, vogliamo ottenere tutti gli utenti registrati nel nostro sistema il cui nome inizia con s. Quindi puoi usare l'espressione regolare "^s". Puoi usare il comando egrep:
egrep "^s" /etc/passwd
Se vogliamo selezionare le righe dall'ultimo carattere nella riga, possiamo usare $. Ad esempio, selezioniamo tutti gli utenti del sistema, senza shell, i record su tali utenti terminano con false:
egrep "false$" /etc/passwd
Per visualizzare i nomi utente che iniziano con s o d utilizzare questa espressione:
egrep "^" /etc/passwd
Lo stesso risultato si può ottenere utilizzando il simbolo "|". La prima opzione è più adatta per gli intervalli e la seconda è più spesso utilizzata per ordinario o / o:
egrep "^" /etc/passwd
Ora selezioniamo tutti gli utenti il cui nome non è lungo tre caratteri. Il nome utente termina con i due punti. Possiamo dire che può contenere qualsiasi carattere alfabetico, che deve essere ripetuto tre volte, prima dei due punti:
egrep "^w(3):" /etc/passwd
In questo articolo, abbiamo trattato le espressioni regolari di Linux, ma queste erano solo le basi. Se scavi un po' più a fondo, scoprirai che puoi fare cose molto più interessanti con questo strumento. Il tempo speso per imparare le espressioni regolari ne varrà sicuramente la pena.
Alla fine della conferenza di Yandex sulle espressioni regolari:
L'utilità grep è uno strumento molto potente per trovare e filtrare le informazioni testuali. Questo articolo mostra diversi esempi del suo utilizzo, che ti permetteranno di apprezzarne le capacità.
L'uso principale di grep è cercare parole o frasi in file e flussi di output. Puoi cercare digitando riga di comando query e ambito di ricerca (file).
Ad esempio, per trovare la stringa "needle" nel file hystack.txt, utilizzare il seguente comando:
$ grep ago pagliaio.txt
Di conseguenza, grep visualizzerà tutte le occorrenze di needle che incontra nel contenuto del file haystack.txt. È importante notare che in questo caso grep cerca un insieme di caratteri, non una parola. Ad esempio, verranno visualizzate le righe contenenti la parola "needless" e altre parole che contengono la sequenza "needle".
Per dire a grep che stai cercando una parola particolare, usa l'opzione -w. Questa chiave restringerà la ricerca solo alla parola specificata. Una parola è una query delimitata su entrambi i lati da spazi bianchi, segni di punteggiatura o interruzioni di riga.
$ grep -w ago pagliaio.txt
Non devi limitare la tua ricerca a un solo file, grep può anche cercare in un gruppo di file e i risultati della ricerca elencheranno il file che corrisponde. L'opzione -n aggiungerà anche il numero di riga in cui è stata trovata una corrispondenza e l'opzione -r ti consentirà di eseguire ricerca ricorsiva. Questo è molto utile durante la ricerca tra file con testi di origine del programma.
$ grep -rnw nome_funzione /home/www/dev/mioprogramma/
Il nome del file verrà elencato prima di ogni corrispondenza. Se hai bisogno di nascondere i nomi dei file, usa l'opzione -h, al contrario, se sono necessari solo i nomi dei file, specifica l'opzione -l
Nell'esempio seguente, cercheremo gli URL in un file di registro IRC e mostreremo le ultime 10 corrispondenze.
$ grep -wo http://.* canale.log | coda
L'opzione -o dice a grep di emettere solo la corrispondenza del modello, non l'intera riga. L'output di grep viene reindirizzato al comando tail, che stampa le ultime 10 righe per impostazione predefinita.
Ora conteremo il numero di messaggi inviati al canale irc da determinati utenti. Ad esempio, tutti i messaggi che ho inviato da casa e dal lavoro. Differiscono nel nickname, a casa uso il nickname user_at_home e al lavoro user_at_work.
$ grep -c "^user_at_(casa|lavoro)" channel.log
Con l'opzione -c, grep stampa solo il numero di corrispondenze trovate, non le corrispondenze stesse. La stringa di ricerca è racchiusa tra virgolette perché contiene caratteri speciali che la shell potrebbe riconoscere come caratteri di controllo. Si noti che le virgolette non sono incluse nel modello di ricerca. La barra rovesciata "" viene utilizzata per eseguire l'escape dei caratteri di servizio.
Cerchiamo tra i messaggi delle persone a cui piace "gridare" nel canale. Per “gridare” intendiamo messaggi scritti in stile blondy, uno LETTERE MAIUSCOLE. Per escludere risultati casuali di abbreviazioni dalla ricerca, cercheremo parole di cinque o più caratteri:
$ grep -w "+(5,)" canale.log
Per una descrizione più dettagliata, vedere la pagina man di grep.
Qualche altro esempio:
# grep root /etc/passwd root:x:0:0:root:/root:/bin/bash operator:x:11:0:operator:/root:/sbin/nologin
Visualizza le righe del file /etc/passwd che contengono la stringa root.
# grep -n root /etc/passwd 1:root:x:0:0:root:/root:/bin/bash 12:operator:x:11:0:operator:/root:/sbin/nologin
Inoltre, vengono visualizzati i numeri di riga contenenti la stringa di ricerca.
# grep -v bash /etc/passwd | grep -v nologin sync:x:5:0:sync:/sbin:/bin/sync shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown halt:x:7:0:halt:/sbin :/sbin/halt news:x:9:13:news:/var/spool/news: mailnull:x:47:47::/var/spool/mqueue:/dev/null xfs:x:43:43: X Font Server:/etc/X11/fs:/bin/false rpc:x:32:32:Portmapper Utente RPC:/:/bin/false nscd:x:28:28:NSCD Daemon:/:/bin/false named:x:25:25:Named:/var/named:/bin/false squid:x:23:23::/var/spool/squid:/dev/null ldap:x:55:55:LDAP Utente: /var/lib/ldap:/bin/false apache:x:48:48:Apache:/var/www:/bin/false
Controlla quali utenti non stanno usando bash, escludendo quegli account utente che hanno nologin come loro shell.
# grep -c false /etc/passwd 7
Conta il numero di account che hanno /bin/false come shell.
# grep -i giochi ~/.bash* | grep -v storia
Questo comando elenca le righe di tutti i file nella directory home dell'utente corrente che iniziano con ~/.bash, ad eccezione di quei file che hanno la cronologia della stringa nei loro nomi, al fine di escludere le corrispondenze trovate nel file ~/.bash_history in cui può essere la stessa stringa in lettere maiuscole o minuscole. Si prega di notare che la ricerca della parola "giochi" viene eseguita, è possibile sostituirla con qualsiasi altra.
comando grep ed espressioni regolari
A differenza dell'esempio precedente, ora verranno visualizzate solo quelle righe che iniziano con la stringa "root":
# grep ^root /etc/passwd root:x:0:0:root:/root:/bin/bash
Se vogliamo vedere quali account non utilizzavano affatto la shell, cerchiamo le righe che terminano con ":":
# grep:$ /etc/passwd news:x:9:13:news:/var/spool/news:
Per verificare se la variabile PATH nel file ~/.bashrc viene esportata, seleziona prima le righe con "export" e poi cerca le righe che iniziano con la stringa "PATH"; in questo caso, MANPATH e altri non verranno visualizzati modi possibili:
# grep esporta ~/.bashrc | grep "PATH" export PATH="/bin:/usr/lib/mh:/lib:/usr/bin:/usr/local/bin:/usr/ucb:/usr/dbin:$PATH"
Classi di caratteri
Un'espressione tra parentesi quadre è un elenco di caratteri racchiusi tra i caratteri [" e "]"". Corrisponde a qualsiasi singolo carattere in questo elenco; se il primo carattere dell'elenco è "^", corrisponde a qualsiasi carattere NON presente nell'elenco. Ad esempio, l'espressione regolare "" corrisponde a qualsiasi singola cifra.
All'interno di un'espressione tra parentesi quadre è possibile specificare un intervallo costituito da due caratteri separati da un trattino. Quindi l'espressione corrisponde a qualsiasi singolo carattere che, secondo le regole di ordinamento, ricade all'interno di questi due caratteri, compresi questi due caratteri; questo tiene conto della sequenza di fascicolazione e del set di caratteri specificati nella locale. Ad esempio, quando la locale predefinita è C, l'espressione "" è equivalente all'espressione "". Esistono molti locali in cui l'ordinamento viene eseguito in ordine di dizionario, e in questi locali "" di solito non è equivalente a "", in essi, ad esempio, può essere equivalente all'espressione "". Per utilizzare l'interpretazione tradizionale di un'espressione tra parentesi, è possibile utilizzare la locale C impostando variabile d'ambiente LC_ALL valore "C".
Infine, ci sono classi di caratteri che hanno un nome specifico e sono specificate all'interno di espressioni tra parentesi quadre. Informazioni aggiuntive vedere le pagine man o la documentazione di grep per queste espressioni predefinite.
# grep /etc/group sys:x:3:root,bin,adm tty:x:5: mail:x:12:mail,postfix ftp:x:50: nessuno:x:99: floppy:x:19: xfs:x:43: nfsnobody:x:65534: postfix:x:89:
L'esempio visualizza tutte le righe che contengono il carattere "y" o il carattere "f".
Caratteri generici (metacaratteri)
Utilizzo "." per abbinare ogni singolo carattere. Se vuoi ottenere un elenco di tutte le parole inglesi prese da un dizionario contenente cinque caratteri che iniziano con "c" e finiscono con "h" (utile per risolvere i cruciverba):
#grep "
Se vuoi visualizzare le righe che contengono un carattere punto come valore letterale, usa l'opzione -F con il comando grep. Simboli "< " и «>» indica la presenza di una stringa vuota prima e, rispettivamente, dopo le lettere specificate. Ciò significa che le parole nel file delle parole devono essere scritte in modo appropriato. Se vuoi trovare tutte le parole nel testo secondo i modelli specificati senza tenerne conto righe vuote ometti i caratteri "< " и «>”, per una ricerca più precisa delle sole parole, utilizzare l'opzione -w.
Per cercare in modo simile parole che possono contenere qualsiasi numero di caratteri tra "c" e "h", utilizzare un asterisco (*). L'esempio seguente seleziona tutte le parole che iniziano con "c" e terminano con "h" dal dizionario di sistema:
#grep "
Se vuoi cercare un carattere letterale asterisco in un file o in un flusso di output, usa le virgolette singole per farlo. L'utente nell'esempio seguente prova prima a trovare l'"asterisco" nel file /etc/profile senza usare le virgolette, senza ottenere alcun risultato. Quando vengono utilizzate le virgolette, il risultato viene stampato nel flusso di output:
# grep * /etc/profile # grep "*" /etc/profile for i in /etc/profile.d/*.sh ; Fare
