6  *grep & regular expressions

6.1  Yleistä

Monet Unix-komennot tarvitsevat yleistä merkkijonovertailua, keinoa kysyä ''kuuluuko merkkijono x joukkoon X?'' Tähän tarkoitukseen käytetään merkkijonomalleja, erikoismerkkejä sisältäviä merkkijonoja, jotka vastaavat tiettyjen sääntöjen mukaisesti joukkoa merkkijonoja. Yksi yleinen tällainen on regular expression, formaalien kielten teoriasta lainattu termi jolle ei ole oikein hyvää suomennosta.

Historiallisista syistä eri komennot käyttävät erilaisia ja yhteensopimattomia merkkijonomalleja:

• glob pattern (jatkossa vain GP) on jo esitelty (). Sitä käyttävät sh tiedostonimien levittämiseen, merkkijono-operaatioihin (${var...} ja case-lauseeseen, ksh:n [[...]] sekä ulkoisista komennoista find.
• basic regular expression (jatkossa BRE) on historiallisesti vanhin ja yhä yleisin merkkijonomalli. Sitä käyttävät standardikomennoista grep, ed, sed, expr ja pax.
• extended regular expression (jatkossa ERE) on edellisen laajennus tai oikeammin vain uusi versio siitä. Standardikomennoista EREjä käyttävät grep -E ja awk.

Jotkin komennot käyttävät vielä edellisistä poikkeavia malleja, yleensä edellisiä jotenkin rajoitettuina, esim. tr. Huomionarvoinen on myös case-lauseen syntaksiin kuuluva |, joka olennaisesti laajentaa sen ymmärtämää GP:tä, vaikka muodollisesti onkin eri asia.

Lisäksi monet epästandardit komennot käyttävät omia versioitaan, lähinnä erilaisia laajennuksia edellisiin. Erityisesti ksh tuntee omat laajennuksensa GP:hen () ja Gnu-versiot standardikomennoista tuntevat erinäisiä regexp-laajennuksia, samoin perl.

6.2  grep - File pattern searcher

Komento grep ja käsite regular expression liittyvät kiinteästi yhteen, sen nimikin on lyhenne ed-editorin syntaksista: Global/RegExp/Print. Sen syntaksi on seuraavanlainen:

grep [-E|-F] [-c|-l|-q] [-insvx] [[-e] pattern_list...] [-f pattern_file...] [file...]

ja se etsii tiedostosta annettua mallia (-eja) vastaavia rivejä. Oletuksena malli (pattern) on basic regular expression (BRE), mistä enemmän alla, ja (vain) mallia vastaavat rivit (rivit joilla esiintyy mallia vastaava merkkijono) tulostetaan.

Optiot:

-E Käytä laajennettua regexp syntaksia (extended regular expression, ERE).

-F Etsi vakiomerkkijonoa (ei regexp).

-c Tulosta vain löydettyjen rivien lukumäärä.

-e pattern_list Etsittävät mallit (komentoriviargumentteina).

-f pattern_file Lue etsittävät mallit tiedostosta, yksi per rivi.

-i Samaista isot ja pienet kirjaimet.

-l Tulosta vain niiden tiedostojen nimet, joista malli löytyi.

-n Tulosta rivinumerot löydetyille riveille (kunkin tiedoston alusta ykkösellä alkaen).

-q Älä tulosta mitään.

-s Ei virhettä tiedostoista joita ei voi lukea tai joita ei ole.

-v Tulosta vain rivit jotka eivät vastaa mallia.

-x Tulosta vain rivit jotka kokonaisuudessaan vastaavat mallia.

Optioita -e ja -f voi antaa useita. Jos kumpaakaan ei ole annettu, ensimmäinen ei-optio argumentti tulkitaan malliksi. (Siten -e on tarpeen vain jos malleja halutaan antaa useita tai malli alkaa viivalla (vrt. --).) Kussakin tapauksessa useita malleja voidaan antaa erottamalla ne rivinvaihdolla (grep on tiukasti rivipohjainen, rivinvaihtoja sisältäviä malleja ei voi käyttää).

Jos tiedostoargumentteja on useita, grep tulostaa tiedostonimet kustakin tiedostosta löytyvien rivien (tai löydettyjen rivien lukumäärän optiolla -c) alkuun kaksoispisteellä erotettuna (optiolla -l aina vain tiedostonimet).

Exit status on 0 jos ainakin yksi mallia vastaava rivi löytyi, 1 jos ei, > 1 jos tapahtui virhe (paitsi optiolla -q nolla myös virheen tapahtuessa jos rivi löytyi).

Komennosta on historiallisesti myös versiot egrep ja fgrep, jotka toimivat kuten grep -E ja grep -F.

6.3  Basic Regular Expressions

BRE:t tulkitaan seuraavien sääntöjen mukaisesti:

• Tavalliset merkit (muut paitsi \ . [ * ^ $) vastaavat itseään.
• Kenoviiva (\) ja jokin erikoismerkeistä \ . [ * ^ $ vastaa ko. merkkiä.
• Piste (.) vastaa yhtä mielivaltaista merkkiä.
• [...] (hakasulkulauseke) vastaa yhtä lausekkeen sisällön määräämään joukkoon kuuluvaa merkkiä. Hakasulkujen välissä olevat merkit tulkitaan seuraavasti:

  • Jos vasenta hakasulkua seuraa ^ , joukko tulkitaan seuraavien merkkien määräämän joukon komplementiksi. Muualla kuin heti [:n perässä sillä ei ole erikoismerkitystä.
  • Merkeillä . * [ \ ei ole erikoismerkitystä hakasulkujen sisällä.
  • char1-char2 tarkoittaa merkkejä jotka ovat > = char1 ja < = char2 (lajittelujärjestyksessä, riippuu LC_COLLATE:sta).
  • Oikea hakasulku edustaa itseään heti vasemman hakasulun tai sitä mahdollisesti seuraavan ^ :n jäljessä.
  • Tavuviiva edustaa itseään heti vasemman hakasulun ja sitä mahdollisesti seuraavien ^ :n ja ]:n jäljessä. (Siis jos halutaan sekä ] että - mukaan, edellinen ensin.)
  • [:class:] tarkoittaa luokkaan class kuuluvaa merkkiä. Tunnetut luokat ovat [:alnum:], [:alpha:], [:cntrl:], [:digit:], [:graph:], [:lower:], [:print:], [:punct:], [:space:], [:upper:] ja [:xdigit:] (samat kuin kohdassa 4.6.2).
  • [=char=] tarkoittaa merkkejä jotka ovat aakkosjärjestyksessä samanarvoisia merkin char kanssa. (Esim. [=e=] vastaa ranskassa (ja suomessa!) merkkejä e, é, è ja ë).
  • [.symb.] tarkoittaa lajitteluelementtiä joka vastaa symbolia symb. Käytetään lähinnä silloin kun monesta merkistä muodostuva lajitteluelementti pitää erottaa vastaavista erillisistä merkeistä. (Esim. espanjassa grep 'a[[.ch.]x]b' löytäisi jonot 'achb' ja 'axb'.)

• Usean peräkkäisen BRE:n yhdistelmä vastaa niitä vastaavien merkkijonojen yhdistelmää.
• BRE:n osa voidaan rajoittaa symbolipareilla \( ja \). Tällainen rajaus ei vaikuta siihen mitä ko. BRE:n osa vastaa (paitsi ankkureiden ^ $ toiminta niissä on standardin mukaan ''optional'').
• \n, missä n on numero 1-9, vastaa järjestyksessä n:ttä edeltävää sulkulauseketta \(...\). Esim. \([0-9]\)\1 tarkoittaa samaa numeroa kahdesti peräkkäin.
• Tähti * tarkoittaa edeltävän merkin tai suluilla rajoitetun osalausekkeen tai osalausekeviittauksen (\n) toistamista nolla tai useampia kertoja. Rivin alussa * edustaa itseään.

• \{m[,n]\} tarkoittaa edeltävän merkin, osalausekkeen tai osalausekeviittauksen toistamista m-n kertaa (\{m,\} vähintään m, \{m\} tasan m).

• ^ BRE:n alussa ankkuroi sen alun, niin että se vastaa vain verrattavan merkkijonon alkua. (Esim. ''^ ab'' vastaa ''abc'':tä mutta ei ''aab'':tä.) Muualla kuin BRE:n alussa ^ vastaa itseään.
• $ BRE:n lopussa ankkuroi vastaavasti sen lopun. Muualla kuin BRE:n lopussa $ vastaa itseään. Jos molempia ankkureita on käytetty, koko merkkijonon pitää täsmätä.

Erikoismerkit tulkitaan seuraavan prioriteettijärjestyksen mukaisesti:

1. [= =] [: :] [. .]
2. \<erikoismerkki>
3. [...]
4. \( \) \n
5. * ja \{m[,n]\}
6. yhdistely
7. ^ ja $ ankkureina

Useasta mahdollisesta osamerkkijonosta BRE vastaa ensimmäistä (vasemmanpuoleisinta), jos niitä on useita pisintä niistä. Tällä ei ole merkitystä grepin kanssa mutta esim. sedin ja exprin kanssa kylläkin.

Kenoviivan vaikutusta muiden kuin edellämainittujen merkkien edellä ei ole määritelty, ja se vaihtelee järjestelmästä toiseen.

Huom. Rivinvaihdolla ei ole mitään erityisasemaa RE:ssä sinänsä, vaikka monet komennot moisen rajoituksen asettavatkin (mutta esim. sed ei).

Kaiken mitä voi tehdä GP:llä voi tehdä BRE:lläkin, mutta ei päinvastoin. Seuraavassa taulukossa on esimerkkejä niiden eroista:

GP	BRE
?	.
*	.*
a*	a.*
a.*	a\..* tai a[.].*
*[!0-9]*	.*[^ 0-9].*
^ ?^	\^ .^
\?	?
\*a	*a
[0-9][0-9][0-9][0-9]	[0-9]\{4\}

Seuraavassa taulukossa on BRE:llä ja ksh:n GP:llä esimerkkejä malleista joita ei perus-GP:llä voi tehdä:

BRE	ksh GP
[-+]\{0,1}[0-9][0-9]*	?([-+])+([0-9])
[A-Za-z][A-Za-z0-9_]*	[A-Za-z]*([A-Za-z0-9_])
[0-9]\{1,3\}	[0-9]?([0-9])?([0-9])
\([[:alpha:]]\)[[:blank:].,]\1	(ei onnistu)
(ei onnistu)	?(Kalle|Pekka|Tapani)

Viimemainittu ei siis onnistu BRE:llä lainkaan, seuraavassa esiteltävällä ERE:llä kylläkin. Myös case-lauseella se onnistuu helposti.

6.4  Extended Regular Expressions

ERE:t tulkitaan muuten samoin kuin BRE:t paitsi:

• Erikoismerkkejä jotka pitää suojata kenoviivalla jos haluaa niiden esittävän itseään ovat . [ \ ( ) * + ? { | ^ ja $. Oikeaa sulkua ei tarvitse suojata ellei vastaavaa vasenta sulkua ole lausekkeessa, muut on suojattava aina paitsi hakasulkulausekkeen sisällä (erityisesti $ ^ ja * sijainnista riippumatta, toisin kuin BRE:ssä).
• Ankkurit ^ ja $ toimivat myös osalausekkeissa.
• Osalausekkeet rajataan suluilla ilman kenoviivoja.
• Aaltosulkuja käytetään toistoon syntaksilla {m[,n]}} ilman kenoviivoja.
• Osalausekeviittauksia (\n) ei ole.
• Plus-merkki + tarkoittaa edeltävän merkin tai osalausekkeen toistamista yhden tai useampia kertoja.
• Kysymysmerkki ? tarkoittaa edeltävän merkin tai osalausekkeen toistamista nolla tai yksi kertaa.
• Pystyviiva (putkimerkki) | kahden ERE:n välissä tarkoittaa jompaa kumpaa niistä. (Esim. a(b|c)d vastaa ''abd'':tä ja ''acd'':tä; Pe(ikko|kka) sanoja ''Pekka'' ja ''Peikko''.)

Erikoismerkkien prioriteetti on soveltuvin osin sama:

1. [= =] [: :] [. .]
2. \<erikoismerkki>
3. [...]
4. ( )
5. * + ? ja {m[,n]}}
6. yhdistely
7. ^ ja $ ankkureina
8. |

BRE	ERE
[-+]\{0,1\}[0-9][0-9]*	[-+]?[0-9]+
[-+]\{0,1\}[0-9]\{1,10\}	[-+]?[0-9]{1,10}
\(/[a-zA-Z0-9]\{1,14\}\)\{1,\}	(/[a-zA-Z0-9]{1,14})+
\([[:alpha:]]\)[[:blank:].,]\1	(ei onnistu)
(ei onnistu)	Kalle|Pekka|Tapani

Siis joitakin asioita voi tehdä vain BRE:llä ja joitakin vain ERE:llä. (Tosin esim. Gnu grep kyllä tuntee osalausekeviittauksen myös ERE:n kanssa.) Teoriassa ksh:n GP on yhtä ilmaisuvoimainen kuin ERE, käytännössä usein paljon hankalampi (erityisesti toisto-operaattorin puutteen vuoksi).

6.5  Esimerkkejä

Toisinaan käytettävä komento ratkaisee millaista merkkijonomallia on käytettävä, mutta grep tuntee kaksi erilaista ja usein saman asian voi tehdä monella eri komennolla jotka käyttävät erilaisia malleja. Seuraavassa esimerkkejä valinnan avuksi.

• Jos testattavana on vain yksi merkkijono ja testiin riittää GP, helpoin ja yleensä myös nopein tapa on case tai ksh:ssa [[...]]. Esim. onko tiedoston tarkennin .c:

  case "$name" in
        *.c) ... ;;
  esac
  
  if [[ $name = *.c ]] # ksh 
  then ...
  
  if expr "$name" : '.*\.c$' >/dev/null
  then ...
  
  if printf "%s\n" "$name" | grep -q '\.c$' 
  then ...
  
  if printf "%s\n" "$name" | grep -q '[.]c$' 
  then ...
  

• Jos ehto on hieman monimutkaisempi, sitä ei useinkaan pysty GP:llä esittämään. Ehdon kääntäminen tai jakaminen useammaksi onnistuu usein, mutta se saattaa mennä hankalaksi. Yksittäisen merkkijonon tutkiminen BRE:llä on usein helpointa komennolla expr (muista implisiittinen ankkuri ^ ). Esim. Onko sanassa iso alkukirjain ja loput pieniä ja vain kirjaimia a-z:

  case "$sana" in
    [!A-Z]*|?*[!a-z]*) echo BAD ;;
    *) echo OK ;;
  esac
  
  if [[ $sana = [!A-Z]* || $sana = ?*[!a-z]* ]]
  then echo BAD 
  else echo OK 
  fi
  
  if expr "$sana" : '[A-Z][a-z]*$' >&-
  then echo OK
  else echo BAD
  fi
  
  if printf "%s\n" "$sana" | grep -q '^[A-Z][a-z]*$'
  then echo OK
  else echo BAD
  fi
  
  if printf "%s\n" "$sana" | grep -qx '[A-Z][a-z]*'
  then echo OK
  else echo BAD
  fi
  

• Jos tekstiä etsitään tiedostosta, grep on yleensä helpoin ratkaisu, vaikka malli olisikin yksinkertainen. Esim. haettava tiedostosta A-kirjaimella alkavat rivit:

  grep '^A' "$file"
  
  while read line 
  do case "$line" in
  	A*) printf "%s\n" "$line" ;;
     esac
  done <"$file"
  

• Esim. etsittävä tiedostosta epätyhjät rivit:

  grep -v '^$' "$file"
  
  grep . "$file"
  

• Jos etsittäviä vaihtoehtoja on useita, ne voi antaa grepille yhtenä monelle riville jaettuna argumenttina mutta se vaikeuttaa luettavuutta (ja aiheuttaa vaikeuksia joidenkin ei-POSIX-shellien kanssa). Yleensä on parempi käyttää useaa -e optiota tai -E:tä jolla ne saa yhdeksi:

  grep 'Kalle
  Pekka
  Jussi' "$file"
  
  grep -e Kalle -e Pekka -e Jussi "$file"
  
  grep -E 'Kalle|Pekka|Jussi' "$file"
  
  while read line ;do
    case "$line" in
      Pekka|Kalle|Jussi) printf "%s\n" "$line" ;;
    esac
  done <"$file"
  
  

• Jos halutaan etsiä dynaamisesti luotua (esim. käyttäjältä saatua) merkkijonoa tai jos vain et ole varma erikoismerkkien suojauksesta, grep -F on turvallinen ratkaisu. Esim. tutkittava esiintyykö tiedostossa merkkijonoja **.?[a] tai a[2*3]+4:

  grep -e '*\*\.\[a]' -e 'a\[2\*3]+4' "$file"
  
  grep -F -e '**.?[a]' -e 'a[2*3]+4' "$file"
  

• Esim. etsitään laskutoimitusmerkkejä +-*/:

  grep '[-+*/]' "$file"
  
  grep -F -e + -e - -e '*' -e / "$file"
  

  Huomaa merkkien järjestys hakasuluissa!

• Jos halutaan erottaa merkkijonosta osa erilleen, grep ei auta. Jos GP riittää voi käyttää shellin merkkijono-operaatioita, muuten expriä (kyseeseen voi tulla myös cut tai myöhemmin esiteltävät sed ja awk, erityisesti jos halutaan käsitellä kokonainen tiedosto). Esim. dirname (ilman erikoistapauksia):

  dirname=${name%/*}
  
  dirname=$(expr "$name" : '\(.*\)/[^/]*')
  

• Esim. halutaan merkkijonon toinen merkki:

  x=${mjono#?}
  x="${x%${x#?}}"
  
  x=$(expr "$mjono" : '.\(.\)')
  
  x=$(printf "%s\n" "$mjono" | cut -b2)
  

• Jos halutaan samaistaa isot ja pienet kirjaimet, grep -i on yleensä helpoin ratkaisu, joskin ksh:lla on tähänkin oma keinonsa:

  case "$nimi" in
    [kK][aA][lL][lL][eE]) echo "kalle se on" ;;
  esac
  
  [[ "$nimi" = [kK][aA][lL][lL][eE] ]] &&
    echo "kalle se on" 
  
  typeset -l tmp="$nimi"
  [[ "$tmp" = kalle ]] && echo "kalle se on" 
  
  expr "$nimi" : "[kK][aA][lL][lL][eE]$" &&
    echo "kalle se on" 
  
  printf "%s\n" "$sana" | grep -iq '^kalle$' &&
    echo "kalle se on" 
  

• Jos halutaan monimutkaisempia toistorakenteita, grep -E on yleensä selkein. Esim. tutkittava onko annettu merkkijono mahdollisesti etumerkillinen kokonaisluku:

  case "$luku" in
    [!-+0-9]*|?*[!0-9]*|'') echo "not a number" ;;
    *)  echo "good number!" ;;
  esac
  
  case "${luku#[-+]}" in
    *[!0-9]*|'') echo "not a number" ;;
    *)  echo "good number!" ;;
  esac
  
  if expr "$luku" '[-+]\{0,1\}[0-9][0-9]*$' >&-
  then echo "good number!" 
  else echo "not a number" 
  fi
  
  if printf "%s\n" "$luku" | grep -q '^[-+]\{0,1\}[0-9][0-9]*$' 
  then echo "good number!" 
  else echo "not a number" 
  fi
  
  if printf "%s\n" "$luku" | grep -qx '[-+]\{0,1\}[0-9]\{1,\}' 
  then echo "good number!" 
  else echo "not a number" 
  fi
  
  if printf "%s\n" "$luku" | grep -Eqx '[-+]?[0-9]+' 
  then echo "good number!" 
  else echo "not a number" 
  fi
  

• Esim. Tutkittava onko merkkijono laillinen liukuluku, jossa voi olla desimaalipilkku ja eksponentti merkittynä isolla tai pienellä E:llä (desimaalipilkun vasemmalla puolella on oltava ainakin yksi numero):

  expr "$luku" :\
  '[-+]\{0,1\}[0-9]{\1,}.\{0,1}[0-9]*\([Ee][-+]\{0,1\}[0-9]\{1,\}\)\{0,1\}$' &&
  echo "looks OK floating point number to me"
  
  printf "%s\n" "$luku" | 
  grep -qix '[-+]\{0,1\}[0-9]{\1,}.\{0,1}[0-9]*\(e[-+]\{0,1\}[0-9]\{1,\}\)\{0,1\}' &&
  echo "looks OK floating point number to me"
  
  printf "%s\n" "$luku" | 
  grep -Eqix '[-+]?[0-9]+.?[0-9]*(e[-+]?[0-9]+)?' &&
  echo "looks OK floating point number to me"
  

• Jos pitää ilmaista monimerkkisiä vaihtoehtoja lausekkeen sisällä, grep -E on usein ainoa järkevä vaihtoehto. Esim. etsittävä tiedostosta sanoja agoraphobia ja sesquipedalophobia sekä em. englanninkielisessä muodossa että kokonaan tai osittain suomalaisittain translitteroituina (qu->k ja ph->f):

  grep -i 'agoraphobia
  agorafobia
  sesquipedalophobia
  sesquipedalofobia
  seskipedalophobia
  seskipedalofobia' "$file"
  
  grep -Ei 'agora(ph|f)obia
  ses(qu|k)ipedalo(ph|f)obia' "$file"
  
  grep -Ei '(agora|ses(qu|k)ipedalo)(ph|f)obia' "$file"
  

• Esim. etsitään tiedostosta sanaa ''ei'' erillisenä sanana, ts. niin että sen molemmin puolin on joko rivinvaihto tai jokin ei-kirjain:

  grep -i '[^[:alpha:]]ei[^[:alpha:]]
  ^ei[^[:alpha:]]
  [^[:alpha:]]ei$
  ^ei$' "$file"
  
  grep -iE '(^|[^[:alpha:]])ei([^[:alpha:]]|$)' "$file"
  

• Esim. etsittävä työhakemistosta .tex-tarkenteiset tiedostot, joissa on vähintään 250 riviä:

  wc -l *.tex | 
  while read lines file 
  do if [ $lines -ge 250 ] printf "%s\n" "$lines $file"
  done
  
  wc -l *.tex | 
  while read lines file
  do case "$lines" in [3-9][0-9][0-9]|2[5-9][0-9]|[0-9][0-9][0-9][0-9]*)
  	printf "%s\n" "$lines $file" ;;
     esac
  done
  
  wc -l *.tex | grep -E '^ *([3-9][0-9]{2}|2[5-9][0-9]|[0-9]{4,}) '
  
  wc -l *.tex | grep -E '[3-9][0-9]{2}|2[5-9][0-9]|[0-9]{4,}'
  

  Viimeinen vaihtoehto listaa myös tiedostot joiden nimessä on numero > 250, mutta kelpaa interaktiivisesti tai jos muuten tiedetään ettei sellaisia ole.

• Jos tarvitaan osalausekeviittauksia, tarvitaan BRE. Grep on parempi jos käsitellään tiedostoa tai halutaan käyttää sen optioita kuten -i, expr jos testataan yhtä merkkijonoa tai halutaan erottaa siitä osa. Esim. etsitään tiedostosta rivejä jotka ovat muotoa x="x" tai x='x' (muuttujan arvoksi sijoitetaan sen nimi jonkinlaisissa lainausmerkeissä):

  grep -x '\([a-zA-Z][a-zA-Z0-9_]*\)=\(["'\'']\)\1\2' "$file"
  
  while read line ;do
    expr "$line" : '\(\([a-zA-Z][a-zA-Z0-9_]*\)=\(["'\''\)\2\3\)$'
  done <"$file"
  

• Jos tarvittava komento ei osaa halutunlaisia malleja, voi ongelman usein ratkaista yhdistelemällä komentoja. Esim. etsittävä hakemistopuusta tiedostoja joilla on sama tarkennin kaksi kertaa peräkkäin ('koe.c.c' tms):

  find . -type f | grep '\(\..*\)\1$'
  
  find . -type f | grep '\(\.[^.][^.]*\)\1$'   
  

  Jälkimmäinen jättää pois tyhjät tarkentimet (kahteen pisteeseen päättyvät nimet).

• Esim. halutaan poistaa tiedostonimestä siinä mahdollisesti oleva tuplatarkennin:

  FNAME=$(expr "$FNAME" : "\(.*\(\..*\)\)\2")
  

• Jos vaihtoehtoisia malleja on paljon tai ne generoidaan dynaamisesti, on usein helpointa käyttää optiota -f. Esim. Tarkistettava että jokainen /etc/passwd:ssä oleva ryhmä on myös /etc/groupissa:

  cut -d: -f3 /etc/group >groups
  cut -d: -f4 /etc/passwd | grep -vx -f groups
  
  cut -d: -f4 /etc/passwd | grep -vx "$(cut -d: -f3 /etc/group)"
  

6.6  Gnu extensions

Gnu-projektin komennot tuntevat joukon laajennuksia BRE/ERE-syntaksiin:

\ < sanan alku

\ > sanan loppu

\b sanan raja (alku tai loppu)

\B muu kuin sanan raja

\w kirjain tai numero ([[:alnum:]])

\W sama kuin [^ [:alnum:]]

\| BRE:ssä sama kuin | ERE:ssä

\ < , \ > , \b ja \B vastaavat nollamittaista merkkijonoa ao. paikassa, ts. toimivat ankkureina ^ :n ja $:n tapaan. Lisäksi osalausekeviittaukset toimivat myös ERE:ssä. (Siis Gnu ERE ja BRE ovat toiminnallisesti identtisiä, ainoa ero on syntaksissa.)

Gnu grep tuntee myös joukon epästandardeja optioita ja pitkiä synonyymejä standardioptioille. Niihin ei tässä puututa sen enempää.

Seuraava: 7. sed
Edellinen: 5.44-72 Standardikomennot N-Z