PHP
Regular Expressions (regexp / PCRE)

Syntax

• preg_replace($pattern, $replacement, $subject, $limit = -1, $count = 0);
• preg_replace_callback($pattern, $callback, $subject, $limit = -1, $count = 0);
• preg_match($pattern, $subject, &$matches, $flags = 0, $offset = 0);
• preg_match_all($pattern, $subject, &$matches, $flags = PREG_PATTERN_ORDER, $offset = 0);
• preg_split($pattern, $subject, $limit = -1, $flags = 0)

parametrar

Anmärkningar

<?php

$replaced = preg_replace('%hello ([a-z]+) world%', 'goodbye $1 world', 'hello awesome world');

echo $replaced; // 'goodbye awesome world'

Strängmatchning med vanliga uttryck

preg_match kontrollerar om en sträng matchar det vanliga uttrycket.

$string = 'This is a string which contains numbers: 12345';

$isMatched = preg_match('%^[a-zA-Z]+: [0-9]+$%', $string);
var_dump($isMatched); // bool(true)

Om du skickar in en tredje parameter fylls den med matchande data för det reguljära uttrycket:

preg_match('%^([a-zA-Z]+): ([0-9]+)$%', 'This is a string which contains numbers: 12345', $matches);
// $matches now contains results of the regular expression matches in an array.
echo json_encode($matches); // ["numbers: 12345", "numbers", "12345"]

$matches innehåller en matris med hela matchen och sedan sub-streringar i det reguljära uttrycket avgränsat av parenteser, i ordningen för öppen parentesens offset. Det betyder, om du har /z(a(b))/ som den vanliga uttryck, index 0 innehåller hela trängen zab , index 1 innehåller delsträngen som begränsas av den yttre parenteser ab och index 2 innehåller den inre parenteser b .

Dela strängen i matris med ett regelbundet uttryck

$string = "0| PHP 1| CSS 2| HTML 3| AJAX 4| JSON";

//[0-9]: Any single character in the range 0 to 9
// +   : One or more of 0 to 9
$array = preg_split("/[0-9]+\|/", $string, -1, PREG_SPLIT_NO_EMPTY);
//Or
// []  : Character class
// \d  : Any digit
//  +  : One or more of Any digit
$array = preg_split("/[\d]+\|/", $string, -1, PREG_SPLIT_NO_EMPTY);

Produktion:

Array
(
    [0] =>  PHP
    [1] =>  CSS 
    [2] =>  HTML 
    [3] =>  AJAX 
    [4] =>  JSON
)

För att dela en sträng i en array passerar du bara strängen och en regexp för preg_split(); för att matcha och söka, lägg till en tredje parameter ( limit ) gör att du kan ställa in antalet "matchningar" att utföra, den återstående strängen läggs till i slutet av matrisen.

Den fjärde parametern är ( flags ) här använder vi PREG_SPLIT_NO_EMPTY som förhindrar att vårt array innehåller några tomma nycklar / värden.

Sträng ersätter med regelbundet uttryck

$string = "a;b;c\nd;e;f";
// $1, $2 and $3 represent the first, second and third capturing groups
echo preg_replace("(^([^;]+);([^;]+);([^;]+)$)m", "$3;$2;$1", $string);

utgångar

c;b;a
f;e;d

Söker efter allt mellan semikolon och omvänd ordning.

Global RegExp-match

En global RegExp-matchning kan utföras med preg_match_all . preg_match_all returnerar alla matchande resultat i ämnessträngen (i motsats till preg_match , som bara returnerar den första).

Funktionen preg_match_all returnerar antalet matchningar. Tredje parameter $matches kommer att innehålla matchningar i format som styrs av flaggor som kan anges i fjärde parameter.

Om en matris ges kommer $matches att innehålla array i liknande format som du får med preg_match , förutom att preg_match stoppar vid första matchningen, där preg_match_all itererar över strängen tills strängen helt konsumeras och returnerar resultatet av varje iteration i en multidimensionell matris , vilket format som kan styras av flaggan i fjärde argumentet.

Det fjärde argumentet, $flags , kontrollerar strukturen för $matches . Standardläget är PREG_PATTERN_ORDER och möjliga flaggor är PREG_SET_ORDER och PREG_PATTERN_ORDER .

Följande kod visar användning av preg_match_all :

$subject = "a1b c2d3e f4g";
$pattern = '/[a-z]([0-9])[a-z]/';

var_dump(preg_match_all($pattern, $subject, $matches, PREG_SET_ORDER)); // int(3)
var_dump($matches);
preg_match_all($pattern, $subject, $matches); // the flag is PREG_PATTERN_ORDER by default
var_dump($matches);
// And for reference, same regexp run through preg_match()
preg_match($pattern, $subject, $matches);
var_dump($matches);

Den första var_dumpen från PREG_SET_ORDER ger denna utgång:

array(3) {
  [0]=>
  array(2) {
    [0]=>
    string(3) "a1b"
    [1]=>
    string(1) "1"
  }
  [1]=>
  array(2) {
    [0]=>
    string(3) "c2d"
    [1]=>
    string(1) "2"
  }
  [2]=>
  array(2) {
    [0]=>
    string(3) "f4g"
    [1]=>
    string(1) "4"
  }
}

$matches har tre kapslade matriser. Varje matris representerar en matchning, som har samma format som returresultatet för preg_match .

Den andra var_dumpen ( PREG_PATTERN_ORDER ) ger denna utgång:

array(2) {
  [0]=>
  array(3) {
    [0]=>
    string(3) "a1b"
    [1]=>
    string(3) "c2d"
    [2]=>
    string(3) "f4g"
  }
  [1]=>
  array(3) {
    [0]=>
    string(1) "1"
    [1]=>
    string(1) "2"
    [2]=>
    string(1) "4"
  }
}

När samma regexp körs via preg_match följande array:

array(2) {
  [0] =>
  string(3) "a1b"
  [1] =>
  string(1) "1"
}

Strängen ersättas med återuppringning

preg_replace_callback fungerar genom att skicka varje matchad fångargrupp till den definierade återuppringningen och ersätter den med återuppringningsvärdet för återuppringningen. Detta gör att vi kan ersätta strängar baserade på alla typer av logik.

$subject = "He said 123abc, I said 456efg, then she said 789hij";
$regex = "/\b(\d+)\w+/";

// This function replaces the matched entries conditionally 
// depending upon the first character of the capturing group
function regex_replace($matches){
    switch($matches[1][0]){
        case '7':
            $replacement = "<b>{$matches[0]}</b>";
            break;
        default:
            $replacement = "<i>{$matches[0]}</i>";
    }
    return $replacement;
}

$replaced_str = preg_replace_callback($regex, "regex_replace", $subject);

print_r($replaced_str);
# He said <i>123abc</i>, I said <i>456efg</i>, then she said <b>789hij</b>