Vizualizare sursă pentru „Expresie regulată”

[[Fișier:The_river_effect_in_justified_text.jpg|miniatura|Rezultatele unui match al șablonului <br>
<code>(?<=\.) {2,}(?</code><code>=[A-Z])</code>.<br>
Se caută cel puțin două spații, dar numai dacă apar imediat după un punct (.) și înainte de o literă mare.]]
[[Fișier:Kleene.jpg|miniatura|[[Stephen Cole Kleene]], care a contribuit la punerea bazelor conceptului]]
O '''expresie regulată''', '''regex''' sau '''regexp'''<ref>[http://www.regular-expressions.info/tutorial.html What Regular Expressions Are Exactly - Terminology]</ref> (numită uneori '''expresie rațională''')<ref name="Mitkov2003">{{cite book|author=Ruslan Mitkov|title=The Oxford Handbook of Computational Linguistics|url=https://books.google.com/books?id=yl6AnaKtVAkC&pg=PA754|year=2003|publisher=Oxford University Press|isbn=978-0-19-927634-9|page=754}}</ref><ref name="Lawson2003">{{cite book|author=Mark V. Lawson|title=Finite Automata|url=https://books.google.com/books?id=MDQ_K7-z2AMC&pg=PA98|date=17 September 2003|publisher=CRC Press|isbn=978-1-58488-255-8|pages=98–100}}</ref> este, în {{Ill-wd|Q2878974|3=informatica teoretică}} și în teoria [[Limbaje formale|limbajelor formale]], un șir de {{Ill-wd|Q32483|3=caractere}} care definesc un'' {{Ill-wd|Q1503724|3=șablon}} de căutare''. De obicei, acest șablon este apoi utilizat de către {{Ill-wd|Q374040|3=algoritmii de căutare pe șiruri}} pentru operațiuni de „căutare” sau „căutare și înlocuire” pe {{Ill-wd|Q184754|3=șiruri de caractere}}.

Conceptul a apărut în anii 1950, când matematicianul american [[Stephen Cole Kleene]] a formalizat descrierea unui ''[[limbaj regulat]]''. Conceptul a intrat în uz comun împreună cu utilitarele de prelucrare a textului din [[UNIX|Unix]]. Astăzi, există diferite sintaxe pentru scrierea expresiilor regulate, una fiind standardul {{Ill-wd|Q14658}} și alta, utilizată pe scară largă, fiind sintaxa [[Perl]].

Expresiile regulate sunt folosite în {{Ill-wd|Q4182287|3=motoarele de căutare}}, de dialogurile de căutare și înlocuire ale [[Procesor de text|procesoarelor]] și [[Editor de text|editoarelor de text]], în utilitare de prelucrare a textului, cum ar fi [[sed]] și [[AWK]] și în analiza lexicală. Multe [[Limbaj de programare|limbaje de programare]] furnizează capabilități  regex fie built-in, fie prin intermediul unor {{Ill-wd|Q188860|3=biblioteci}}.

== Șabloane ==
Sintagma ''expresii regulate'' (și, în consecință, ''regexuri'') este adesea folosită cu referire la ''sintaxa'' standard'', textuală'' (distinctă de notația matematică descrisă mai jos) pentru reprezentarea ''șabloanelor'' cărora trebuie să se conformeze textul găsit. Fiecare caracter dintr-o expresie regulată (adică fiecare caracter din șirul care descrie șablonul) este considerat a fi un {{Ill-wd|Q1415908|3=metacaracter}} (caracter cu semnificație specială), sau un caracter obișnuit. De exemplu, în regexul <code>a.</code> ''a'' este un caracter literal, care se potrivește doar cu litera „a”, iar ''.'' este un metacaracter care se potrivește cu orice caracter, cu excepția sfârșitului de linie. Prin urmare, acest regex ar identifica, de exemplu, șirurile „a” sau „ax” sau „a0”. Împreună, metacaracterele și caracterele literale pot fi utilizate pentru a identifica materialul textual pe anumit șablon, sau să prelucreze o serie de instanțe ale sale. Potrivirile pot varia de la o egalitate precisă la o asemănare foarte generală (controlată de metacaractere). De exemplu, <code>.</code> este un șablon general, <code><nowiki>[a-z]</nowiki></code> (care potrivește toate literele de la „a” la „z”) este mai puțin general și <code>a</code> este un șablon exact (se potrivește doar cu „a”). Sintaxa metacaracterelor este special concepută pentru a reprezenta obiective prescrise într-un mod concis și flexibil pentru a dirija automatizarea procesării de text pe o varietate de date de intrare, într-o formă ușor de introdus folosind o [[tastatură]] ASCII standard.

Un caz foarte simplu de expresie regulată în această sintaxă ar fi pentru a localiza același cuvânt scris în două moduri diferite într-un [[editor de text]], expresia regulată <code>p[âî]ine</code> se potrivește atât cu „pâine”, cât și cu „pîine”. {{Ill-wd|Q283679|3=Wildcardurile}} ar putea realiza și ele acest lucru, dar sunt mai limitate în ceea ceea ce pot modela (având mai puține metacaractere și un limbaj de bază simplu).

Contextul obișnuit al {{Ill-wd|Q283679|3=caracterelor wildcard}} îl reprezintă gruparea unor denumiri similare dintr-o listă de fișiere, pe când regexurile sunt de obicei folosite în aplicații care efectuează identificări de șabloane pe șiruri de caractere de text în general. De exemplu, regexul <code>^[ \t]+|[ \t]+$</code> identifică excesul de spațiu de la începutul sau de la sfârșitul unei linii. Un regex mai avansat folosit pentru a identifica orice numeral este <code>^[+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?</code><code>$ </code>. Vezi secțiunea de ''[[#Examples|Exemple]]'' secțiunea pentru mai multe exemple.
[[Fișier:Thompson-kleene-star.svg|dreapta|miniatura|Traducerea [[Închidere Kleene|închiderii Kleene]]<br>
(''s''* înseamnă „zero sau mai mulți de ''s''”)]]
Un '''procesor regex''' traduce o expresie regulată scrisă în sintaxa de mai sus într-o reprezentare internă care poate fi executată și comparată cu un {{Ill-wd|Q184754|3=șir de caractere}} reprezentând textul în care se caută. O abordare posibilă este cea a {{Ill-wd|Q7795667|3=algoritmului de construcție al lui Thompson}} pentru a construi un{{Ill-wd|Q617295|3= automat finit nedeterminist}} (AFN), care este apoi {{Ill-wd|Q2106494|3=făcut determinist}} și {{Ill-wd|Q837528|3=AFD}}-ul rezultat este rulat pe șirul de text pentru a recunoaște cuvinte care se potrivesc cu expresia regulată.
Imaginea prezinta schema AFN ''N''(''s''<code>*</code>) obținută din expresia regulată ''s''<code>*</code>, unde ''s'' reprezintă la rândul său o expresie regulată mai simplă, care a fost deja {{Ill-wd|Q264164|3=recursiv}} tradusă în AFN-ul ''N''(''s'').

== Istoria ==
Expresii regulate își au originea în 1956, când matematicianul [[Stephen Cole Kleene]] a descris [[Limbaj regulat|limbajele regulate]] cu ajutorul notației sale matematice numită ''mulțimi regulate''.{{Sfn|Kleene|1956}} Acestea au apărut în {{Ill-wd|Q2878974|3=informatica teoretică}}, în subdomenii ale [[Teoria automatelor|teoriei automatelor]] (modelelor de calcul) și în descrierea și clasificarea [[Limbaje formale|limbajelor formale]]. O altă implementare timpurie a {{Ill-wd|Q1503724|3=identificării șabloanelor}} a fost limbajul {{Ill-wd|Q522041}}, care nu folosea expresii regulate, ci propriile sale construcții de identificare a șabloanelor.

Expresiile regulate au intrat în utilizarea populară în 1968 în două moduri: identificarea șabloanelor într-un editor de text{{Sfn|Thompson|1968}} și analiza lexicală într-un compilator.{{Sfn|Johnson|Porter|Ackley|Ross|1968}} Printre primele apariții ale expresiilor regulate sub formă de program a fost atunci când [[Ken Thompson]] a integrat notația lui Kleene în editorul {{Ill-wd|Q1055723|3=QED}} ca mijloc de a identifica șabloane în [[Fișier text|fișiere text]].{{Sfn|Thompson|1968}}<ref name="Beautiful Code Kernighan">{{cite book|last1=Kernighan|first1=Brian|authorlink1=Brian Kernighan|title=Beautiful Code|chapter=A Regular Expressions Matcher|publisher={{Ill-wd|Q1065097}}|pages=1–2|url=http://www.cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html|accessdate=2013-05-15|isbn=978-0-596-51004-6}}</ref><ref>{{cite web|url=http://cm.bell-labs.com/who/dmr/qed.html|title=An incomplete history of the QED Text Editor|last1=Ritchie|first1=Dennis M.|publisher=|accessdate=9 October 2013|archive-date=1999-02-21|archive-url=https://web.archive.org/web/19990221023422/http://cm.bell-labs.com/who/dmr/qed.html|dead-url=yes}}</ref>{{Sfn|Aho|Ullman|1992|loc=10.11 Bibliographic Notes for Chapter 10, p. 589}} Pentru viteză, Thompson a implementat potrivirea expresiilor regulate prin {{Ill-wd|Q110546|3=compilare just-in-time}} (JIT) în cod {{Ill-wd|Q2701019}} pe {{Ill-wd|Q1121396}}, un exemplu important de compilare JIT timpurie.{{Sfn|Aycock|2003|loc=2. JIT Compilation Techniques, 2.1 Genesis, p. 98}} Mai târziu, el a adăugat această capacitate la editorul Unix [[ed]], care a facilitat în cele din urmă ca popularul instrument de căutare [[grep]] să utilizeze expresiile regulate („grep” este un cuvânt derivat din comanda de căutare de expresii regulate căutarea în editorul ed: <code>g/''re''/p</code> înseamnă „Global search for Regular Expression and Print matching lines” - „căutare globală de expresii regulate și tipărire a liniilor rezultate”<ref>{{cite web|url=http://catb.org/jargon/html/G/grep.html|title=Jargon File 4.4.7: grep|author={{Ill-wd|Q188954|3=Raymond, Eric S.}} citing [[Dennis Ritchie]]|year=2003}}</ref>). Cam în același timp când Thompson dezvolta QED, un grup de cercetători din care făcea parte {{Ill-wd|Q5302019}} a implementat un instrument bazat pe expresii regulate, care este utilizat pentru {{Ill-wd|Q835922|3=analiza lexicală}} în proiectarea [[Compilator|compilatoarelor]].{{Sfn|Johnson|Porter|Ackley|Ross|1968}}

În programele [[UNIX|Unix]]{{Sfn|Aho|Ullman|1992|loc=10.11 Bibliographic Notes for Chapter 10, p. 589}} programe de la [[Laboratoarele Bell|Bell Labs]] au fost utilizate multe variații ale acestor forme inițiale de expresii regulate în anii 1970, de exemplu în {{Ill-wd|Q214743}}, {{Ill-wd|Q306650|3=lex}}, [[sed]], [[AWK]], și [[expr]], și în alte programe, cum ar fi [[Emacs]]. Regexurile au fost ulterior adoptate de către o gamă largă de programe, aceste forme incipiente fiind standardizate în standardul POSIX.2 din 1992.

În 1980, au apărut regexuri mai complicate în [[Perl]], care inițial au rezultat dintr-un bibliotecă de regex scrisă de {{Ill-wd|Q5358365}} (1986), care a scris mai târziu o implementare a ''Advanced Regular Expressions'' pentru [[Tcl/TK|Tcl]].<ref>{{cite web|url=http://www.tcl.tk/doc/howto/regexp81.html|title=New Regular Expression Features in Tcl 8.1|accessdate=2013-10-11}}</ref> Biblioteca Tcl este o implementare hibridă de {{Ill-wd|Q617295|3=AFN}}/{{Ill-wd|Q837528|3=AFD}} cu performanțe îmbunătățite, lăudată de {{Ill-wd|Q2576121}}, care a spus, „...pare chiar destul de minunată.”<ref>{{cite book|last1=Friedl|first1=Jeffrey|authorlink=Jeffrey Friedl|title=Mastering Regular Expressions|chapter=The Mechanics of Expression Processing|publisher={{Ill-wd|Q1065097}}|pages=182|isbn=0-596-52812-4}}</ref> Printre proiectele software care au adoptat implementarea de expresii regulate a lui Spencer din Tcl punerea în aplicare se numără [[PostgreSQL]].<ref>{{cite web|url=http://www.postgresql.org/docs/9.3/interactive/functions-matching.html|title=PostgreSQL 9.3.1 Documentation: 9.7. Pattern Matching|accessdate=2013-10-12}}</ref> Perl a extins ulterior biblioteca inițială a lui Spencer pentru a adăuga mai multe caracteristici noi,<ref>{{cite web|url=http://perldoc.perl.org/perlre.html|title=perlre: Perl regular expressions|author=[[Larry Wall|Wall, Larry]] and the Perl 5 development team|year=2006}}</ref> dar încă nu avea performanțele sau capabilitățile de manipulare [[Unicode]] pe care le avea Advanced Regular Expressions a lui Spencer.<ref>{{cite web|url=http://perldoc.perl.org/perlreguts.html#Unicode-and-Localisation-Support|title=Unicode and Localisation Support|accessdate=2013-10-11}}</ref><ref>{{cite web|url=http://swtch.com/~rsc/regexp/regexp1.html|title=Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby, …)|author=Russ Cox|year=2007|accessdate=2013-10-11}}</ref> O parte din efortul de proiectare pentru {{Ill-wd|Q2052676}} îl reprezintă îmbunătățirea integrării regexurilor în Perl, și de a crește domeniul de aplicare a acestora și a capacităților pentru a permite definirea de {{Ill-wd|Q32271|3=gramatici de analiză sintactică}}.<ref name="Apocalypse5">{{harvtxt|Wall|2002}}</ref> Rezultatul a fost un {{Ill-wd|Q691358|3=mini-limbaj}} numit {{Ill-wd|Q7169108|3=regulile Perl 6}}, utilizate pentru a defini gramatici Perl 6 și de a oferi un instrument pentru programatori ce folosesc acest limbaj. Aceste reguli menține caracteristicile existente ale regexurilor din Perl 5.x, dar permit și definiția în stil {{Ill-wd|Q211577|3=Backus-Naur}} ale unui {{Ill-wd|Q1323264|3=parser cu coborâre recursivă}} prin intermediul sub-regulilor.

Utilizarea regexurilor în standardele deinformații structurate pentru modelarea documentelor și bazelor de date a început în anii 1960 și s-a extins în anii 1980, atunci când s-au consolidat standardele din industrie, cum ar fi {{Ill-wd|Q207819|3=ISO SGML}} (cu precursorul ANSI „GCA 101-1983”). Nucleul {{Ill-wd|Q1043076|3=limbajului de specificare a structurii}} este format din regexuri. Utilizarea sa este evidentă în sintaxa {{Ill-wd|Q212327|3=DTD}}.

Începând cu anul 1997, {{Ill-wd|Q7183710}} a dezvoltat {{Ill-wd|Q125267|3=PCRE}} (Perl Compatible Regular Expressions), care încearcă să imite îndeaproape funcționalitatea regexurilor din Perl și este folosit de multe instrumente moderne, inclusiv de [[PHP]] și de [[Apache (server)|Apache HTTP Server]].

Astăzi, regexurile sunt suportate pe scară largă în limbaje de programare, în programe de procesare de text (lexere speciale), editoare de text avansate, și alte programe. Suportul pentru regex face parte din biblioteca standard a multor limbaje de programare, inclusiv [[Java (limbaj de programare)|Java]] și [[Python]], și este integrată și în sintaxa altora, inclusiv Perl și ECMAScript. Implementările funcționalităților regex sunt adesea numite '''motoare regex''', și există mai multe biblioteci disponibile pentru reutilizare.

== Concepte de bază ==
O expresie regulată, de multe ori numită '''șablon '''(pattern), este o expresie folosită pentru a specifica o mulțime de șiruri de caractere necesară pentru un anumit scop. Un mod simplu de a specifica o mulțime finită de șiruri de caractere este de a enumera elementele sale. Cu toate acestea, există de multe ori moduri mai concise de a specifica mulțimea dorită de șiruri de caractere. De exemplu, mulțimea ce conține trei șiruri de caractere "Handel", "Händel", și "Haendel" poate fi specificată de '''șablonul''' <code>H(ä|ae?)ndel</code>; spunem că acest șablon '''se potrivește''' pe fiecare dintre cele trei șiruri de caractere. În cele mai multe formalisme, dacă există cel puțin o expresie regulată care se potrivește cu o anumită mulțime, atunci există un număr infinit de alte expresii regulată care se potrivesc—specificația nu este unică. Cele mai multe formalisme oferă următoarele operațiuni pentru a construi expresii regulate.
; „Sau” logic (alternanța)
: O {{Ill-wd|Q1132051|3=bară verticală}} separă alternativele. De exemplu, {{Code|code=gray{{!}}grey|lang=perl}} se poate potrivi cu „gray” sau cu „grey”.
; Gruparea
: [[Paranteză|Parantezele]] sunt folosite pentru a defini domeniul de aplicare și de precedență a operatorilor (printre alte utilizări). De exemplu, <code>gray|grey</code> și {{Code|code=gr(a{{!}}e)y|lang=perl}} sunt șabloane echivalente care ambele descriu mulțimea formată din „gray” și „grey”.
; Cuantificarea
: Un {{Ill-wd|Q3412958|3=cuantificator}} după un {{Ill-wd|Q835922|3=token}} (cum ar fi un caracter) sau un grup specifică de câte ori poate apărea precedentul element. Cei mai frecvenți cuantificatori sunt [[Semnul întrebării|semnul de întrebare]] <code>?</code>, [[Asterisc|asteriscul]] <code>*</code> (derivat din [[Închidere Kleene|închiderea Kleene]]) și {{Ill-wd|Q747083|3=semnul plus}} <code>+</code> ([[Închidere Kleene|plus Kleene]]).
: {|
| style="width:15px; vertical-align:top;" | <code>'''?'''</code>
|Semnul de întrebare indică ''zero sau una'' apariții ale elementului precedent. De exemplu, <code>colou?r</code> potrivește atât cu „colour”, cât și cu „color”.
|-
| style="vertical-align:top;" | <code>'''<nowiki>*</nowiki>'''</code>
|Asteriscul indică ''zero sau mai multe'' apariții ale elementului precedent. De exemplu, <code>ab*c</code> se potrivește cu „ac”, „abc”, „abbc”, „abbbc” și așa mai departe.
|-
| style="vertical-align:top;" | <code>'''+'''</code>
|Semnul plus indică ''unul sau mai multe'' apariții ale elementului precedent. De exemplu, <code>ab+c</code> se potrivește cu „abc”, „abbc”, „abbbc” și așa mai departe, dar nu cu „ac”.
|-
|<code>'''{n}'''</code><ref name="grep">grep(1) man page</ref>
| Elementul precedent apare exact de ''n'' ori.
|-
|<code>'''{min,}'''</code>
| Elementul precedent apare de cel puțin ''min'' ori.
|-
|<code>'''{min,max}'''</code>
| Elementul precedent apare de cel puțin ''min'' ori, dar de cel mult ''max'' ori.
|}
Aceste construcții pot fi combinate pentru a forma expresii arbitrar de complexe, așa cum se pot construi expresii aritmetice din numerele și operațiile '''+''', '''−''', '''×''', '''÷'''. De exemplu, <code>H(ae?|ä)ndel</code> și {{Code|code=H(a{{!}}ae{{!}}ä)ndel|lang=perl}} sunt ambele șabloane valabile care se potrivesc cu aceleași șiruri ca în exemplul anterior, <code>H(ä|ae?)ndel</code>.

[[Sintaxă|Sintaxa]] exactă a expresiilor regulate variază de la instrument la instrument și de la context la context; mai multe detalii sunt furnizate în secțiunea [[#Syntax|''Sintaxă'']].

== Teoria limbajelor formale ==
Expresiile regulate descriu [[Limbaj regulat|limbaje regulate]] în [[Limbaje formale|teoria limbajelor formale]]. Ele au aceeași putere expresivă ca și {{Ill-wd|Q645527|3=gramaticile regulate}}.

=== Definiție formală ===
Expresiile regulate constau din constante și operatori care notează mulțimi de șiruri de caractere și, respectiv, operațiuni efectuate pe aceste mulțimi. Următoarea definiție este una standard, găsită ca atare în majoritatea manualelor de limbaje formale.<ref name="HopcroftMotwaniUllman01">{{harvtxt|Hopcroft|Motwani|Ullman|2000}}</ref><ref>{{harvtxt|Sipser|1998}}</ref> Dat fiind un {{Ill-wd|Q837518|3=alfabet}} Σ finit, următoarele constante sunt, prin definiție, expresii regulate:
* (''mulțimea vidă'') ∅ care reprezintă mulțimea ∅.
* (''{{Ill-wd|Q670834|3=șirul vid}}'') ε care reprezintă mulțimea ce conține numai șirul „vid”, care nu are caractere.
* (''{{Ill-wd|Q4736519|3=caracter literal}}'') <code>a</code> din Σ care reprezintă mulțimea conținând doar caracterul ''a''.
Date fiind expresiile regulate R și S, următoarele operațiuni efectuate cu ele produc expresii regulate:
* (''{{Ill-wd|Q126002|3=concatenare}}'') ''RS'' reprezintă mulțimea șirurilor de caractere ce se obțin prin concatenarea unui șir din R cu un șir din S. De exemplu, {"ab", "c"}{"d", "ef"} = {"abd", "abef", "cd", "cef"}.
* (''{{Ill-wd|Q4736419|3=alternarea}}'') ''R'' | ''S'' reprezintă {{Ill-wd|Q185359|3=reuniunea}} mulțimilor descrise de ''R'' și ''S''. De exemplu, dacă R descrie {"ab", "c"} și S describe {"ab", "d", "ef"}, atunci expresia ''R'' | ''S'' descrie {"ab", "c", "d", "ef"}.
* (''[[Închidere Kleene|închiderea Kleene]]'') ''R''* reprezintă cea mai mică [[Submulțime|supermulțime]] a mulțimii descrise de ''R'' care conține ε și este închisă în raport cu concatenarea de șiruri. Aceasta este mulțimea tuturor șirurilor de caractere ce se pot consturi prin concatenarea de orice număr finit de ori (inclusiv de zero ori) a șirurilor din mulțimea descrisă de ''R''. De exemplu, {"0","1"}* este mulțimea tuturor {{Ill-wd|Q184754|3=reprezentărilor binare}} (inclusiv șirul vid), iar {"ab", "c"}* = {ε, "ab", "c", "abab", "abc", "cab", "cc", "ababab", "abcab", … }.
Pentru a evita parantezele, se presupune că închiderea Kleene are prioritatea cea mai mare, urmată fiind de concatenare și apoi de alternare. Dacă nu există ambiguitate, atunci parantezele se pot omite. De exemplu, <code>(ab)c</code> se poate scrie și ca <code>abc</code>, iar <code>a|(b(c*))</code> se poate scrie ca <code>a|bc*</code>. Multe manuale folosesc simbolurile ∪, +, or ∨ pentru alternare, în locul barei verticale.

'''Exemple:'''
* <code>a|b*</code> reprezintă {ε, "a", "b", "bb", "bbb", ...}
* <code>(a|b)*</code> reprezintă mulțimea tuturor șirurilor de caractere fără alte simboluri decât "a" și "b", inclusiv șirul vid: {ε, "a", "b", "aa", "ab", "ba", "bb", "aaa", ...}
* <code>ab*(c|ε)</code> reprezintă mulțimea șirurilor de caractere care încep cu "a", apoi sunt urmate de zero sau mai mulți de "b"și în cele din urmă, opțional, un "c": {"a", "ac", "ab", "abc", "abb", "abbc", ...}
* <code>(0|(1(01*0)*1))*</code> reprezintă mulțimea numerelor binare multipli de 3: { ε, "0", "00", "11", "000", "011", "110", "0000", "0011", "0110", "1001", "1100", "1111", "00000", ... }

=== Puterea expresivă și compactitatea ===
Definiția formală a expresiilor regulate este intenționat minimală și evită definirea cuantificatorilor redundanți <code>?</code> și <code>+</code>, care pot fi exprimați după cum urmează: <code>a+</code> = <code>aa*</code>, și <code>a?</code> = <code>(a|ε)</code>. Uneori, se adaugă și operatorul {{Ill-wd|Q242767|3=complement}} pentru a da o ''expresie regulată generalizată''; aici ''R<sup>c</sup>'' se potrivește cu șirurile de caractere peste Σ* care nu se potrivesc cu ''R''. În principiu, operatorul complement este redundant, deoarece rezultatul lui se poate obține cu ajutorul altor operatori. Cu toate acestea, procesul de calcul al unei astfel de reprezentări este complex, iar rezultatul poate necesita expresii de o dimensiune care este {{Ill-wd|Q3075235|3=dublu exponențial}} mai mare.<ref>{{harvtxt|Gelade|Neven|2008}}</ref><ref>{{harvtxt|Gruber|Holzer|2008}}</ref>

Expresiile regulate în acest sens pot exprima limbajele regulate, mai exact clasa limbajelor acceptate de {{Ill-wd|Q837528|3=automate finite deterministe}}. Există, totuși, o diferență semnificativă de compactitate. Unele clase de limbaje regulate pot fi descrise numai prin automate finite deterministe a căror dimensiune crește exponențial în funcție de dimensiunea celei mai scurte expresii regulate echivalente. Exemplul standard îl constituie aici limbajele ''L<sub>k</sub>'' formate din toate șirurile de caractere peste alfabetul {''a'',''b''} al căror literă la indicele ''k'' de la dreapta este egal cu ''a''. Pe de o parte, o expresie regulată care descrie ''L''<sub>4</sub> este dată de <math>(a\mid b)^*a(a\mid b)(a\mid b)(a\mid b)</math>.

Generalizând acest șablon la ''L<sub>k</sub>'' rezultă expresia:
<math>(a\mid b)^*a\underbrace{(a\mid b)(a\mid b)\cdots(a\mid b)}_{\text{de }k-1\text{ ori}}. \, </math>

Pe de altă parte, este cunoscut faptul că fiecare [[automat finit]] determinist care acceptă limbajul ''L<sub>k</sub>'' trebuie să aibă cel puțin 2<sup>''k''</sup> membri. Din fericire, există un mod simplu de mapare de la expresii regulate la {{Ill-wd|Q617295|3=automatele finite nedeterministe}} (AFN) mai generale, care nu prezintă o asemenea explozie a dimensiunii; pentru acest motiv, AFN-urile sunt adesea folosite ca reprezentări alternative ale limbajelor regulate. AFN-urile sunt o variație simplă a {{Ill-wd|Q373045|3=gramaticilor}} de tipul 3 din [[ierarhia Chomsky]].

În cele din urmă, este de remarcat faptul că multe motoare de „expresii regulate” din lumea reală implementează caracteristici care nu pot fi descrise prin expresii regulate în sensul teoriei limbajelor formale; mai degrabă, acestea pun în aplicare ''regexuri''. Vezi [[#Patterns for non-regular languages|mai jos]] pentru mai multe detalii despre aceasta.

=== Decizia privind echivalența expresiilor regulate ===
După cum se vede în multe din exemplele de mai sus, există mai multe modalități de a construi o expresie regulată care dă aceleași rezultate.

Este posibil să se scrie un [[algoritm]] care, pentru anumite expresii regulate, decide dacă descriu limbaje similare; algoritmul reduce fiecare expresie la {{Ill-wd|Q5204896|3=automatul finit determinist minimal}}, și determină dacă acestea sunt [[Izomorfism|izomorfe]] (echivalente).

Redundanța poate fi eliminată prin utilizarea [[Închidere Kleene|închiderii Kleene]] și a {{Ill-wd|Q185359|3=reuniunii mulțimilor}} pentru a găsi o submulțime interesantă de expresii regulate care încă este complet expresivă, dar a căror utilizare poate fi limitată.{{Clarificare|date=February 2015}} Acest lucru este surprinzător de dificil. Oricât de simple sunt expresiile regulate, nu există nicio metodă sistematică de a le rescrie într-o formă normală. Lipsa de axiome în trecut a condus la {{Ill-wd|Q7601219|3=problema înălțimii stelei}}. În 1991, {{Ill-wd|Q5268410}} a axiomatizat expresiile regulate cu {{Ill-wd|Q2634506|3=algebra Kleene}}.<ref>{{harvtxt|Kozen|1991}}{{page needed|date=February 2015}}</ref>

== Sintaxa ==
Un șablon regex se potrivește cu n șir țintă. Modelul este compus dintr-o secvență de ''atomi''. Un [[atom]] este un singur punct în modelul regex care încearcă să se potrivească cu șirul țintă. Cel mai simplu atom este un literal, dar gruparea unor părți din șablon pentru a se potrivi cu un atom necesită folosirea <code>( )</code> ca metacaractere. Metacaracterele ajută la formarea: ''atomilor''; ''cuantificatorilor'' care spun câți atomi (și dacă cuantificatorul este ''greedy'' sau nu); un caracter SAU logic, care oferă un set de alternative, un caracter NU logic, care neagă existența unui atom; și ''backreferences'' ca referințe la atomi anteriori ai unui șablon de atomi. Potrivirea se face nu atunci când toți atomii din șir sunt potriviți, ci mai degrabă atunci când toții atomii din șablon s-au potrivit. Ideea este de a face ca șabloane mici de caractere să suporte un număr mare de șiruri de caractere posibile, mai degrabă decât să se compileze o listă lungă a tuturor literalilor posibili.

În funcție de procesorul regex, există aproximativ paisprezece metacaractere, caractere care pot sau nu să aibă sensul lor {{Ill-wd|Q121572|3=literal}}, în funcție de context, sau dacă acestea sunt „escapate”, adică precedate de o {{Ill-wd|Q1366300|3=secvență de ''escape''}}, în acest caz, backslash <code>\</code>. Regexurile moderne și cele cu extensii POSIX utilizează metacaracterele mai des decât sensul literal, astfel încât să se evite inundarea cu backslash-uri, este logic să existe un metacaracter de trecere la un mod literal; dar de la început, are mai mult sens ca cele patru caractere paranteze <code>( )</code> și <code>{ }</code> să fie în primul rând literale, și să „scape” de acest sens obișnuit pentru a deveni metacaractere. Standardele comune le implementează pe ambele. De obicei, metacaractere sunt <code>{}[]()^$.|*+?</code> și <code>\</code>. Caracterele care devin de obicei devin metacaractere când sunt escapate sunt <code>dsw.</code><code>DSW</code> și <code>N</code>.

=== Delimitatori ===
Atunci când se introduc regexuri într-un limbaj de programare, ele pot fi reprezentate ca șiruri de caractere obișnuite, prin urmare, de obicei, între ghilimele; acest lucru este comun în C, Java, Python, de exemplu, unde regexul <code>re</code> este introdus ca <code>"re"</code>. Cu toate acestea, ele sunt adesea scrise cu slash-uri ca {{Ill-wd|Q1641420|3=delimitatori}}, adică <code>/re/</code> reprezintă regexul <code>re</code>. Aceasta provine din ed, unde <code>/</code> este comanda de editor pentru căutare, iar expresia <code>/re/</code> poate fi folosită pentru a specifica o gamă de rânduri (care să se potrivească cu șablonul), care puteau fi combinate cu alte comenzi de fiecare parte, cea mai celebră fiind <code>g/re/p</code>, de unde [[grep]] („global regex print”), care este inclusă în majoritatea sistemelor de operare pe bază de [[UNIX|Unix]], cum ar fi distribuțiile de [[Linux]]. O convenție similară este utilizată și în [[sed]], unde căutarea și înlocuirea sunt date de <code>s/re/înlocuire/</code> și șabloanele pot fi concatenate prin virgulă pentru a specifica mai multe rânduri, ca <code>/re1/,/re2/</code>. Această notație este deosebit de bine-cunoscută datorită utilizării sale în [[Perl]], de unde formează parte a sintaxei diferite de șirurile de caractere literale normale. În unele cazuri, cum ar fi sed și Perl, se pot folosi delimitatori alternativi pentru a evita coliziunea cu conținutul, și pentru a evita necesitatea escapării apariției delimitatorului în conținut. De exemplu, în sed comanda <code>s,/,X,</code> va înlocui un <code>/</code> cu un <code>X</code>, folosind virgula ca delimitator.

=== Standardele ===
Standardul [[IEEE]] POSIX are trei seturi de conformitate: BRE (Basic Regular Expressions),<ref>ISO/IEC 9945-2:1993 ''Information technology – Portable Operating System Interface (POSIX) – Part 2: Shell and Utilities'', successively revised as ISO/IEC 9945-2:2002 ''Information technology – Portable Operating System Interface (POSIX) – Part 2: System Interfaces'', ISO/IEC 9945-2:2003, and currently ISO/IEC/IEEE 9945:2009 ''Information technology – Portable Operating System Interface (POSIX®) Base Specifications, Issue 7''</ref> ERE (Extended Regular Expressions), și SRE (Simple Regular Expressions). SRE este depășit,<ref>The Single Unix Specification (Version 2)</ref> în favoarea lui BRE, ambele fiind compatibile înapoi. Subsecțiunea de mai jos ce acoperă ''clasele de caractere'' se aplică și la BRE și la ERE.

BRE ERE lucrează împreună. ERE adaugă <code>?</code>, <code>+</code>, și <code>|</code>, și elimină necesitatea de a escapa metacaracterele <code>( )</code> și <code>{ }</code>, care sunt ''obligatorii'' în BRE. În plus, atâta timp cât sintanxa standard POSIX pentru regexuri este respectată, poate exista, și adesea există, sintaxă suplimentară pentru a servi aplicații specifice (și totuși conforme POSIX). Deși POSIX.2 lasă unele aspecte de implementare nedefinite, BRE și ERE oferă un „standard”, care a fost adoptat ca sintaxă implicită de către mai multe instrumente, acolo unde alegerea modului BRE sau ERE este de obicei o opțiune acceptată. De exemplu, GNU grep are următoarele opțiuni: „grep -E” pentru ERE și „grep -G” pentru BRE (implicit), și „grep -P” pentru expresii Perl.

Regexurile [[Perl]] au devenit un standard [[de facto]], având un set bogat și puternic de expresii atomice. Perl by are nivele de „bază” sau „extins” separate, unde <code>( )</code> și <code>{ }</code> să poată avea sau nu sens literal. Ele sunt întotdeauna metacaractere, așa cum sunt și în modul „extins” pentru POSIX. Pentru a obține sensul lor ''literal'', ele trebuie escapate. Alte metacaractere sunt cunoscute a fi literale sau simbolice doar în funcție de context. Perl oferă mult mai multe funcționalități: regexuri „lazy”, [[backtracking]], grupuri de captură cu nume, și șabloane {{Ill-wd|Q264164|3=recursive}}, toate completări puternice la POSIX BRE/ERE. (Vezi și [[#Lazy matching|potrivirea „lazy”]] de mai jos.)

==== POSIX de bază și extins ====
În standardul {{Ill-wd|Q14658}}, Basic Regular Syntax (BRE) impune ca {{Ill-wd|Q1415908|3=metacaracterele}} <code>(&nbsp;)</code> și <code>{&nbsp;}</code> să fie notate cu <code>\(\)</code> și <code>\{\}</code>, pe când  Extended Regular Syntax (ERE) nu.<div class="cx-template-editor-source-container" lang="en" dir="ltr" style="display: none;"><div class="cx-template-editor-source"><div class="cx-template-editor-title" title="Prevents word wraps (line breaks) within text or inside a link which contains spaces or hyphens (-).">Nowrap</div><div class="cx-template-editor-param"><div class="cx-template-editor-param-title"><span id="1" class="cx-template-editor-param-key">Text</span></div><div class="cx-template-editor-param-value" data-key="1" style="position: relative;"><code>\(&nbsp;\)</code></div></div></div></div><div class="cx-template-editor-source-container" lang="en" dir="ltr" style="display: none;"><div class="cx-template-editor-source"><div class="cx-template-editor-title" title="Prevents word wraps (line breaks) within text or inside a link which contains spaces or hyphens (-).">Nowrap</div><div class="cx-template-editor-param"><div class="cx-template-editor-param-title"><span id="1" class="cx-template-editor-param-key">Text</span></div><div class="cx-template-editor-param-value" data-key="1" style="position: relative;"><code>\(&nbsp;\)</code></div></div></div></div><div class="cx-template-editor-source-container" lang="en" dir="ltr" style="display: none;"><div class="cx-template-editor-source"><div class="cx-template-editor-title" title="Prevents word wraps (line breaks) within text or inside a link which contains spaces or hyphens (-).">Nowrap</div><div class="cx-template-editor-param"><div class="cx-template-editor-param-title"><span id="1" class="cx-template-editor-param-key">Text</span></div><div class="cx-template-editor-param-value" data-key="1" style="position: relative;"><code>{''m'',''n''}</code></div></div></div></div><div class="cx-template-editor-source-container" lang="en" dir="ltr" style="display: none;"><div class="cx-template-editor-source"><div class="cx-template-editor-title" title="Prevents word wraps (line breaks) within text or inside a link which contains spaces or hyphens (-).">Nowrap</div><div class="cx-template-editor-param"><div class="cx-template-editor-param-title"><span id="1" class="cx-template-editor-param-key">Text</span></div><div class="cx-template-editor-param-value" data-key="1" style="position: relative;"><code>{''m'',''n''}</code></div></div></div></div><div class="cx-template-editor-source-container" lang="en" dir="ltr" style="display: none;"><div class="cx-template-editor-source"><div class="cx-template-editor-title" title="Prevents word wraps (line breaks) within text or inside a link which contains spaces or hyphens (-).">Nowrap</div><div class="cx-template-editor-param"><div class="cx-template-editor-param-title"><span id="1" class="cx-template-editor-param-key">Text</span></div><div class="cx-template-editor-param-value" data-key="1" style="position: relative;">\{''m'',''n''\</div></div></div></div>
{| class="wikitable" style="margin-bottom: 10px; background-repeat: no-repeat; background-image: url(&quot;data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAALHRFWHRDcmVhdGlvbiBUaW1lAEZyaSAxMiBOb3YgMjAxMCAxOTowNzowMiArMTIwMOGr8p4AAAAHdElNRQfaCwwGBxwduq16AAAACXBIWXMAAAsSAAALEgHS3X78AAAABGdBTUEAALGPC/xhBQAAAfJJREFUeNqVkk1vElEUhp87X4CIFhhMG0toMC5K3Lgxbro10bhxY2Jc+CO666Y/oP/DxFVjTKM7l1apTdM0JSU0LSg0WqaUjwE6MDNebGpKBYlndc+55zw5H6/gim2UUd0qs5Uy6VaTa7EYdtOmUN7naHER92q+dtnZ2UFpHTOTXWfuwxrfYlNUHz1lxvdIVyx6MuXHPwFeBLW2z+29Pepr7ziUof7SEq1CibCEmKMAymXH6SD6LrpzRndQPIjNz9P3odu2URlhQ4C+ghcM0JpLEchkzrv7eIDS62JYP2lPBJS2cIMhyrMpwo+fMbW8jLhhc2t3F906pjoK8GcH29vonoenRDk1m5zcvUM6ZuJvZEnmcljT09hbR6iVIuLJw/PxhgAOPOj26Gk1nEQCNWAQ7XS4bxvw8hWuGedeo4iR+/y7+OtfgM1N9OIBwnFQ5SLdZJJ2JML17BdqEuYHgmiahsjnx4zw/i2fslm8dht/YQHx/AWpfI50/ZTKm9d8lykiHkf4/hjA6ipnF++VFRS7T1AoaDejyCEYlHmWNeEKF9YISz30CBkGirxKUIZGamAsQG2hux66BAipi1A6g/5fAM/HkGrUFfmr6wSSiWHJTwQoPrq8hCYEGDoh0xzfwUhyIY9ROkRrNKQ65e1P6uM7+AW+ibcHEM1ixAAAAABJRU5ErkJggg==&quot;); background-position: 488px 0px;"
! Metacaracter
! Descriere
|- valign="top"
!<code>.</code>
|Se potrivește cu orice caracter individual (multe aplicații exclud {{Ill-wd|Q184914|3=sfârșiturile de linie}}, și exact care caractere sunt considerate a fi sfârșituri de linie depinde de varianta de interpretor, de codificarea caracterelor și de platformă, dar se poate presupune că caracterul ''line feed'' este inclus). În interiorul parantezelor din expresiile POSIX, caracterul „punct” este literal. De exemplu, <code>a.c</code> se potrivește cu "abc" etc., dar <code>[a.c]</code> reprezintă doar "a", ".", sau "c".
|- valign="top"
!<code>[&nbsp;]</code>
|Expresie-paranteză. Se potrivește cu un singur caracter conținut între paranteze. De exemplu, <code>[abc]</code> reprezintă "a", "b", sau "c". <code>[a-z]</code> specifică un interval ce se potrivește cu oricel literă mică între "a" și "z". Aceste forme pot fi amestecate: <code>[abcx-z]</code> reprezintă "a", "b", "c", "x", "y", sau "z", la fel ca <code>[a-cx-z]</code>.
Caracterul <code>-</code> este tratat ca literal dacă este primul  (eventual după <code>^</code>) sau ultimul caracter din paranteze: <code>[abc-]</code>, <code>[-abc]</code>. Nu se permit escapări cu backslash. Caracterul <code>]</code> poate fi inclus într-o expresie-paranteză dacă este primul (după <code>^</code>) caracter: <code>[]abc]</code>.
|- valign="top"
!<code>[^&nbsp;]</code>
|Reprezintă un singur caracter care nu este conținut între paranteze. De exemplu, <code>[^abc]</code> se potrivește cu orice caracter altul decât "a", "b", sau "c". <code>[^a-z]</code> se potrivește cu orice caracter unic care nu este o literă mică între "a" și "z". Caracterele literale și intervalele pot fi, la fel ca mai sus, amestecate.
|- valign="top"
!<code>^</code>
|Se potrivește cu începutul șirului. În uneltele pe rânduri, se potrivește cu începutul oricărui rând.
|- valign="top"
!<code>$</code>
|Se potrivește cu sfârșitul șirului, sau pe poziția de imediat înaintea unui sfârșit de linie de la sfârșitul șirului. În uneltele pe rânduri, se potrivește cu sfârșitul oricărui rând.
|- valign="top"
!<code>( )</code>
|Definește o subexpresie. Șirul potrivit în paranteze poate fi referențiat ulterior (vezi mai jos, <code>\''n''</code>). O subexpresie astfel marcată se numește și „bloc” sau „grup de captură”. '''Modul BRE necesită <code>\(&nbsp;\)</code>'''.
|- valign="top"
!<code>\''n''</code>
|Se potrivește cu ce s-a potrivit și a ''n''-a subexpresie, unde ''n'' este o cifră de la 1 la 9. Această construcție este vag definită în standardul POSIX.2. Unele unelte permit referențierea a mai mult de nouă grupuri de captură.
|- valign="top"
!<code>*</code>
|Se potrivește cu șirul ce cuprinde elementul precedent de zero sau mai multe ori. De exemplu, <code>ab*c</code>se potrivește cu "ac", "abc", "abbbc" etc. <code>[xyz]*</code> se potrivește cu "", "x", "y", "z", "zx", "zyx", "xyzzy", și așa mai departe. <code>(ab)*</code> se potrivește cu "", "ab", "abab", "ababab", și așa mai departe.
|- valign="top"
!<code>{''m'',''n''}</code>
|Se potrivește cu elementul precedent de cel puțin ''m'' și cel mult ''n'' ori. De exemplu, <code>a{3,5}</code> se potrivește doar cu "aaa", "aaaa", și "aaaaa". Această funcționalitate nu există în instanțe mai vechi de regex. '''Modul BRE necesită <code>\{''m'',''n''\}</code>'''.
|}
'''Exemple:'''
* <code>.at</code> se potrivește cu orice șir de trei caractere terminat cu "at", inclusiv "hat", "cat", și "bat".
* <code>[hc]at</code> se potrivește cu "hat" și "cat"
* <code>[^b]at</code> se potrivește cu toate șirurile care se potrivesc cu <code>.at</code> cu excepția lui "bat".
* <code>[^hc]at</code> se potrivește cu toate șirurile care se potrivesc cu <code>.at</code> cu excepția lui "hat" și "cat".
* <code>^[hc]at</code> se potrivește cu "hat" și "cat", dar numai de la începutul șirului sau rândului.
* <code>[hc]at$</code> se potrivește cu "hat" și "cat", dar numai la sfârșitul șirului sau rândului.
* <code>\[.\]</code> se potrivește cu orice caracter unic, înconjurat de "[" și "]", întrucât parantezele sunt escapate, de exemplu: "[a]" și "[b]".
* <code>s.*</code> se potrivește cu s urmat de zero sau mai multe caractere, de exemplu: "saw" și "seed".

==== POSIX extins ====
Sensul metacaracterelor {{Ill-wd|Q998991|3=escapate}} cu un backslash este inversat pentru unele caractere din sintaxa POSIX Extended Regular Expression (ERE). Cu această sintaxă, un backslash determină ca metacaracterul să fie tratat ca un literal. Astfel, de exemplu, <code>\( \)</code> este acum <code>( )</code> și <code>\{ \}</code> este acum <code>{ }</code>. În plus, suportul este eliminat pentru backreferences <code>\''n''</code> și se adaugă următoarele metacaractere:
{| class="wikitable" style="margin-bottom: 10px; background-repeat: no-repeat; background-image: url(&quot;data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAALHRFWHRDcmVhdGlvbiBUaW1lAEZyaSAxMiBOb3YgMjAxMCAxOTowNzowMiArMTIwMOGr8p4AAAAHdElNRQfaCwwGBxwduq16AAAACXBIWXMAAAsSAAALEgHS3X78AAAABGdBTUEAALGPC/xhBQAAAfJJREFUeNqVkk1vElEUhp87X4CIFhhMG0toMC5K3Lgxbro10bhxY2Jc+CO666Y/oP/DxFVjTKM7l1apTdM0JSU0LSg0WqaUjwE6MDNebGpKBYlndc+55zw5H6/gim2UUd0qs5Uy6VaTa7EYdtOmUN7naHER92q+dtnZ2UFpHTOTXWfuwxrfYlNUHz1lxvdIVyx6MuXHPwFeBLW2z+29Pepr7ziUof7SEq1CibCEmKMAymXH6SD6LrpzRndQPIjNz9P3odu2URlhQ4C+ghcM0JpLEchkzrv7eIDS62JYP2lPBJS2cIMhyrMpwo+fMbW8jLhhc2t3F906pjoK8GcH29vonoenRDk1m5zcvUM6ZuJvZEnmcljT09hbR6iVIuLJw/PxhgAOPOj26Gk1nEQCNWAQ7XS4bxvw8hWuGedeo4iR+/y7+OtfgM1N9OIBwnFQ5SLdZJJ2JML17BdqEuYHgmiahsjnx4zw/i2fslm8dht/YQHx/AWpfI50/ZTKm9d8lykiHkf4/hjA6ipnF++VFRS7T1AoaDejyCEYlHmWNeEKF9YISz30CBkGirxKUIZGamAsQG2hux66BAipi1A6g/5fAM/HkGrUFfmr6wSSiWHJTwQoPrq8hCYEGDoh0xzfwUhyIY9ROkRrNKQ65e1P6uM7+AW+ibcHEM1ixAAAAABJRU5ErkJggg==&quot;); background-position: 488px 0px;"
! Metacaracter
! Descriere
|- valign="top"
!<code>?</code>
|Se potrivește cu elementul anterior de zero ori sau o singură dată. De exemplu, <code>ab?c</code> se potrivește numai cu "ac" sau "abc".
|-
!<code>+</code>
|Se potrivește cu elementul precedent de una sau de mai multe ori. De exemplu, <code>ab+c</code> se potrivește cu "abc", "abbc", "abbbc", și așa mai departe, dar nu "ac".
|-
!<code><nowiki>|</nowiki></code>
|Alternanța (cunoscută și sub numele de reuniune) se potrivește fie cu expresia dinainte, fie cu cea de după operator. De exemplu, <code><nowiki>abc|def</nowiki></code> se potrivește cu "abc" sau cu "def".
|}
'''Exemple:'''
* <code>[hc]+at</code> se potrivește cu "hat", "cat", "hhat", "chat", "hcat", "cchchat", și așa mai departe, dar nu cu "at".
* <code>[hc]?at</code> se potrivește cu "hat", "cat", și "at".
* <code>[hc]*at</code> se potrivește cu "hat", "cat", "hhat", "chat", "hcat", "cchchat", "at", și așa mai departe.
* <code>cat|dog</code> se potrivește cu "cat" sau "dog".
POSIX Extended Regular Expressions pot fi folosite adesea cu utilitarele Unix moderne prin activarea flagului de [[CLI|linie de comandă]] <var>-E</var>.

==== Clase de caractere ====
Clasa de caractere este cel mai de bază concept al regexurilor după cel de literal. El face ca o secvență scurtă de caractere să se potrivească cu un șir mai mare. De exemplu, <code>[A-Z]</code> ar putea reprezenta întreg alfabetul majusculelor, iar <code>\d</code> ar putea însemna orice cifră. Clasele de caractere se aplică la ambele niveluri POSIX.

Atunci când se specifică un interval de caractere, cum ar fi <code>[a-Z]</code> (adică literele mici de la ''<code>a</code>'' la ''<code>z</code>''), setările locale ale calculatorului determină conținutul ordonării numerice a codificării caracterelor. S-ar putea stoca simbolurile în ordine lexicografică, sau ordonarea ar putea fi ''abc...zABC...Z'', sau ''aAbBcC...zZ''. Așa că standardul POSIX definește o clasă de caractere, care va fi cunoscută de procesorul regex instalat. Aceste definiții sunt în tabelul următor:
{| class="wikitable" style="margin-bottom: 34px; background-repeat: no-repeat; background-image: url(&quot;data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAALHRFWHRDcmVhdGlvbiBUaW1lAEZyaSAxMiBOb3YgMjAxMCAxOTowNzowMiArMTIwMOGr8p4AAAAHdElNRQfaCwwGBxwduq16AAAACXBIWXMAAAsSAAALEgHS3X78AAAABGdBTUEAALGPC/xhBQAAAfJJREFUeNqVkk1vElEUhp87X4CIFhhMG0toMC5K3Lgxbro10bhxY2Jc+CO666Y/oP/DxFVjTKM7l1apTdM0JSU0LSg0WqaUjwE6MDNebGpKBYlndc+55zw5H6/gim2UUd0qs5Uy6VaTa7EYdtOmUN7naHER92q+dtnZ2UFpHTOTXWfuwxrfYlNUHz1lxvdIVyx6MuXHPwFeBLW2z+29Pepr7ziUof7SEq1CibCEmKMAymXH6SD6LrpzRndQPIjNz9P3odu2URlhQ4C+ghcM0JpLEchkzrv7eIDS62JYP2lPBJS2cIMhyrMpwo+fMbW8jLhhc2t3F906pjoK8GcH29vonoenRDk1m5zcvUM6ZuJvZEnmcljT09hbR6iVIuLJw/PxhgAOPOj26Gk1nEQCNWAQ7XS4bxvw8hWuGedeo4iR+/y7+OtfgM1N9OIBwnFQ5SLdZJJ2JML17BdqEuYHgmiahsjnx4zw/i2fslm8dht/YQHx/AWpfI50/ZTKm9d8lykiHkf4/hjA6ipnF++VFRS7T1AoaDejyCEYlHmWNeEKF9YISz30CBkGirxKUIZGamAsQG2hux66BAipi1A6g/5fAM/HkGrUFfmr6wSSiWHJTwQoPrq8hCYEGDoh0xzfwUhyIY9ROkRrNKQ65e1P6uM7+AW+ibcHEM1ixAAAAABJRU5ErkJggg==&quot;); background-position: 756px 0px;"
! POSIX 
! Nestandard 
! Perl/Tcl 
! Vim 
! Java 
! ASCII 
! Description
|-
| <code>\p{ASCII}</code>
| <code>[\x00-\x7F]</code>
| ASCII characters
|-
| <code>[:alnum:]</code>
| <code>\p{Alnum}</code>
| <code>[A-Za-z0-9]</code>
| Alphanumeric characters
|-
| <code>[:word:]</code>
| <code>\w</code>
| <code>\w</code>
| <code>\w</code>
| <code>[A-Za-z0-9_]</code>
| Alphanumeric characters plus "_"
|-
| <code>\W</code>
| <code>\W</code>
| <code>\W</code>
| <code>[^A-Za-z0-9_]</code>
| Non-word characters
|-
| <code>[:alpha:]</code>
| <code>\a</code>
| <code>\p{Alpha}</code>
| <code>[A-Za-z]</code>
| Alphabetic characters
|-
| <code>[:blank:]</code>
| <code>\s</code>
| <code>\p{Blank}</code>
| <code>[ \t]</code>
| Space and tab
|-
| <code>\b</code>
| <code>\&#x3C; \&#x3E;</code>
| <code>\b</code>
| <code>(?</code><code><=\W)(?=\w)&#x7C;(?<=\w)(?=\W)</code>
| Word boundaries
|-
| <code>\B</code>
| <code>(?</code><code><=\W)(?=\W)&#x7C;(?<=\w)(?=\w)</code>
| Non-word boundaries
|-
| <code>[:cntrl:]</code>
| <code>\p{Cntrl}</code>
| <code>[\x00-\x1F\x7F]</code>
| Control characters
|-
| <code>[:digit:]</code>
| <code>\d</code>
| <code>\d</code>
| <code>\p{Digit}</code> or <code>\d</code>
| <code>[0-9]</code>
| Digits
|-
| <code>\D</code>
| <code>\D</code>
| <code>\D</code>
| <code>[^0-9]</code>
| Non-digits
|-
| <code>[:graph:]</code>
| <code>\p{Graph}</code>
| <code>[\x21-\x7E]</code>
| Visible characters
|-
| <code>[:lower:]</code>
| <code>\l</code>
| <code>\p{Lower}</code>
| <code>[a-z]</code>
| Lowercase letters
|-
| <code>[:print:]</code>
| <code>\p</code>
| <code>\p{Print}</code>
| <code>[\x20-\x7E]</code>
| Visible characters and the space character
|-
| <code>[:punct:]</code>
| <code>\p{Punct}</code>
| <code><nowiki>[][!"</nowiki></code><code><nowiki>#$%&'()*+,./:;<=>?@\^_`{|}~-]</nowiki></code>
| Punctuation characters
|-
| <code>[:space:]</code>
| <code>\s</code>
| <code>\_s</code>
| <code>\p{Space}</code> or <code>\s</code>
| <code>[ \t\r\n\v\f]</code>
| Whitespace characters
|-
| <code>\S</code>
| <code>\S</code>
| <code>\S</code>
| <code>[^ \t\r\n\v\f]</code>
| Non-whitespace characters
|-
| <code>[:upper:]</code>
| <code>\u</code>
| <code>\p{Upper}</code>
| <code>[A-Z]</code>
| Uppercase letters
|-
| <code>[:xdigit:]</code>
| <code>\x</code>
| <code>\p{XDigit}</code>
| <code>[A-Fa-f0-9]</code>
| Hexadecimal digits
|}
Clasele de caractere POSIX pot fi utilizate numai în expresii cu paranteze. De exemplu, <code><nowiki>[[:upper:]ab]</nowiki></code> se potrivește cu literele mari și cu literele mici "a" și "b".

O clasă suplimentară non-POSIX înțeleasă de către unele instrumente este <code>[:word:]</code>, care este de obicei definită ca <code>[:alnum:]</code> plus [[underscore]]. Acest lucru reflectă faptul că în multe limbaje de programare, acestea sunt caracterele care pot fi utilizate în identificatori. Editorul [[Vim]] distinge și clasele ''word'' și ''word-head'' (folosind notația <code>\w</code> și <code>\h</code>), deoarece în multe limbaje de programare caracterele ce pot apărea la începutul unui identificator nu sunt aceleași cu cele care pot apărea și în alte poziții în cadrul identificatorului.

Ceea ce standardele POSIX numesc ''clase de caractere'' sunt frecvent denumite ''clase de caractere POSIX'' în alte variante de regex care le suportă. Majoritatea variantelor de regex, termenul ''clasă de caractere'' este utilizat pentru a descrie ceea ce în POSIX se numește ''expresii cu paranteze''.

=== Perl ===
Din cauza puterii sale de exprimare și a lizibilității (relativ) ușoare, multe alte utilitare și limbaje de programare au adoptat o sintaxă similară cu Perl—de exemplu, [[Java (limbaj de programare)|Java]], [[JavaScript]], [[Python]], [[Ruby]], [[Microsoft]] .{{Ill-wd|Q5289|3=NET Framework}}, și {{Ill-wd|Q16342|3=XML Schema}}. Unele limbi și instrumente, cum ar fi {{Ill|en|Boost C++ Libraries|4=Boost}} și [[PHP]] suportă mai multe variante de regex. Implementările de regex derivate din Perl nu sunt identice și, de obicei, implementează un subset al facilităților găsite în Perl 5.0, lansat în 1994. Perl încorporează uneori caracteristici găsite inițial și în alte limbaje, de exemplu, Perl 5.10 implementează extensiile sintactice inițial dezvoltate în {{Ill-wd|Q125267}} și Python.<ref>{{cite web|url=http://perldoc.perl.org/perlre.html#PCRE%2fPython-Support|title=Perl Regular Expression Documentation|publisher=perldoc.perl.org|accessdate=8 ianuarie 2012}}</ref>

=== Potrivirea lazy ===
În Python și în alte implementări (de exemplu, Java), cei trei cuantificatori fecvenți (<code>*</code>, <code>+</code> și <code>?</code>) sunt implicit {{Ill-wd|Q504353|3=greedy}}, deoarece aceștia se potrivesc cu cât mai multe caractere posibil.<ref name="py-re">{{cite web|title=Regular Expression Syntax|url=https://docs.python.org/3/library/re.html#regular-expression-syntax|website=Python 3.5.0 documentation|publisher={{Ill-wd|Q83818}}|accessdate=10 October 2015}}</ref> Regexul <code>".*"</code> aplicat asupra șirului
 "Ganymede," a continuat el, "este cel mai mare satelit din Sistemul Solar."
se potrivește cu întreaga linie în loc a se potrivi doar cu <code>"Ganymede,"</code>. Cuantificatorii menționați pot fi făcuți și {{Em|lazy}} sau {{Em|minimali}} sau {{Em|reticenți}}, așa încât să potrivească cât mai puține caractere posibil, astfel, prin adăugarea unui semn de întrebare: <code>".*?"</code> șablonul de mai sus identifică doar <code>"Ganymede,"</code>.

=== Potrivirea posesivă ===
În Java, cuantificatorii poate fi făcuți {{Em|posesivi}} prin adăugarea unui semn plus, care dezactivează pașii înapoi în algoritmul backtracking de parcurgere a automatului, chiar dacă acești pași ar face să se găsească o potrivire:<ref name="es-re">{{cite web|title=Essential classes: Regular Expressions: Quantifiers: Differences Among Greedy, Reluctant, and Possessive Quantifiers|url=https://docs.oracle.com/javase/tutorial/essential/regex/quant.html#difs|website=The Java Tutorials|publisher=[[O=racle]]|accessdate=23 December 2016}}</ref> Deși regexul <code>".*"</code> aplicat pe șirul
 "Ganymede," a continuat el, "este cel mai mare satelit din Sistemul Solar."
se potrivește cu întreaga linie, regexul <code>".*+"</code> {{Em|nu se potrivește cu nimic}}, pentru că <code>.*+</code> consumă întreaga intrare, inclusiv <code>"</code> de la sfârșit. Astfel, cuantificatorii posesivi sunt cele mai utili cu clase de caractere negate, de exemplu cu <code>"[^"]*+"</code>, care se potrivește cu <code>"Ganymede,"</code> atunci când este aplicat pe același șir.

Cuantificatorii posesivi sunt mai ușor de implementat decât cei ''greedy'' și ''lazy'', și sunt de obicei mai eficienți la ''runtime''.

== Șabloane pentru limbaje neregulate ==
Multe caracteristici găsite în aproape toate bibliotecile moderne de expresii regulate oferă o putere expresivă care depășește pe cea a [[Limbaj regulat|limbajelor regulate]]. De exemplu, multe implementări permit gruparea subexpresiilor cu paranteze și reapelarea valorii care s-a potrivit deja în cadrul aceleeiași expresii (''{{Visible anchor|backreferences}}''). Acest lucru înseamnă că, printre alte lucruri, un șablon poate compara șiruri de cuvinte repetate ca „papa” sau „WikiWiki”, numite în teoria limbajelor formale ''pătrate''. Șablonul pentru aceste șiruri de caractere este <code>(.+)\1</code>.

Limbajul pătratelor nu este regulat, și nici [[Limbaje independente de context|independent de context]], din cauza {{Ill-wd|Q2596624|3=lemei de pompare}}. Cu toate acestea, {{Ill-wd|Q1503724|3=potrivirea șabloanelor}} cu un număr nelimitat de backreference-uri, așa cum este suportată de numeroase instrumente moderne, este încă {{Ill-wd|Q1430282|3=dependentă de context}}.<ref>{{cite journal|author=Cezar Câmpeanu and Kai Salomaa, and Sheng Yu|title=A Formal Study of Practical Regular Expressions|journal=International Journal of Foundations of Computer Science|volume=14|number=6|pages=1007–1018|url=http://137.149.157.5/Articles/index.php?aid=1<!---This url was taken from Câmpeanu's publications page http://www.csit.upei.ca/~ccampeanu/Research/RJ--->|date=Dec 2003}}</ref>

Cu toate acestea, multe instrumente, biblioteci, și motoare care asigură astfel de construcții încă mai folosesc termenul ''expresie regulată'' pentru șabloanele lor. Acest lucru a condus la o nomenclatură în care termenul ''expresie regulată'' are o semnificație diferită în [[Limbaje formale|teoria limbajelor formale]] față de cea pe care o are în potrivirea șabloanelor. Din acest motiv, unii oameni folosesc termenul de ''regex'', ''regexp'', sau pur și simplu ''șablon'' sau ''pattern'' pentru a le descrie pe cele din urmă. [[Larry Wall]], autorul limbajului de programare Perl, scria într-un eseu despre proiectarea Perl 6:{{Citat|"Expresiile regulate" […] sunt doar marginal legate de expresiile regulate adevărate. Chiar și așa, termenul s-a extins odată cu capabilitățile motoarelor noastre de potrivirea șabloanelor, așa că nu o să mă apuc acum să combat necesitățile lingvistice. Totuși, am să le numesc „regexuri”...<ref name="Apocalypse5"/></div>}}

== Regexuri fuzzy ==
Unele variante de regex poate fi folosite pentru lucrul cu text în [[limbaj natural]], atunci când este necesar să se ia în considerare posibilele greșeli de ortografie și variante de ortografie. De exemplu, textul „Iulius Cezar” ar putea fi o potrivire fuzzy pentru:
* Gaius Iulius Cezar
* Yulius Cesar
* G. Julius Caezar
În astfel de cazuri, mecanismul implementează un algoritm {{Ill-wd|Q1798621|3=fuzzy de identificare a șirurilor}} și, eventual, un algoritm pentru găsirea {{Ill-wd|Q5338467|3=similitudinilor}} între fragmentul de text și șablon.

Această sarcină este strâns legată de {{Ill-wd|Q83540|3=căutarea în texte}} și {{Ill-wd|Q403574|3=recunoașterea entităților cu nume}}.

Unele {{Ill-wd|Q188860|3=biblioteci software}} lucrează cu regexuri fuzzy:
* {{Ill-wd|Q7671327|3=TRE}} – proiect liber și bine dezvoltat în [[C (limbaj de programare)|C]], care utilizează o sintaxă similară cu [[#Standards|POSIX]]
* FREJ – proiect open source în [[Java (limbaj de programare)|Java]] cu sintaxă nestandard (care utilizează o [[notație prefixată]], în stil [[LISP|Lisp]]), orientate spre a permite o utilizare ușoară a substituțiilor fragmentelor interne identificate din blocuri exterioare, fără a avea însă multe caracteristici ale regexurilor standard.
* agrep – utilitar open source în linie de comandă.

== {{Anchor|Implementations}}Implementări și timpi de rulare ==
Există cel puțin trei tipuri diferite de [[Algoritm|algoritmi]] care decid dacă și cum se potrivește un anumit regex cu un șir de caractere.

Cea mai vechi și mai rapidă se bazează pe un rezultat din teoria limbajelor formale, care permite ca fiecare {{Ill-wd|Q617295|3=automat finit nedeterminist}} (AFN) să fie transformat într-un {{Ill-wd|Q837528|3=automat finit determinist}} (AFD). AFD-ul poate fi construit în mod explicit și apoi executat pe șirul de intrare simbol cu simbol. Construirea AFD pentru o expresie regulată de dimensiune ''m'' are complexitatea în timp și spațiu {{Ill-wd|Q269878|3=''O''}}(2<sup>''m''</sup>), dar poate fi rulată pe un șir de caractere de dimensiune ''n'' într-un timp ''O''(''n'').

O abordare alternativă este aceea de a simula AFN-ul direct, construind practic la cerere fiecare stare a AFD-ului și apoi renunțând la ea în pasul următor. Acest lucru face ca AFD-ul să fie doar implicit și evită costurile exponențiale de construcție a lui, dar și costurile de funcționare se ridică la ''O''(''mn''). Abordarea explicită se numește „algoritmul AFD” și cea implicită - algoritmul AFN. Adăugarea de caching pentru algoritmul AFN este adesea numită „algoritmul AFD lazy”, sau „algoritmul AFD”, fără a face o distincție. Acești algoritmi sunt rapizi, dar folosirea lor pentru obținerea subexpresiilor grupate, pentru cuantificarea lazy, și alte caracteristici similare este complicată.<ref>{{harvtxt|Cox|2007}}</ref><ref>{{harvtxt|Laurikari|2009}}</ref>

Cel de-al treilea algoritm este potrivirea șablonului pe un șir de intrare prin [[backtracking]]. Acest algoritm este denumit în mod obișnuit AFN, dar această terminologie poate fi confuză. Timpul de funcționare poate fi exponențial, ceea ce se întâmplă cu implementările simple atunci când încearcă identificarea unei expresii ca {{Code|code=(a{{!}}aa)*b|lang=perl}} , care conține atât alternanță cât și cuantificare nelimitată și forțează algoritmul să ia în considerare un număr de subcazuri care crește exponențial. Acest comportament poate provoca o problemă de securitate numită {{Ill-wd|Q7300006|3=regular expression denial of service}}.

Deși implementările de backtracking garantează doar timpi exponențiali în cel mai râu caz, ele oferă mult mai multă flexibilitate și putere expresivă. De exemplu, orice implementare care permite utilizarea de backreferences, sau pune în aplicare diferite extensii introduse de Perl, trebuie să includă un fel de backtracking. Unele implementari{{Care?}} încearcă să ofere ce este mai bun în ambii algoritmi, executând la început un algoritm AFD rapid, recurgând la un algoritm potențial mai lent cu backtracking numai atunci când se întâlnește un backreference în timpul potrivirii.

== Unicode ==
Din punct de vedere teoretic, orice set de tokenuri poate fi potrivit prin expresii regulate, atâta timp cât este predefinit. În termeni de implementări istorice, regexurile au fost inițial scrise pentru a utiliza caractere [[ASCII]], deși există biblioteci de regex care suportă și alte {{Ill-wd|Q184759|3=seturi de caractere}}. Multe motoare regex moderne oferă cel puțin suport parțial pentru [[Unicode]]. În cele mai multe privințe, nu contează care este setul de caractere, dar apar totuși unele probleme atunci când se extinde regexul cu suport Unicode.
* '''Codificare suportată'''. Unele biblioteci de regex se așteaptă să meargă pe anumite codificări în locul caracterelor Unicode abstracte. Multe dintre acestea necesită codificarea {{Ill-wd|Q193537}}, în timp ce altele ar putea aștepta {{Ill-wd|Q740701}} sau {{Ill-wd|Q736068}}. Invers, Perl și Java sunt agnostice în ce privește codificările, operând în schimb pe caractere decodificate intern.
* '''Game Unicode suportate'''. Multe motoare de regex suportă numai {{Ill-wd|Q10853148}}, adică acele caractere care pot fi codificate pe doar 16 biți. Actualmente, doar câteva motoare de regex (de exemplu, cele din Perl și Java) pot trata toată gama Unicode de 21 de biți.
* '''Extinderea la Unicode a construcțiilor orientate către ASCII'''. De exemplu, în implementările pe bază de ASCII, gamele de caractere de forma <code>[x-y]</code> sunt valide atunci când ''x'' și ''y'' au {{Ill-wd|Q1105784|3=coduri}} în gama [0x00,0x7F] și când codepoint(''x'') ≤ codepoint(''y''). Extensia naturală a acestor game de caractere la Unicode ar schimba cerința ca codurile lor să fie în gama [0x00,0x7F] la cea ca ele să fie în gama [0x0000,0x10FFFF]. În practică, însă, nu prea este cazul. Unele implementări, cum ar fi cea din [[AWK|gawk]], nu permit ca gamele de caractere să traverseze limitele de blocuri Unicode. O gamă ca [0x61,0x7F] este validă deoarece ambele capete sunt în interiorul blocului Basic Latin, și la fel și [0x0530,0x0560] deoarece ambele capete sunt în interiorul blocului caracterelor armenești, dar o gamă ca [0x0061,0x0532] este invalidă deoarece cuprinde multiple blocuri Unicode. Alte motoare, cum ar fi cel din editorul [[Vim]], permit traversarea limitelor de bloc, dar valorile caracterelor nu pot fi mai depărtate de 256 de poziții.<ref>{{cite web|url=http://vimdoc.sourceforge.net/htmldoc/pattern.html#/%5B%5D|title=Vim documentation: pattern|publisher=Vimdoc.sourceforge.net|accessdate=2013-09-25}}</ref>
* '''Case insensitivity'''. Unele flaguri de case-insensitivity afectează doar caracterele ASCII. Altele afectează toate caracterele. Unele motoare au două flaguri diferite, unul pentru ASCII, altul pentru Unicode. Variază și apartenența caracterelor la clasele POSIX.
* '''Concepte înrudite cu case insensitivity'''. Cum ASCII face distincția între litere mari și mici, conceptul acesta de case insensitivity a devenit o caracteristică logică a căutării de texte. Unicode a introdus scrieri alfabetice fără această distincție, cum ar fi [[Devanagari]]. Acestora nu li se poate aplica conceptul de {{Ill-wd|Q257869}}. Pentru scrieri cum ar fi cea chineză, pare logică o altă distincție: cea între tradițional și simplificat. În simbolurile alfabetului arab, ar putea fi de dorit distincția între {{Ill-wd|Q5972005|3=pozițiile inițială, medială, finală și izolată}}. În japoneză, s-ar putea să se dorească să se ignore diferența între [[hiragana]] și [[katakana]].
* '''Normalizarea'''. Unicode are și [[Unicode|caractere combinabile]]. Ca și la vechile mașini de scris, literele simple pot fi urmate de unul sau mai multe caractere nespațiate (de regulă diacritice și accente) pentru a forma un unic caracter tipărit, dar furnizează și caractere precompuse, care deja includ unul sau mai multe caractere combinabile. Un șir format dintr-un caracter + un caracter combinabil ar trebui să se potrivească cu caracterul precompus identic simplu. Procesul de standardizare a șirurilor de caractere cu caractere combinabile se numește normalizare.
* '''Noi coduri de control'''. Unicode a introdus, printre altele, [[BOM|semne de ordonarea octeților]] și pentru direcția textului. Aceste coduri pot pune probleme speciale.
* '''Introducerea de clase de caractere pentru blocuri Unicode, alfabete, și numeroase alte proprietăți'''. Proprietățile pe blocuri sunt mult mai puțin utile decât cele pe alfabete, întrucât un bloc poate avea coduri din alfabete diferite, iar un alfabet poate avea coduri împrăștiate în multiple blocuri.<ref name="unicode">{{cite web|title=UTS#18 on Unicode Regular Expressions, Annex A: Character Blocks|url=http://unicode.org/reports/tr18/#Character_Blocks|accessdate=2010-02-05}}</ref> În [[Perl]] și în biblioteca {{Javadoc:SE|java/util/regex|package=java.util.regex}}, proprietățile de forma <code>\p{InX}</code> sau <code>\p{Block=X}</code> se potrivesc cu caractere din blocul ''X'' iar <code>\P{InX}</code> sau <code>\P{Block=X}</code> se potrivesc cu coduri care nu se află în blocul respectiv. Analog, <code>\p{Armenian}</code>, <code>\p{IsArmenian}</code>, ori <code>\p{Script=Armenian}</code> se potrivesc cu orice caracter din alfabetul armenesc. În general, <code>\p{X}</code> se potrivește cu orice caracter care fie are proprietatea binară ''X'' fie este în categoria generală ''X''. De exemplu, <code>\p{Lu}</code>, <code>\p{Uppercase_Letter}</code>, sau <code>\p{GC=Lu}</code> se potrivesc cu orice literă mare. Între proprietățile binare care ''nu'' sunt categorii generale se numără <code>\p{White_Space}</code>, <code>\p{Alphabetic}</code>, <code>\p{Math}</code> și <code>\p{Dash}</code>. Exemple de proprietăți nebinare sunt <code>\p{Bidi_Class=Right_to_Left}</code>, <code>\p{Word_Break=A_Letter}</code>, și <code>\p{Numeric_Value=10}</code>.

== Utilizare ==
Regexurile sunt utile într-o varietate de taskuri ce implică {{Ill-wd|Q14802672|3=prelucrarea textului}} și, mai mult, prelucrarea șirurilor de caractere în general, în care datele nu trebuie neapărat să fie textuale. Printre aplicațiile comune se numără {{Ill-wd|Q3306762|3=validarea datelor}}, {{Ill-wd|Q521850|3=scrapingul de date}} (mai ales {{Ill-wd|Q665452}}), {{Ill-wd|Q5227374|3=conversiile datelor între formate}}, [[Parsare|parsări]] simple, producerea de sisteme de {{Ill-wd|Q747907|3=evidențierea sintaxei}}, și multe alte operațiuni.

În timp ce regexurile ar fi utile în [[Motor de căutare|motoarele de căutare]] pe Internet, procesarea acestora pe întregi baze de date ar putea consuma excesiv resurse de calcul în funcție de complexitatea și designul regexului. Deși, în multe cazuri, administratorii de sistem pot rula regexuri pe bază de interogări pe plan intern, cele mai multe motoare de căutare nu oferă suport de regex pentru public. O excepție notabilă este {{Ill-wd|Q775931}}.<ref>{{Citat web|url=https://stackoverflow.com/questions/7778034/replacement-for-google-code-search|titlu=Replacement for Google Code Search?}}</ref>{{Sursă mai bună|date=September 2015}}

== Exemple ==
Regulile specifice de sintaxă pot varia în funcție de implementarea specifică, în funcție de [[Limbaj de programare|limbajul de programare]], sau de {{Ill-wd|Q188860|3=biblioteca}} utilizată. În plus, funcționalitatea implementării de regex poate varia de la o {{Ill-wd|Q10859422|3=versiune}} la alta.

Pentru că regexurile pot fi dificil atât de explicat cât și de înțeles fără exemple, [[#OnlineRegexTesters|site-urile web interactive]] pentru testarea regexurilor sunt o resursă utilă pentru învățarea regexurilor prin experimentare.
Această secțiune oferă o descriere de bază a unor proprietăți ale modului de ilustrare al regexurilor.

În exemple se folosesc următoarele convenții.<ref name="clarify000" group="lower-alpha">Caracterul 'm' nu este întotdeauna utilizat pentru a specifica o operațiune de potrivire [[Perl]].</ref>
 metacaracter(e) ;; coloana metacaracterelor specifică sintaxa regex demonstrată
 =~ m// ;; indică o operațiune de '''potrivire''' regex în Perl
 =~ s/// ;; indică o operațiune de '''substituție''' în Perl
De asemenea, aceste regexuri sunt toate în sintaxa Perl. Expresiile pe standardul [[#POSIX Basic Regular Expressions|POSIX]] sunt diferite.

Dacă nu se indică altfel, următoarele exemple sunt conforme limbajului [[Perl]], versiunea 5.8.8 din 31 ianuarie 2006. Aceasta înseamnă că altor implementări le poate lipsi suportul pentru unele părți ale sintaxei prezentate aici (de exemplu, regex de bază vs extins, <code>\( \)</code> vs <code>()</code>, sau lipsa lui <code>\d</code> în locul lui <code>[:digit:]</code>din POSIX).

Sintaxa și convențiile utilizate în aceste exemple coincid cu cele ale altor medii de programare.<ref>Vezi, de exemplu, ''[[Java (limbaj de programare)|Java]] {{Ill|en|O'Reilly_Media#In_a_Nutshell|4=in a Nutshell}}'', p. 213; ''{{Ill|en|Python_(programming_language)|4=Python}} Scripting for Computational Science'', p. 320; Programming [[PHP]], p. 106.</ref>


{| class="wikitable"
! Meta-<br/>caracter(e)
! Descriere
! Exemple<ref group="lower-alpha">Toate ifurile returnează TRUE</ref>
|-
! <code>.</code>
| Se potrivește în mod normal cu orice caracter cu excepția unui sfârșit de linie. <br/>În paranteze drepte, punctul este un literal.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/...../) {
  print "$string1 are lungime >= 5.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello World
 are lungime >= 5.
</syntaxhighlight>
|-
! <code>( )</code>
| Grupează o serie de elemente de șablon într-unul singur. <br/>La potrivirea expresie dintre paranteze, se poate folsi <code>$1</code>, <code>$2</code>, … ulterior pentru a face referire la textul anterior potrivit.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/(H..).(o..)/) {
  print "We matched '$1' and '$2'.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
We matched 'Hel' and 'o W'.
</syntaxhighlight>
|-
! <code>+</code>
| Potrivește elementul anterior o dată sau de mai multe ori.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/l+/) {
  print "There are one or more consecutive letter \"l\"'s in $string1.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
There are one or more consecutive letter "l"'s in Hello World.
</syntaxhighlight>
|-
! <code>?</code>
| Potrivește prezența elementului anterior o dată sau deloc.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/H.?e/) {
  print "There is an 'H' and a 'e' separated by ";
  print "0-1 characters (e.g., He Hue Hee).\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
There is an 'H' and a 'e' separated by 0-1 characters (e.g., He Hue Hee).
</syntaxhighlight>
|-
! <code>?</code>
| Modifică expresia cu <code>*</code>, <code>+</code>, <code>?</code> sau <code>{M,N}</code> astfel încât să se potrivească cu cât mai puține caractere.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/(l.+?o)/) {
  print "The non-greedy match with 'l' followed by one or\n";
  print "more characters is 'llo' rather than 'llo Wo'.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
The non-greedy match with 'l' followed by one or
more characters is 'llo' rather than 'llo Wo'.
</syntaxhighlight>
|-
! <code>*</code>
| Potrivește prezența elementului anterior de oricâte ori (inclusiv zero).
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/el*o/) {
  print "There is an 'e' followed by zero to many ";
  print "'l' followed by 'o' (e.g., eo, elo, ello, elllo).\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
There is an 'e' followed by zero to many 'l' followed by 'o' (e.g., eo, elo, ello, elllo).
</syntaxhighlight>
|-
! <code>{M,N}</code>
| Notează o potrivire de minim M și maxim N ori.<br/>N poate fi omis, iar M poate fi 0: <code>{M}</code> se potrivește de „exact” M ori; <code>{M,}</code> se potrivește „de cel puțin” M ori; <code>{0,N}</code> se potrivește „de cel mult” N ori.<br/><code>x* y+ z?</code> este astfel echivalent cu <code>x{0,} y{1,} z{0,1}</code>.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/l{1,2}/) {
  print "There exists a substring with at least 1 ";
  print "and at most 2 l's in $string1\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
There exists a substring with at least 1 and at most 2 l's in Hello World
</syntaxhighlight>
|-
! <code>[…]</code>
| Notează un set de potriviri posibile cu caractere.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/[aeiou]+/) {
  print "$string1 contains one or more vowels.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello World
 contains one or more vowels.
</syntaxhighlight>
|-
! <code><nowiki>|</nowiki></code>
| Separă posibilitățile alternative.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/(Hello|Hi|Pogo)/) {
  print "$string1 contains at least one of Hello, Hi, or Pogo.";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello World
 contains at least one of Hello, Hi, or Pogo.
</syntaxhighlight>
|-
! <code>\b</code>
| Se potrivește cu marginea cuvântului (potrivire de lungime zero); la fel ca
<code>(^\w|\w$|\W\w|\w\W)</code>.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/llo\b/) {
  print "There is a word that ends with 'llo'.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
There is a word that ends with 'llo'.
</syntaxhighlight>
|-
! <code>\w</code>
| Se potrivește cu un caracter alfanumeric, inclusiv cu "_"; <br/>la fel ca <code>[A-Za-z0-9_]</code> în ASCII, și
: <code>[\p{Alphabetic}<wbr/>\p{GC=Mark}<wbr/>\p{GC=Decimal_Number}<wbr/>\p{GC=Connector_Punctuation}]</code>
în Unicode,<ref name="unicode" /> unde proprietatea <code>Alphabetic</code> conține mai mult decât litere latinești, iar proprietatea <code>Decimal_Number</code> conține mai mult decât cifrele arabe.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/\w/) {
  print "There is at least one alphanumeric ";
  print "character in $string1 (A-Z, a-z, 0-9, _).\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
There is at least one alphanumeric character in Hello World
 (A-Z, a-z, 0-9, _).
</syntaxhighlight>
|-
! <code>\W</code>
| Se potrivește cu un caracter '''ne'''alfanumeric, excluzând "_"; <br/>ca și <code>[^A-Za-z0-9_]</code> în ASCII, și
:<code>[^\p{Alphabetic}<wbr/>\p{GC=Mark}<wbr/>\p{GC=Decimal_Number}<wbr/>\p{GC=Connector_Punctuation}]</code>
în Unicode.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/\W/) {
  print "The space between Hello and ";
  print "World is not alphanumeric.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
The space between Hello and World is not alphanumeric.
</syntaxhighlight>
|-
! <code>\s</code>
| Se potrivește cu un caracter de whitespace, <br/>care în ASCII sunt tab, line feed, form feed, carriage return, și space; <br/>în Unicode, se potrivește și cu no-<wbr/>break spaces, next line, și cu spațiile de lungime variabilă (printre altele).
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/\s.*\s/) {
  print "In $string1 there are TWO whitespace characters, which may";
  print " be separated by other characters.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
In Hello World
 there are TWO whitespace characters, which may be separated by other characters.
</syntaxhighlight>
|-
! <code>\S</code>
| Se potrivește cu orice în afară de whitespace.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/\S.*\S/) {
  print "In $string1 there are TWO non-whitespace characters, which";
  print " may be separated by other characters.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
In Hello World
 there are TWO non-whitespace characters, which may be separated by other characters.
</syntaxhighlight>
|-
! <code>\d</code>
| Se potrivește cu o cifră; <br/>la fel ca <code>[0-9]</code> în ASCII; <br/>în Unicode, la fel ca proprietățile <code>\p{Digit}</code> sau <code>\p{GC=Decimal_Number}</code>, care la rândul lor sunt similare proprietății <code>\p{Numeric_Type=Decimal}</code>.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "99 bottles of beer on the wall.";
if ($string1 =~ m/(\d+)/) {
  print "$1 is the first number in '$string1'\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
99 is the first number in '99 bottles of beer on the wall.'
</syntaxhighlight>
|-
! <code>\D</code>
| Se potrivește cu orice în afară de cifră; <br/>la fel ca <code>[^0-9]</code> în ASCII sau <code>\P{Digit}</code> în Unicode.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/\D/) {
  print "There is at least one character in $string1";
  print " that is not a digit.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
There is at least one character in Hello World
 that is not a digit.
</syntaxhighlight>
|-
! <code>^</code>
| Se potrivește cu începutul unei linii sau al șirului.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/^He/) {
  print "$string1 starts with the characters 'He'.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello World
 starts with the characters 'He'.
</syntaxhighlight>
|-
! <code>$</code>
| Se potrivește cu sfârșitul liniei sau șirului.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/rld$/) {
  print "$string1 is a line or string ";
  print "that ends with 'rld'.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello World
 is a line or string that ends with 'rld'.
</syntaxhighlight>
|-
! <code>\A</code>
| Se potrivește cu începutul șirului (dar nu al liniei).
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello\nWorld\n";
if ($string1 =~ m/\AH/) {
  print "$string1 is a string ";
  print "that starts with 'H'.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello
World
 is a string that starts with 'H'.
</syntaxhighlight>
|-
! <code>\z</code>
| Se potrivește cu sfârșitul șirului (dar nu al unei linii).<ref name="Perl Best Practices">{{cite book | last = Conway | first = Damian | authorlink = Damian Conway | title = Perl Best Practices | chapter = Regular Expressions, End of String | publisher = [[O'Reilly Media|O'Reilly]] | pages = 240 | url = http://www.scribd.com/doc/15491004/Perl-Best-Practices | year=2005 | isbn = 978-0-596-00173-5}}</ref>
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello\nWorld\n";
if ($string1 =~ m/d\n\z/) {
  print "$string1 is a string ";
  print "that ends with 'd\\n'.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello
World
 is a string that ends with 'd\n'.
</syntaxhighlight>
|-
! <code>[^…]</code>
| Se potrivește cu toate caracterele cu excepția celor din paranteze.
| <syntaxhighlight lang="perl" enclose="div">
$string1 = "Hello World\n";
if ($string1 =~ m/[^abc]/) {
 print "$string1 contains a character other than ";
 print "a, b, and c.\n";
}
</syntaxhighlight>
'''Rezultat:'''
<syntaxhighlight lang="text" enclose="div">
Hello World
 contains a character other than a, b, and c.
</syntaxhighlight>
|}

== Inducție ==
Expresiile regulate pot fi de multe ori create („induse” sau „învățate”), pe baza unui set de exemplu de șiruri de caractere. Acest lucru este cunoscut sub numele de {{Ill-wd|Q17101592|3=inducție a limbajelor regulate}}, și face parte din problema generală a {{Ill-wd|Q5593673|3=inducției gramaticale}} în {{Ill-wd|Q2462783|3=teoria învățării automate}}. Formal, date fiind exemple de șiruri de caractere dintr-un limbaj regulat, și eventual și exemple de șiruri de caractere care ''nu'' fac parte din limbajul regulat, se poate induce o gramatică a limbajului, adică o expresie regulată care generează limbajul. Nu toate limbajele pot fi induse în acest fel, dar multe pot fi. De exemplu, setul de exemple {1, 10, 100}, și setul de contraexemple {11, 1001, 101, 0} pot fi folosite pentru a induce expresia regulată 1⋅0* (1 urmat de zero sau mai multe 0-uri).

== Note de completare ==
{{listănote|group=lower-alpha}}
== Note bibliografice ==
{{listănote|20em}}

== Bibliografie ==
{{Refbegin|20em}}
* {{cite book
 | last = Aho
 | first = Alfred V.
 | author-link =Alfred Aho
 | year = 1990
 | title = Algorithms for finding patterns in strings
 | editor-last = van Leeuwen
 | editor-first = Jan | editor-link = Jan van Leeuwen
 | work = Handbook of Theoretical Computer Science, volume A: Algorithms and Complexity
 | publisher = The MIT Press
 | pages = 255–300
 | ref = harv
 | postscript = <!--None-->
}}
* {{cite book
 | last1 = Aho
 | first1 = Alfred V.
 | authorlink1 = Alfred Aho
 | last2 = Ullman
 | first2 = Jeffrey D.
 | authorlink2 = Jeffrey Ullman
 | year = 1992
 | title = Foundations of Computer Science
 | url = http://infolab.stanford.edu/~ullman/focs.html
 | chapter = Chapter 10. Patterns, Automata, and Regular Expressions
 | chapterurl = http://infolab.stanford.edu/~ullman/focs/ch10.pdf
 | ref = harv
 }}
* {{cite journal
 | publisher = The Open Group
 | url = http://pubs.opengroup.org/onlinepubs/007908799/xbd/re.html
 | title = Regular Expressions
 | work = The Single UNIX ® Specification, Version 2
 | year = 1997
 | ref = harv
 | postscript = <!--None-->
 }}
* {{cite journal
 | publisher = The Open Group
 | url = http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html
 | title = Chapter 9: Regular Expressions
 | work = The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
 | year = 2004
 | ref = harv
 | postscript = <!--None-->
 }}
* {{cite web
 | url = http://swtch.com/~rsc/regexp/regexp1.html
 | title = Regular Expression Matching Can Be Simple and Fast
 | last = Cox
 | first = Russ
 | year = 2007
 | ref = harv
 | postscript = <!--None-->
 }}
* {{cite book
 | first = Ben
 | last = Forta
 | authorlink = Ben Forta
 | year =2004
 | title = Sams Teach Yourself Regular Expressions in 10 Minutes
 | publisher = Sams
 | isbn = 0-672-32566-7
}}
* {{cite book
 | first = Jeffrey
 | last = Friedl
 | authorlink = Jeffrey Friedl
 | year = 2002
 | title = Mastering Regular Expressions
 | url = http://regex.info/
 | publisher = {{Ill-wd|Q1065097|3=O'Reilly}}
 | isbn = 0-596-00289-0
 }}
* {{cite conference
 | last1 = Gelade
 | first1 = Wouter
 | last2 = Neven
 | first2 = Frank
 | title = Succinctness of the Complement and Intersection of Regular Expressions
 | pages = 325–336
 | work = Proceedings of the 25th International Symposium on Theoretical Aspects of Computer Science (STACS 2008)
 | url = http://drops.dagstuhl.de/opus/volltexte/2008/1354
 | year = 2008
 | ref = harv
 | postscript = <!--None-->
 }}
* {{cite book
 | first = Jan
 | last = Goyvaerts
 | authorlink =
 | first2=Steven |last2=Levithan
 | year =2009
 | title = Regular Expressions Cookbook
 | publisher = [O'reilly]
 | isbn = 978-0-596-52068-7
}}
* {{cite conference
 | last1 = Gruber
 | first1 = Hermann
 | last2 = Holzer
 | first2 = Markus
 | title = Finite Automata, Digraph Connectivity, and Regular Expression Size
 | pages = 39–50
 | work = Proceedings of the 35th International Colloquium on Automata, Languages and Programming (ICALP 2008)
 | url = http://www.hermann-gruber.com/data/icalp08.pdf
 | year = 2008
 | doi = 10.1007/978-3-540-70583-3_4
 | volume = 5126
 | ref = harv
 | postscript = <!--None-->
 }}
* {{cite book
 | first = Mehran
 | last = Habibi
 | year =2004
 | title = Real World Regular Expressions with Java 1.4
 | publisher = Springer
 | isbn = 1-59059-107-0
}}
* {{cite book
 | last1 = Hopcroft
 | first1 = John E.
 | last2 = Motwani
 | first2 = Rajeev
 | last3 = Ullman
 | first3 = Jeffrey D.
 | title = Introduction to Automata Theory, Languages, and Computation
 | publisher = Addison-Wesley
 | year = 2000
 | edition = 2nd
 | ref = harv
}}
* {{Cite journal | last1 = Johnson | first1 = W. L. | last2 = Porter | first2 = J. H. | last3 = Ackley | first3 = S. I. | last4 = Ross | first4 = D. T. | title = Automatic generation of efficient lexical processors using finite state techniques | doi = 10.1145/364175.364185 | journal = Communications of the ACM | volume = 11 | issue = 12 | pages = 805–813| year = 1968 | pmid = | pmc = | ref = harv }}
* {{cite book
 |last = Kleene
 |first = Stephen C.
 |title = Representation of Events in Nerve Nets and Finite Automata
 |work = Automata Studies
 |editor1-last = Shannon
 |editor1-first = Claude E.
 |editor2-last = McCarthy
 |editor2-first = John
 |publisher = Princeton University Press
 |year = 1956
 |pages = 3–42
 |ref = harv
 |postscript = <!--None-->
}}
* {{cite journal
 |last = Kozen
 |first = Dexter
 |title = A Completeness Theorem for Kleene Algebras and the Algebra of Regular Events
 |work = Proceedings of the 6th Annual IEEE Symposium on Logic in Computer Science (LICS 1991)
 |pages = 214–225
 |year = 1991
 |ref = harv
 |postscript = <!--None-->
}}
* {{cite web
 | url = http://www.laurikari.net/tre/
 | title = TRE library 0.7.6
 | first = Ville
 | last = Laurikari
 | year = 2009
 | ref = harv
 }}
* {{cite book
 | first = Francois
 | last = Liger
 |author2=Craig McQueen |author3=Paul Wilton
 | year =2002
 | title = Visual Basic .NET Text Manipulation Handbook
 | publisher = {{Ill-wd|Q4053259}}
 | isbn = 1-86100-730-2
}}
* {{cite book
 | first = Michael
 | last = Sipser
 | authorlink = Michael Sipser
 | year =1998
 | title = Introduction to the Theory of Computation
 | chapter = Chapter 1: Regular Languages
 | pages = 31–90
 | publisher = PWS Publishing
 | isbn = 0-534-94728-X
 | ref = harv
}}
* {{cite book
 | first = Tony
 | last = Stubblebine
 | year =2003
 | title = Regular Expression Pocket Reference
 | publisher = O'Reilly
 | isbn = 0-596-00415-X
}}
* {{Cite journal | last = Thompson | first = K. | authorlink = Ken Thompson | title = Programming Techniques: Regular expression search algorithm | doi = 10.1145/363347.363387 | journal = Communications of the ACM | volume = 11 | issue = 6 | pages = 419–422 | year = 1968 | ref = Harv }}
* {{cite web
 | url=http://dev.perl.org/perl6/doc/design/apo/A05.html
 | title=Apocalypse 5: Pattern Matching
 | first=Larry
 | last=Wall
 | authorlink=Larry Wall
 | year=2002
 | ref=harv
 | accessdate=2017-02-28
 | archive-date=2010-01-12
 | archive-url=https://web.archive.org/web/20100112232513/http://dev.perl.org/perl6/doc/design/apo/A05.html
 | dead-url=yes
 }}
{{Refend}}


[[Categorie:Limbaje formale și automate]]