Den vanligaste användningen av reguljära uttryck i Perl är i sök- och ersätt-operatorer som t.ex s//, m/, länkoperatorer =~ eller != etc. Som regel har alla dessa operatörer liknande alternativ som:
Vanligtvis betecknas alla dessa alternativ som "/x". De kan till och med användas inuti mallar med den nya konstruktionen (?...)
Reguljära uttryck eller mönster (mönster) är samma som regexp-procedurer i Unix. Uttrycken och syntaxen är lånade från Henry Spencers fritt distribuerade V8-rutiner och beskrivs i detalj där.
Mallar använder följande metatecken (tecken som anger grupper av andra tecken) som ofta kallas egrep-standarden:
Metatecken har modifierare (skrivna efter metatecken):
I alla andra fall behandlas lockiga hängslen som normala (vanliga) tecken. Således är "*" ekvivalent med (0,), "+" till (1,) och "?" - (0,1). n och m får inte vara större än 65536.
Standardåtgärden för metatecken är "girig". Matchen förlängs så många gånger som möjligt, oavsett resultatet av följande metatecken. Om du vill "minska deras aptit", använd sedan tecknet "?". Det ändrar inte betydelsen av metakaraktärerna, det minskar bara spridningen. På det här sättet:
Mönster fungerar på samma sätt som dubbla citattecken, så du kan använda `\` - tecken (omvänt snedstreck) i dem:
| \t | - tabbtecken |
| \n | - ny linje |
| \r | - en vagnretur |
| \a | - formatöversättning |
| \v | - vertikal flik |
| \a | - ringa upp |
| \e | - fly |
| \033 | - oktal teckennotation |
| \x1A | - hexadecimalt |
| \c[ | - kontrollkaraktär |
| \l | - nästa tecken med gemener |
| \u | - versaler -//- |
| \L | - alla gemener upp till \E |
| \U | - i toppen -//- |
| \E | - växlingsbegränsare |
| \Q | - ångra åtgärd som metatecken |
Dessutom har följande metatecken lagts till i Perl:
Observera att allt detta är "ett" tecken. Använd modifierare för att ange en sekvens. Så:
Dessutom finns det imaginära metakaraktärer. Betecknar icke-existerande tecken i stället för värdeförändringen. Till exempel:
Ordgränsen (\b) är den tänkta punkten mellan tecknen \w och \W. Inom en teckenklass anger "\b" ett backsteg (radera) tecken. Metakaraktärer \A och \Z- liknande "^" och "$", men om början av raden "^" och slutet av raden "$" är giltiga för varje rad i flerradssträngen, då \A och \Z ange början och slutet av hela flerradssträngen.
Om gruppering (parentes) används inom mönstret, betecknas gruppens delsträngnummer som "\nummer". Observera att efter mönstret inom ett uttryck eller block, betecknas dessa grupper som "$nummer". Dessutom finns det ytterligare variabler:
Exempel:
$s = "En 1 två 2 och tre 3"; if ($s =~ /(\d+)\D+(\d+)/) ( skriv ut "$1\n"; # Resultat "1" skriv ut "$2\n"; # "2" skriv ut "$+\n" ; # "2" skriv ut "$&\n"; # "1 två 2" skriv ut "$`\n"; # "En " utskrift "$"\n"; # " och tre 3" )
Perl version 5 innehåller ytterligare mallkonstruktioner:
Exempel:
$s = "1+2-3*4"; if ($s =~ /(\d)(?=-)/) # Hitta siffran följt av "-" (skriv ut "$1\n"; # Resultatet är "2") annars (skriv ut "sökning misslyckades\n) ";)
(?!mall) - "kikar" fram genom negation:
Exempel:
$s = "1+2-3*4"; if ($s =~ /(\d)(?!\+)/) # Hitta en siffra som inte följs av ett "+" (skriv ut "$1\n"; # Resultatet är "2") annars (skriv ut "sök misslyckades\ n"; )
(?ismx) - "interna" modifierare. Det är bekvämt att använda i mallar, där du till exempel behöver ange en modifierare inuti mallen.
Regler för reguljära uttryck. (regex)
- Vilken karaktär som helst står för sig själv, såvida det inte är en metakaraktär. Om du behöver ångra en metatecken, föregå den med ett "\".
- En sträng av tecken anger en sträng av dessa tecken.
- Uppsättningen av möjliga tecken (klass) är omgiven av hakparenteser "", vilket betyder att ett av tecknen som anges inom parentes kan finnas på denna plats. Om det första tecknet inom parentes är "^" - kan inget av de angivna tecknen finnas på denna plats i uttrycket. Inom en klass kan du använda tecknet "-" för att ange ett antal tecken. Till exempel är a-z en av de små bokstäverna i det latinska alfabetet, 0-9 är en siffra och så vidare. PHP-portalforum. SU
Reguljära uttryck låter dig hitta sekvenser i en sträng som matchar ett mönster. Till exempel, mallen "Vasya (. *) Pupkin" låter dig hitta en sekvens när det kommer att finnas hur många tecken som helst mellan orden Vasya och Pupkin. Om du behöver hitta sex siffror skriver vi "(6)" (om till exempel från sex till åtta siffror, då "(6,8)"). Detta skiljer saker som teckenuppsättningspekare och nummerkravspekare:
<набор символов><квантификатор><жадность>
Istället för en uppsättning tecken kan beteckningen för vilket tecken som helst användas - en prick, en specifik uppsättning tecken kan anges (sekvenser stöds - de nämnda "0-9"). Kan anges "annat än denna teckenuppsättning".
Indikatorn för teckenantal kallas "kvantifierare" i den officiella php-dokumentationen. Termen är bekväm och bär inga falska rykten. Så en kvantifierare kan ha antingen ett specifikt värde - antingen ett fast ("(6)"), eller som ett numeriskt område ("(6,8)"), eller ett abstrakt "vilket som helst tal, inklusive 0" (" * "), "valfritt naturligt tal" - från 1 till oändligt ("+": "dokument+.txt"), "antingen 0 eller 1" ("?"). Standardkvantifieraren för denna teckenuppsättning är ett ("document.txt").
För en mer flexibel sökning efter kombinationer kan dessa "teckenuppsättning - kvantifierare"-buntar kombineras till metastrukturer.
Som alla flexibla verktyg är reguljära uttryck flexibla, men inte absolut: deras omfattning är begränsad. Till exempel, om du behöver ersätta en fast sträng i texten med en annan, fixad igen, använd str_replace. PHP-utvecklare ber tårögt att inte använda de komplexa funktionerna ereg_replace eller preg_replace för detta, för när de anropas tolkas strängen och detta förbrukar systemresurser på allvar. Tyvärr är detta en favorit rake av nybörjare php-programmerare.
Använd bara reguljära uttrycksfunktioner om du inte vet exakt vilken sträng som är "där". Från exempel: en sökkod där tjänstecken och korta ord klipps ut ur söksträngen, samt extra mellanslag klipps ut (eller snarare, alla mellanslag komprimeras: "+" ersätts med ett mellanslag). Med dessa funktioner kontrollerar jag e-posten till användaren som lämnar en recension. Många användbara saker kan göras, men det är viktigt att tänka på att reguljära uttryck inte är allsmäktig. Till exempel är det bättre att inte göra en komplex ersättning i en stor text. När allt kommer omkring, till exempel kombinationen "(.*)" i programplan betyder att upprepa alla tecken i texten. Och om mallen inte är bunden till början eller slutet av raden, då "flyttar" själva mallen genom hela texten, och en dubbel uppräkning erhålls, eller snarare, uppräkning i kvadrat. Det är lätt att gissa att en annan kombination "(.*)" betyder iteration i kuben och så vidare. Höj till tredje potens, säg 5 kilobyte text. Det visar sig 125 000 000 000 (med ord: hundra tjugofem miljarder transaktioner). Naturligtvis, om du närmar dig strikt, kommer det inte att bli så många operationer, men det kommer att bli fyra till åtta gånger färre, men själva ordningen på siffrorna är viktig.
Karaktärsuppsättning
| . | punkt | vilken karaktär som helst |
| [<символы>] | hakparentes | teckenklass ("någon av"). Till exempel |
| [^<символы>] | negativ karaktärsklass ("alla men") | |
| - | rusa | beteckning av en sekvens i en teckenklass ("" siffror) |
| \d | Endast siffror | |
| \D | [^0-9] | Förutom siffror |
| \w | Bokstäver och siffror | |
| \W | [^a-z0-9] | Förutom bokstäver och siffror |
| \s | Blanktecken: blanksteg, tab, nyrad | |
| \S | [^ ] | Förutom blanksteg |
| | | (en|annan) | Denna plats kan vara ett av de listade alternativen, till exempel: (Vasya|Petya|Masha). Om du inte vill att den ska väljas använd (?: ...) |
Använd inte en teckenklass för att representera bara en (ett "+" fungerar bra istället för "+"). Skriv inte en prick i en teckenklass eftersom detta är vilket tecken som helst, då blir andra tecken i klassen helt enkelt överflödiga (och i negativ klass kommer att resultera i negation av alla tecken).
Kvantifierare
En kvantifierare kan ange både ett specifikt värde och gränser. Om det angivna talet faller inom kvantifierarens gränser, anses fragmentet av uttrycket matcha den analyserade strängen. Syntax:
{<количество> }
{<минимум> , <максимум> }
Om du bara behöver ange det erforderliga minimumet, men det finns inget maximum, sätt bara ett kommatecken och skriv inte den andra siffran: "(5,)" ("minst 5"). Det finns speciella notationer för de mest använda kvantifierarna:
I praktiken används sådana tecken oftare än lockiga hängslen.
Ankare
Dessa karaktärer måste förekomma i början respektive i slutet av raden.
Girighet
Frågetecknet fungerar också som en kvantifieringsminimering:.*?
$1"; $re1 = "|\ (.*) \|ixs"; $re2 = "|\ (.*?) \|ixs"; $result = preg_replace($re1, $to, $str); echo " Girig version: ".htmlspecialchars($result,null,"windows-1251")."
"; $result = preg_replace($re2, $to, $str); echo "Lazy version: ".htmlspecialchars($result,null,"windows-1251")."
"; ?> Exempelutdata: Greedy version: fet text [b] och här - ännu djärvare tillbaka Lat version: fet text [b] och här - ännu fetare returnerad
Mallsträngen, som du redan har märkt, börjar och slutar med snedstreck. Efter den andra kommer parametrarna:
| i | skiftlägeskänslig sökning |
| m | flerlinjeläge. Som standard matchar PCRE mönstret endast inom en enda rad, och tecknen "^" och "$" matchar bara början och slutet av hela texten. När det här alternativet är inställt matchar "^" och "$" början och slutet av enskilda rader. |
| s | symbol "." (prick) matchar också radbrytning (standard ingen) |
| A | ankare till början av texten |
| E | gör att "$"-tecknet endast matchar slutet av texten. Ignoreras om m är inställt. |
| U | Inverterar "girighet" för varje kvantifierare (om det finns ett "?" efter kvantifieraren är den kvantifieraren inte längre "girig"). |
| e | Ersättningssträngen tolkas som PHP-kod. |
Funktioner för att arbeta med reguljära uttryck
- preg_grep
- preg_match - Utför en matchningskontroll vanligt uttryck. Denna funktion letar bara efter den första matchningen!
- preg_match_all
- preg_quote - Escape-tecken i reguljära uttryck. De där. infogar snedstreck före alla servicetecken (till exempel parenteser, hakparenteser etc.) så att de tas bokstavligt. Om du har någon användarinmatning och du kontrollerar den med reguljära uttryck, är det bättre att undvika tjänstetecknen i den inkommande variabeln innan det
- preg_replace
- preg_replace_callback - Utför en sökning och ersätt med reguljära uttryck
- preg_split
preg_grep
Fungera preg_grep- Returnerar en uppsättning av förekomster som matchar mönstret
Syntax
array preg_grep(strängmönster, array-ingång [, int-flaggor])
preg_grep() returnerar en array som består av elementen i indatamatrisen som matchar det givna mönstret.
Flaggsparametern kan ha följande värden:
PREG_GREP_INVERT
Om denna flagga är inställd returnerar preg_grep()-funktionen dessa arrayelement, som inte matchar det givna mönstret.
Resultatet som returneras av preg_grep() använder samma index som den ursprungliga datamatrisen. Om det här beteendet inte passar dig, använd array_values() på arrayen som returneras av preg_grep() för omindexering.
Kodexempel:
// Returnerar alla arrayelement // som innehåller flytningar $fl_array = preg_grep("/^(\d+)?\.\d+$/", $array);
preg_match
Fungera preg_match- Utför matchning av reguljära uttryck
Syntax
int preg_match(strängmönster, strängämne [, array matchar [, int flaggor [, int offset]]]) Söker i det givna textämnet efter matchningar med mönster
Om ytterligare parameter matchningar anges, kommer den att fyllas i med sökresultaten. Elementet $matches kommer att innehålla den del av strängen som matchar förekomsten av hela mönstret, $matchar den del av strängen som matchar det första delmönstret, och så vidare.
flaggor kan ha följande värden:
PREG_OFFSET_CAPTURE
Sökningen utförs från vänster till höger, från början av raden. Den valfria offsetparametern kan användas för att ange en alternativ startposition för sökningen. Ett liknande resultat kan uppnås genom att ersätta ämne med substr()($subject, $offset).
Funktionen preg_match() returnerar antalet hittade matchningar. Det kan vara 0 (inga matchningar hittades) och 1 eftersom preg_match() slutar efter den första matchningen som hittas. Om du behöver hitta eller räkna alla matchningar bör du använda funktionen preg_match_all() . Funktionen preg_match() returnerar FALSE om några fel inträffade under körningen.
Rekommendation: Använd inte funktionen preg_match() om du behöver kontrollera om det finns en delsträng i en given sträng. Använd strpos() eller strstr() för detta, eftersom de kommer att göra jobbet mycket snabbare.
Kodexempel
Kodexempel
Kodexempel
Resultatet av exemplet:domännamn är: webbplats
preg_match_all
Fungera preg_match_all- Utför en global mönstersökning i en sträng
Syntax
int preg_match_all(strängmönster, strängämne, arraymatcher [, int flaggor [, int offset]])
Söker i ämnet efter alla matchningar av mönster och placerar resultatet i matchningsarrayen i den ordning som anges av flaggkombinationen.
Efter att ha hittat den första matchningen kommer efterföljande sökningar att utföras inte från början av strängen, utan från slutet av den senast hittade förekomsten.
Den valfria flaggparametern kan kombinera följande värden (tänk på att det är meningslöst att använda PREG_PATTERN_ORDER samtidigt som PREG_SET_ORDER):
PREG_PATTERN_ORDER
Om denna flagga är inställd kommer resultatet att ordnas enligt följande: $matches-elementet innehåller en array av fullständiga matchningar av mönstret, $matches-elementet innehåller en array av förekomster av det första undermönstret, och så vidare.
Kodexempel
]+>(.*)]+>|U", " exempel:Som vi kan se innehåller $out en array med fullständiga matchningar av mönstret, och $out-elementet innehåller en array av delsträngar som finns i taggarna.
PREG_SET_ORDER
Om denna flagga är inställd kommer resultatet att ordnas enligt följande: $matches-elementet innehåller den första uppsättningen av förekomster, $matches-elementet innehåller den andra uppsättningen av förekomster, och så vidare.
Kodexempel
]+>(.*)]+>|U", " exempel:I det här fallet innehåller arrayen $matches den första uppsättningen av förekomster, nämligen: elementet $matches innehåller den första förekomsten av hela mönstret, elementet $matches innehåller den första förekomsten av det första undermönstret, och så vidare. På liknande sätt innehåller arrayen $matches den andra uppsättningen av matchningar och så vidare för varje hittad uppsättning.
PREG_OFFSET_CAPTURE
Om denna flagga anges, kommer dess position i källsträngen att indikeras för varje delsträng som hittas. Man måste komma ihåg att denna flagga ändrar formatet för den returnerade datan: varje förekomst returneras som en array, vars nollelement innehåller den hittade delsträngen, och det första elementet innehåller offset.
Om ingen flagga används används PREG_PATTERN_ORDER som standard.
Sökningen utförs från vänster till höger, från början av raden. Den valfria offsetparametern kan användas för att ange en alternativ startposition för sökningen. Ett liknande resultat kan uppnås genom att ersätta ämne med substr()($subject, $offset).
Returnerar antalet förekomster av mönstret som hittats (kan vara noll) eller FALSK om några fel inträffade under körningen.
Kodexempel
Kodexempel
fettextKlicka här";preg_match_all("/(<([\w]+)[^>]*>)(.*)(<\/\\2>)/", $html, $matches); för ($i=0; $i< count($matches); $i++) { echo "matched: " . $matches[$i] . "\n"; echo "part 1: " . $matches[$i] . "\n"; echo "part 2: " . $matches[$i] . "\n"; echo "part 3: " . $matches[$i] . "\n\n"; } ?>Resultatet av exemplet: matchade: fettext del 1: del 2: fet text del 3: matchade: Klicka här del 1: del 2: klicka på mig del 3:preg_quote
Fungera preg_quote- Escape-tecken i reguljära uttryck
Syntax
sträng preg_quote(sträng str[, strängavgränsare])
Funktionen preg_quote() tar strängen str och lägger till ett omvänt snedstreck före varje escape-tecken. Detta kan vara användbart om strängvariabler är involverade i mallkompileringen, vars värde kan ändras under skriptkörningen.
Om den valfria avgränsningsparametern anges kommer den också att escapes. Detta är användbart för att undvika en avgränsare som används i PCRE-funktioner. Den vanligaste avgränsaren är tecknet "/".
I reguljära uttryck betraktas följande tecken som servicetecken: . \\ + * ? [ ^ ] $ () ( ) = !< > | :
Kodexempel
Kodexempel
". $ord ."", $textbody); echo $textbody; ?> Exempelresultat: Den här boken är *mycket* svårt att hitta.preg_replace
Fungera preg_replace- Utför en sökning och ersätt med ett reguljärt uttryck
Syntax
blandad preg_replace(blandat mönster, blandat ersättning, blandat ämne [, int limit])
Söker i ämnet efter matchningar av mönster och ersätter dem med ersättning. Om gränsparametern anges kommer gränsförekomsterna av mallen att ersättas; om gränsen utelämnas eller är lika med -1 kommer alla förekomster av mönstret att ersättas.
Ersättning kan innehålla referenser av formen \\n eller (sedan PHP 4.0.4) $n, med den senare att föredra. Varje sådan referens kommer att ersättas med en delsträng som motsvarar det n:te delmönstret inom parentes. n kan ha värden från 0 till 99, med \\0 (eller $0) referensen som motsvarar förekomsten av hela mönstret. Delmönster är numrerade från vänster till höger, från ett .
När du använder jokerteckensersättning med hjälp av submönsterreferenser kan det finnas en situation där en siffra omedelbart följer masken. I det här fallet resulterar \\n-notationen i ett fel: en referens till det första delmönstret följt av en 1 kommer att skrivas som \\11, vilket kommer att tolkas som en referens till det elfte delmönstret. Detta missförstånd kan elimineras genom att använda konstruktionen \$(1)1, som pekar på en isolerad referens till det första delmönstret, följt av siffran 1.
Kodexempel
Resultatet av detta exempel kommer att vara:
Om en mönstermatchning hittas under exekveringen av funktionen kommer det ändrade ämnesvärdet att returneras, annars returneras den ursprungliga ämnestexten.
De tre första parametrarna i preg_replace()-funktionen kan vara endimensionella arrayer. Om arrayen använder nycklar, kommer de vid bearbetning av arrayen att tas i den ordning som de är placerade i arrayen. Att ange nycklar i arrayen för mönster och ersättning är valfritt. Om du väljer att använda index, använd funktionen ksort() på varje array för att matcha mönstren och strängarna som ingår i ersättningen.
Björnen svarta långsam hoppade över den lata hunden.
Med ksort() får vi det önskade resultatet:
Den långsamma svartbjörnen hoppade över den lata hunden.
Om ämnesparametern är en array, utförs en mönstersökning och ersättning för vart och ett av dess element. Det returnerade resultatet kommer också att vara en array.
Om parametrarna mönster och ersättning är arrayer, extraherar preg_replace() ett par element från båda arrayerna i tur och ordning och använder dem för sök- och ersätt-operationen. Om ersättningsmatrisen innehåller fler element än mönster, kommer tomma strängar att tas istället för de saknade elementen för ersättning. Om mönster är en array och ersättning är en sträng, kommer varje element i arraymönstret att sökas igenom och ersättas med mönster (mönstret kommer att vara alla arrayelement i tur och ordning, medan ersättningssträngen förblir fixerad). Alternativet när mönster är en sträng och ersättning är en array är inte vettigt.
/e-modifieraren ändrar beteendet för preg_replace()-funktionen på ett sådant sätt att ersättningsparametern, efter att ha utfört de nödvändiga ersättningarna, tolkas som PHP-kod och endast då används för ersättning. När du använder denna modifierare, var försiktig: ersättningsparametern måste innehålla giltig PHP-kod, annars kommer ett syntaxfel att uppstå på raden som innehåller anropet till preg_replace()-funktionen.
Kodexempel: Ersätt med flera mönster
Detta exempel kommer att mata ut:
$startDate = "5/27/1999";
Kodexempel: Använda /e-modifieraren
]*>)/e", ""\\1".strtoupper("\\2")."\\3"", $html_body); ?>Kodexempel: Konvertera alla HTML-taggar till versaler
]*?>.*?"si", // Klipp ut javaScript ""<[\/\!]*?[^<>]*?>"si", // Tar bort HTML-taggar ""([\r\n])[\s]+"", // Tar bort blanktecken ""&(quot|#34);"i" , // Ersätter HTML-entiteter ""&(amp|#38);"i", ""&(lt|#60);"i", ""&(gt|#62);"i", " "& (nbsp|#160);"i", ""&(iexcl|#161);"i", ""&(cent|#162);"i", ""&(pound|#163) ;" i", ""&(kopia|#169);"i", ""(\d+);"e"); // tolka som php-kod $replace = array ("", "", "\\1", "\"", "&", "<", ">", " ", chr(161), chr(162), chr(163), chr(169), "chr(\\1)"); $text = preg_replace($search, $replace, $document); ?>preg_replace_callback
Fungera preg_replace_callback- Utför en sökning och ersätt med reguljära uttryck med en återuppringningsfunktion
Syntax
blandad preg_replace_callback(blandat mönster, återuppringning, blandat ämne [, int limit])
Beteendet för den här funktionen är ungefär som preg_replace(), förutom att istället för ersättningsparametern måste du ange en återuppringningsfunktion, som skickas till en uppsättning av hittade förekomster som en indataparameter. Det förväntade resultatet är strängen som ska ersättas.
Kodexempel
\s*\w|", create_function(// Det är viktigt att använda enstaka citattecken i det här fallet, // alternativet är att undvika alla tecken "$" "$matches", "return strtolower($matches);"), $line ); echo $line; ) fclose($fp); ?>preg_split
Fungera preg_split- Delar en sträng genom reguljärt uttryck
Syntax
array preg_split(strängmönster, strängämne [, int limit [, int flaggor]])
Returnerar en array som består av delsträngar av det givna strängämnet, uppdelat längs matchande gränsmönster.
Om limit-parametern anges returnerar funktionen inte mer än limit-delsträngar. Det speciella gränsvärdet -1 innebär ingen gräns, vilket är mycket användbart för att specificera en annan valfri flaggparameter.
Flaggor kan vara valfri kombination av följande flaggor (anslutningen görs med operatorn "|"):
PREG_SPLIT_NO_EMPTY
Om denna flagga anges kommer preg_split()-funktionen endast att returnera icke-tomma delsträngar.
PREG_SPLIT_DELIM_CAPTURE
Om denna flagga anges extraheras även uttrycket inom parentes i avgränsningsmönstret från den givna strängen och returneras av funktionen. Denna flagga lades till i PHP 4.0.5.
PREG_SPLIT_OFFSET_CAPTURE
Om denna flagga anges, kommer dess position i källsträngen att indikeras för varje hittad delsträng. Man måste komma ihåg att denna flagga ändrar formatet för den returnerade datan: varje förekomst returneras som en array, vars nollelement innehåller den hittade delsträngen, och det första elementet innehåller offset.
Kodexempel
Om den inledande parentesen följs av " ?: ", strängen fångas inte och det aktuella undermönstret är inte numrerat. Till exempel, om strängen "den vita drottningen" matchar mönstret ((?:röd|vit) (kung|drottning)), understrängarna "vit drottning" " och " drottning ", och de kommer att numreras 1 respektive 2:
$r="/the ((?:röd|vit) (kung|drottning))/"; 0="den vita kungen"; 1="vit kung"; 2="kung";
Mer om reguljära uttryck:
Reguljära uttryckskontrolltjänster:
Läs mer: Bibliotek ringla i PHP
.
En av de mycket kraftfulla och användbara funktionerna i PHP-språket är stöd för reguljära uttryck. Många programmerare, både nybörjare och ganska erfarna, skrämmas av den yttre komplexiteten och krångligheterna i det reguljära uttrycksspråket. Men jag kan försäkra dig, det är värt det. Användningen av reguljära uttryck underlättar i hög grad arbetet med att bearbeta texter och löst strukturerad data.
Reguljära uttryck är uttryck skrivna på ett speciellt språk. Var inte rädd, språket är ganska lätt att förstå, du behöver bara erfarenhet och övning.
Jag tror att du upprepade gånger har stött på situationer när du har en text (till exempel i Microsoft Word) och du behöver hitta något viktigt i den. Om du vet vad du letar efter - allt är enkelt: du tog fram sökdialogrutan, skrev in sökordet, tryckte på knappen och voila - texten hittades.
Men vad gör du om du i förväg bara vet vilken typ av information du letar efter? Du ställs till exempel inför uppgiften att hitta alla e-postadresser i ett dokument på ett par hundra ark. Vissa kommer att skanna dokumentet manuellt, andra kommer att söka efter en hund (@) och söka efter den. Håller med - båda varianterna är hårt arbete otacksamt arbete.
Det är här reguljära uttryck kommer in. Till viss del kan reguljära uttryck jämföras med masker eller mönster som är överlagrade på text: om texten matchar masken är detta det önskade fragmentet. Men innan vi överväger användningen av reguljära uttryck kommer vi att bekanta oss med deras syntax.
Ett reguljärt uttryck är en textsträng som är sammansatt enligt vissa lagar och regler. En sträng består av tecken och grupper av tecken, metatecken, kvantifierare och modifierare.
Symboler i det här fallet är alla symboler i vilket alfabet som helst. Och inte bara läsbar. Du kan mycket väl infoga ett oläsligt tecken i uttrycket, för detta behöver du bara känna till dess kod i hexadecimal form. Till exempel:
// läsbara tecken a E // oläsbara tecken och koder \x41 - samma som bokstaven "A" \x09 - tabbtecken
En grupp av tecken är flera tecken skrivna i följd:
Abcg ACZms
Jag uppmärksammar dig direkt - "utrymmet" i reguljära uttryck anses också vara en betydande karaktär, så var försiktig när du skriver uttryck. Till exempel är dessa teckengrupper OLIKA uttryck:
ABCWHERE ABC VAR
Nästa språkelement är metatecken. Prefixet "meta" betyder att dessa symboler beskriver några andra symboler eller deras grupper. Tabellen diskuterar de viktigaste metakaraktärerna i det reguljära uttrycksspråket:
| Metatecken för att specificera specialtecken | |
| () | Parentes. Definiera kapslade uttryck. |
| | | Valmetakaraktär |
| ^ | Linjestart metatecken |
| $ | End-of-line metatecken |
| \n | Radmatningstecken (hexadecimal kod 0x0A) |
| \r | vagnreturtecken (hexadecimal kod 0x0D) |
| \t | Tab-tecken (hexadecimal kod 0x09) |
| \xhh | Om du infogar ett tecken med hexadecimal kod 0xhh, till exempel \x42, infogas den latinska bokstaven "B" |
| Metatecken för att specificera teckengrupper | |
| . | Punkt. Vilken karaktär som helst. |
| \d | Siffra (0-9) |
| \D | Inte en siffra (vilket tecken som helst utom tecknen 0-9) |
| \s | Tomt tecken (vanligtvis mellanslag och tabbtecken) |
| \S | Ett icke-tomt tecken (allt annat än de tecken som identifieras av metateckenet \s) |
| \w | "Ordbok"-tecken (ett tecken som används i ord. Vanligtvis alla bokstäver, alla siffror och understreck ("_")) |
| \W | Alla utom de tecken som definieras av metatecken \w |
Mettecken från andra halvan av tabellen är mycket lätta att komma ihåg. "d" - siffra (nummer), "s" - symbol (symbol), "w" - ord (ord). Om bokstaven är stor måste du lägga till "NOT" i beskrivningen av gruppen.
Låt oss ta till exempel texten "På den röda tröjan är siffrorna 1812, och på den gröna tröjan - 2009". Tänk på exempel på de enklaste reguljära uttrycken:
\d\d\d\d - matchar 1812 och 2009 \D - matchar alla bokstäver, mellanslag och skiljetecken \s - matchar alla mellanslag i texten.
Men trots allt kan året i vårt exempel inte skrivas med fyra, utan med två siffror, ord kan ha andra deklinationer, etc. Underuppsättningar av tecken som specificeras med hakparenteser kan hjälpa till här:
Betyder vilken siffra som helst (samma som \d) - betyder jämn siffra - betyder vilket tecken som helst i det latinska alfabetet (i alla fall) eller siffra.
Till exempel kommer uttrycket \d\d\d i teststrängen bara hitta 1812, inte 2009. Detta uttryck ska läsas som "hitta alla sekvenser av fyra siffror där den sista siffran är 0,2,4,6, eller 8".
Vi behöver bara nämna kvantifierare och modifierare.
Kvantifierareär en speciell konstruktion som bestämmer hur många gånger en karaktär eller grupp av tecken måste förekomma. Kvantifieraren skrivs inom parentes "()". Två inspelningsformat är möjliga: exakt och omfång. Exakt formatet skrivs så här:
Här är X antalet gånger föregående tecken eller grupp måste upprepas. Till exempel uttrycket
Den andra formen av notation är räckvidd. Skrivet som
(X, Y) // eller (,Y) // eller (X,)
där X är minimum och Y är maximalt antal repetitioner. Till exempel:
läsas som "från två till fyra på varandra följande siffror". Om en av gränserna inte är specificerad, antas ingen begränsning. Till exempel:
\w(3,) - tre eller fler bokstäver. \d(,5) - det finns inga siffror alls, eller det finns, men inte fler än fem.
Kvantifierare kan tillämpas på ett enda tecken eller på en grupp:
[A-Zaa-Z](1,3)
Denna konstruktion kommer att välja från texten alla ryska ord med en, två eller tre bokstäver (till exempel "eller", "inte", "jag", "jag går", etc.)
Förutom lockiga hängslen med, finns det ytterligare tre kvantifierande metatecken: "*" (asterisk), "+" (plus) och "?" (fråga). De används i de fall där det minsta och maximala antalet nödvändiga repetitioner inte är känt i förväg. När du till exempel letar upp e-postadresser kan du inte säga i förväg hur många tecken som kommer att finnas i användarnamnet (före "hund") och hur många tecken som kommer att finnas i domännamnet (efter "hund").
"*"-metateckenet läses som "valfritt tal från noll eller mer", dvs. design
definierar valfritt antal på varandra följande bokstäver, inklusive deras fullständiga frånvaro.
Tecknet "+" skiljer sig från asterisken endast genom att det kräver minst ett tecken. De där. design
matchar valfri siffersekvens där det finns en eller flera siffror.
Symbol "?" matchar frånvaron eller närvaron av ett enskilt tecken. De där. design
matchar valfri siffersekvens där det finns en eller två siffror.
Här är det värt att nämna en sådan funktion av antiifierarna "*" och "+" som girighet. Summan av kardemumman är att dessa tecken som standard motsvarar den längsta möjliga sekvensen av tecken. Till exempel, för strängen "mamma tvättade ramen" uttrycket:
kommer att välja "mamma tvål ra", vilket är något oväntat, eftersom vi skulle få "ma". Metatecken "?" används för att ändra detta beteende. (frågetecken) skrivet omedelbart efter kvantifieraren. Det begränsar "aptiten" hos kvantifierare genom att få dem att returnera den första matchen, inte den längsta. Låt oss nu ändra föregående exempel:
och få önskad match "ma".
Den sista delen av språket är modifierare. En modifierare är ett specialtecken som definierar "system"-parametrar för att analysera reguljära uttryck. Det finns bara fyra sådana symboler, de kan användas både separat och samtidigt:
| i | Aktiverar skiftlägeskänsligt läge, dvs. versaler och små bokstäver i uttrycket skiljer sig inte åt. |
| m | Indikerar att texten som genomsöks ska behandlas som flera rader. Som standard behandlar motorn för reguljära uttryck text som en enda rad, oavsett vad den faktiskt är. Följaktligen indikerar metatecken "^" och "$" början och slutet av hela texten. Om denna modifierare anges, kommer de att peka på början respektive slutet av varje textrad. |
| s | Standardmetatecken är "." inkluderar inte nyradstecknet i sin definition. De där. för flerradstext kommer uttrycket /.+/ bara att returnera den första raden, inte hela texten som förväntat. Genom att specificera denna modifierare tas denna begränsning bort. |
| U | Gör alla kvantitativa metatecken "icke giriga" som standard. I vissa modifieringar av språket (särskilt i PHP) används tecknet "g" istället för "U", mer passande för betydelsen ("g" är en förkortning för engelskan "greedy", "greedy"). |
Tabellen visar de mest populära och nödvändiga exemplen på reguljära uttryck. Vissa av dem kan tyckas komplicerade och krångliga för dig, men med en detaljerad studie kommer du utan tvekan att lista ut det.
Reguljära uttryck i PHP.
För att arbeta med reguljära uttryck i PHP är speciella funktioner avsedda, vars lista och en kort beskrivning ges i tabellen:
| int preg_match(strängmönster, strängämne[, matrismatchningar]) |
Funktionen kontrollerar om innehållet i ämnet matchar mönstret. Returnerar 1 om matchningar hittas, annars returnerar 0. Om du anger de valfria arrayparametermatchningarna kommer endast ett element att matas in i den - den första matchningen som hittas, när funktionen exekveras. "; print_r($found); ?> |
| int preg_match_all(strängmönster, strängämne, matrismatchningar[, int ordning]) |
| Funktionen är identisk med den föregående, med den enda skillnaden - den söker igenom hela texten och returnerar ALLA hittade matchningar i matchningsarrayen. |
| mixed preg_replace (blandat mönster, blandat ersättning, blandat ämne [, int limit]) |
| Precis som de två föregående funktionerna söker preg_replace efter en text som matchar mönstret. Funktionen ersätter alla hittade fragment med texten som anges i parametrarna.Före rengöring:\n$text\n\n"; $text = preg_replace("/(\n \s(2,))/"," ",$text); echo " Efter rengöring:\n$text"; // kommer att visa text utan specialtecken // och extra mellanslag?> |
| mixed preg_replace_callback (blandat mönster, blandat återuppringning, blandat ämne [, int limit]) |
| Funktionen är en utökad version av den tidigare. Den största skillnaden är att i parametrarna skickas denna funktion namnet på funktionen som kommer att analysera texten och bilda ersättningstexten. |
| array preg_split(strängmönster, strängämne[, int limit[, int flaggor]]) |
| Denna funktion liknar funktionerna explode() och split(). Dess egenhet är att separatorn inte är en fast sträng, utan ett reguljärt uttryck. Funktionen delar upp indata i element och placerar dem i utgångsmatrisen. |
| preg_grep(strängmönster, matrisinmatning) |
| Funktionen är avsedd för vanlig sökning i arrayer. Sökningen ges ett mönster och en array av indata, och en array returneras som endast består av element som matchar mönstret. |
Listan över övervägda funktioner är långt ifrån komplett, men den är ganska tillräcklig för en framgångsrik start med reguljära uttryck. Om du är intresserad av detta ämne, se till att läsa ytterligare litteratur (till exempel Friedls bok "Regular Expressions"). Dessutom rekommenderar jag för inlärningsändamål att du installerar ett av specialprogrammen för att testa reguljära uttryck (till exempel "PCRE" eller "RegEx Builder").
Reguljära uttryck är speciella mönster för att söka efter en delsträng i text. Med deras hjälp kan du lösa sådana problem på en rad: "kontrollera om strängen innehåller siffror", "hitta alla e-postadresser i texten", "ersätt flera på varandra följande frågetecken med ett".
Låt oss börja med en populär programmeringsvisdom:
Vissa människor, när de står inför ett problem, tänker: "Ja, jag är smart, jag löser det med vanliga uttryck." Nu har de två problem.
Exempel på mallar
Låt oss börja med ett par enkla exempel. Det första uttrycket i bilden nedan letar efter en sekvens av 3 bokstäver, där den första bokstaven är "k", den andra är en rysk bokstav och den tredje är "t" på ett skiftlägesokänsligt sätt (t.ex. "katt" eller " CAT" passar detta mönster). Det andra uttrycket söker efter en tid i texten i formatet 12:34.
Alla uttryck börjar med ett avgränsningstecken (avgränsare på engelska). Symbolen / används vanligtvis som den, men andra tecken som inte har ett speciellt syfte i reguljära uttryck, som ~ , # eller @ , kan användas. Alternativa avgränsare används om tecknet / kan förekomma i uttrycket. Sedan kommer mallen för strängen vi letar efter, följt av den andra avgränsaren, och en eller flera flaggbokstäver kan gå i slutet. De ställer in ytterligare alternativ när du söker efter text. Här är exempel på flaggor:
- i - säger att sökningen ska vara skiftlägesokänslig (skiftlägeskänslig som standard)
- u - säger att uttrycket och texten som söks efter använder utf-8-kodning, inte bara latinska bokstäver. Utan det kanske sökningen efter ryska (och alla andra icke-latinska) tecken inte fungerar korrekt, så du bör alltid använda den.
Själva mallen består av vanliga tecken och specialdesigner. Tja, till exempel, bokstaven "k" i reguljära uttryck betyder sig själv, men symbolerna betyder "alla siffror från 0 till 5 kan finnas på denna plats." Här är en komplett lista över specialtecken (i php-manualen kallas de för metatecken), och alla andra tecken i det reguljära uttrycket är vanliga:
Nedan kommer vi att analysera innebörden av var och en av dessa tecken (och även förklara varför bokstaven "ё" placeras separat i det första uttrycket), men för tillfället kommer vi att försöka tillämpa våra reguljära uttryck på texten och se vad som händer. PHP har en speciell funktion preg_match($regexp, $text, $match) , som tar ett reguljärt uttryck, text och en tom array som indata. Den kontrollerar om texten innehåller en delsträng som matchar det givna mönstret och returnerar 0 om inte, eller 1 om den gör det. Och i den passerade arrayen placeras den första hittade matchningen med det reguljära uttrycket i elementet med index 0. Låt oss skriva ett enkelt program som tillämpar reguljära uttryck på olika strängar:
Nu när vi har sett exemplet, låt oss utforska reguljära uttryck mer i detalj.
Parentes inom reguljära uttryck
Låt oss sammanfatta vad de olika typerna av parentes betyder:
- Lockiga klammerparenteser a(1,5) anger antalet repetitioner av föregående tecken - i det här exemplet letar uttrycket efter 1 till 5 på varandra följande bokstäver "a"
- Hakparenteser betyder "vilket som helst av dessa tecken", i det här fallet bokstäverna a, b, c, x, y, z eller en siffra från 0 till 5. Inom hakparenteser, andra specialtecken som | eller * - de anger ett vanligt tecken. Om det finns en symbol ^ inom hakparenteser i början, är betydelsen omvänd: "vilket som helst tecken, utom de som anges" - till exempel betyder [^a-c] "vilket som helst tecken, utom a, b eller c" .
- Parentes grupperar tecken och uttryck. Till exempel, i uttrycket abc+, hänvisar plustecknet endast till bokstaven c, och detta uttryck letar efter ord som abc, abcc, abccc. Och om du sätter parentes a (bc) + så hänvisar pluskvantifieraren redan till sekvensen bc och uttrycket letar efter orden abc, abcbc, abcbcbc
Notera: teckenintervall kan anges inom hakparenteser, men kom ihåg att den ryska bokstaven ё är skild från alfabetet och för att skriva "alla ryska bokstäver" måste du skriva [а-яё] .
bexleshi
Om du har tittat på andra handledningar om reguljära uttryck, har du förmodligen märkt att backslash skrivs olika överallt. Någonstans skriver de ett omvänt snedstreck: \d , men här i exemplen upprepas det 2 gånger: \\d . Varför?
Det reguljära uttrycksspråket kräver att du skriver omvänt snedstreck en gång. Men i enkla och dubbla citerade strängar i PHP har backslash också en speciell betydelse: en manual om strängar. Tja, till exempel, om du skriver $x = "\$"; då tar PHP det som en speciell kombination och infogar bara $-tecknet i strängen (och regex-motorn kommer inte att känna till omvänt snedstreck innan det). För att infoga sekvensen \$ i en sträng måste vi dubbla snedstrecket och skriva koden som $x = "\\$"; .
Av denna anledning, i vissa fall (där en sekvens av tecken har speciell betydelse i PHP) måste vi dubbla omvänt snedstreck:
- För att skriva i reguljärt uttryck \$, skriver vi i koden "\\$"
- För att skriva \\ i reguljärt uttryck dubblar vi varje snedstreck och skriver "\\\\"
- För att skriva ett omvänt snedstreck och ett tal (\1) i ett reguljärt uttryck måste snedstrecket dubbleras: "\\1"
I andra fall kommer ett eller två snedstreck att ge samma resultat: "\\d" och "\d" kommer att infoga ett par \d tecken i strängen - i det första fallet är 2 omvänt snedstreck sekvensen för att infoga ett omvänt snedstreck , i det andra fallet finns det ingen speciell sekvens och tecken kommer att infogas som de är. Du kan kontrollera vilka tecken som kommer att infogas i strängen och vad motorn för reguljära uttryck kommer att se, med hjälp av echo: echo "\$"; . Ja, det är svårt, men vad kan man göra?
Specialkonstruktioner i reguljära uttryck
- \d letar efter vilken enstaka siffra som helst, \D - vilket enstaka tecken som helst förutom en siffra
- \w matchar valfri enstaka bokstav (valfritt alfabet), siffra eller understreck _ . \W matchar alla tecken utom bokstav, siffra, understreck.
Det finns också ett bekvämt villkor för att peka på en ordgräns: \b . Denna konstruktion innebär att det på ena sidan av den ska finnas ett tecken som är en bokstav/siffra/understreck (\w), och på andra sidan - inte. Jo, till exempel vill vi hitta ordet "katt" i texten. Om vi skriver det reguljära uttrycket /cat/ui , kommer det att hitta sekvensen av dessa bokstäver var som helst - till exempel inuti ordet "beast". Det är helt klart inte vad vi ville ha. Om vi lägger till ett ordgränsvillkor till det reguljära uttrycket: /\bcat\b/ui , så kommer nu bara det separata ordet "cat" att sökas.
Manuell
- Syntax för reguljära uttryck i PHP, detaljerad beskrivning
PHP regexp är en kraftfull mönstermatchningsalgoritm som kan göras i ett enda uttalande. PHP reguljära uttryck använder aritmetiska operatorer (som +, -, ^ ) för att skapa komplexa uttryck.
Vad används reguljära uttryck för:
- Reguljära uttryck gör det enkelt att identifiera strängdata genom att anropa en enda funktion. Detta sparar tid när du skriver kod;
- När du kontrollerar användarinmatade data som e-postadress, webbplatsdomän, telefonnummer, IP-adress;
- Markera nyckelord i sökresultaten;
- Reguljära uttryck kan användas för att identifiera taggar och ersätta dem.
Reguljära uttryck i PHP
PHP innehåller inbyggda funktioner som gör att du kan arbeta med reguljära uttryck. Låt oss nu ta en titt på vanliga PHP-funktioner för reguljära uttryck.
- preg_match används för att utföra mönstermatchning på en sträng. Den returnerar sant om en matchning hittas och falsk om ingen matchning hittas;
- preg_split - används för att dela en sträng enligt ett mönster, resultatet returneras som en numerisk matris;
- preg_replace - används för att söka efter mönster och ersätta med den angivna strängen.
Följande är syntaxen för reguljära uttrycksfunktioner som preg_match , preg_split eller PHP regexp replace :
"funktionsnamn" är antingen preg_match , eller preg_split , eller preg_replace .
"/.../" - snedstreck markerar början och slutet av det reguljära uttrycket.
"'/pattern/"" är mönstret vi behöver matcha.
"objekt" är strängen mot vilken mönstret ska matchas.
Låt oss nu titta på praktiska exempel på att använda funktionerna som nämns ovan.
Preg_match
Det första exemplet använder preg_match-funktionen för att utföra en enkel mönstermatchning på ordet guru i den givna URL:en.
Koden nedan visar en implementering av detta exempel:
Tänk på den del av koden som är ansvarig för utdata "preg_match('/guru/', $my_url)".
"preg_match(...)" är PHP match regexp-funktionen.
"'/Guru/"" är ett reguljärt uttrycksmönster.
"$My_url" är en variabel som innehåller texten att matcha mot.
preg_split
Låt oss titta på ett annat exempel som använder preg_split-funktionen.
Vi tar en fras och delar upp den i en array; mönstret är utformat för att söka efter ett enda utrymme:
Preg_replace
Tänk på funktionen preg_replace , som utför en mönstermatchning och ersätter det hittade resultatet med en annan sträng.
Koden nedan letar efter ordet guru i en sträng. Den ersätter den med css-kod som anger bakgrundsfärgen:
Guru", $text); echo $text; ?>
Metakaraktärer
Exemplen ovan använde enkla mallar. Metatecken möjliggör mer komplex matchning av PHP-regexp-mönster, som att validera en e-postadress. Tänk på vanliga metatecken.
| metakaraktär | Beskrivning | Exempel |
| . | Matchar alla enstaka tecken utom nyradstecknet. | /./ - allt som innehåller ett enda tecken. |
| ^ | Indikerar början på en rad, inte med tecknet /. | /^PH/ är vilken rad som helst som börjar med PH. |
| $ | Betecknar ett mönster i slutet av en rad. | /com$/ - guru99.com, yahoo.com, etc. |
| * | Indikerar valfritt antal tecken, noll eller fler. | /com*/ - dator, kommunikation osv. |
| + | Att föregå metateckenet minst en gång krävs. | /yah+oo/ - yahoo. |
| Sköld symbol. | /yahoo+.com/ - behandlar en prick som ett bokstavligt värde. | |
| […] | Karaktärsklass. | // - abc. |
| a-z | Betecknar små bokstäver. | /a-z/ - cool, glad osv. |
| A-Z | Indikerar versaler. | /A-Z/ - VAD, HUR, VARFÖR osv. |
| 0-9 | Indikerar alla tal från 0 till 9. | /0-4/ — 0,1,2,3,4. |
Låt oss nu titta på ett komplicerat PHP-regexp-exempel som kontrollerar om en e-postadress är giltig:
Resultat: e-postadress [e-postskyddad]är giltig.
Förklaring av mallen " [e-postskyddad]+.(2,5)$/] "
"'/…/"" startar och avslutar det reguljära uttrycket.
"^" matchar alla gemener eller versaler, siffror 0 till 9 och punkter, understreck eller bindestreck.
« [e-postskyddad]' matchar tecknet @ följt av gemener eller versaler, siffrorna 0 till 9 eller bindestreck.
"+.(2,5)$/" indikerar en punkt med ett omvänt snedstreck, följt av eventuella små eller stora bokstäver, antalet tecken i slutet av strängen måste vara mellan 2 och 5.