PHP
नियमित भाव (regexp / PCRE)

वाक्य - विन्यास

• 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)

पैरामीटर

टिप्पणियों

<?php

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

echo $replaced; // 'goodbye awesome world'

नियमित अभिव्यक्ति के साथ स्ट्रिंग मिलान

preg_match जाँचता है कि क्या एक स्ट्रिंग नियमित अभिव्यक्ति से मेल खाता है।

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

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

यदि आप किसी तीसरे पैरामीटर में पास होते हैं, तो इसे नियमित अभिव्यक्ति के मिलान डेटा के साथ आबाद किया जाएगा:

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 में पूरे मैच की एक सरणी होती है, फिर ओपन कोष्ठक के ऑफसेट के क्रम में कोष्ठक द्वारा बंधी हुई नियमित अभिव्यक्ति में सबस्ट्रिंग। इसका मतलब है, यदि आपके पास /z(a(b))/ नियमित अभिव्यक्ति के रूप में, अनुक्रमणिका 0 में संपूर्ण सबस्ट्रिंग zab , तो अनुक्रमणिका 1 में बाहरी कोष्ठक ab द्वारा अनुक्रमणित zab समाहित है और अनुक्रमणिका 2 में आंतरिक कोष्ठक b ।

रेगुलर एक्सप्रेशन द्वारा स्ट्रिंग को स्प्लिट करें

$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);

आउटपुट:

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

एक स्ट्रिंग को एक सरणी में विभाजित करने के लिए बस स्ट्रिंग और preg_split(); लिए एक regexp पास करें preg_split(); मैच और खोज करने के लिए, एक तीसरा पैरामीटर ( limit ) जोड़कर आप प्रदर्शन करने के लिए "मैचों" की संख्या निर्धारित करने की अनुमति देते हैं, शेष स्ट्रिंग को सरणी के अंत में जोड़ा जाएगा।

चौथा पैरामीटर है ( flags ) यहां हम PREG_SPLIT_NO_EMPTY उपयोग करते हैं जो हमारे सरणी को किसी भी खाली कुंजी / मान को PREG_SPLIT_NO_EMPTY से रोकता है।

स्ट्रिंग की जगह नियमित अभिव्यक्ति

$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);

आउटपुट

c;b;a
f;e;d

अर्धविराम के बीच हर चीज की खोज करता है और क्रम को उलट देता है।

ग्लोबल रेस्पेक्ट मैच

एक वैश्विक RegExp मैच preg_match_all का उपयोग करके किया जा सकता है। preg_match_all विषय स्ट्रिंग में सभी मिलान परिणाम देता है ( preg_match विपरीत, जो केवल पहला रिटर्न देता है)।

preg_match_all फ़ंक्शन मैचों की संख्या लौटाता है। तीसरे पैरामीटर $matches में झंडे द्वारा नियंत्रित प्रारूप में $matches होंगे जो चौथे पैरामीटर में दिए जा सकते हैं।

यदि कोई सरणी दी जाती है, तो $matches में समान स्वरूप में सरणी होगी, जिसे आप preg_match साथ प्राप्त करेंगे, सिवाय इसके कि पहले मैच में preg_match रुकता है, जहां स्ट्रिंग पूरी तरह से भस्म होने तक स्ट्रिंग पर preg_match_all करता है और एक बहुआयामी सरणी में प्रत्येक पुनरावृत्ति का परिणाम देता है। , जो प्रारूप को चौथे तर्क में ध्वज द्वारा नियंत्रित किया जा सकता है।

चौथा तर्क, $flags , $matches सरणी की संरचना को नियंत्रित करता है। डिफ़ॉल्ट मोड PREG_PATTERN_ORDER और संभावित झंडे PREG_SET_ORDER और PREG_PATTERN_ORDER ।

निम्नलिखित कोड 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);

PREG_SET_ORDER से पहला var_dump यह आउटपुट देता है:

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 में तीन नेस्टेड ऐरे हैं। प्रत्येक सरणी एक मैच है, जो की वापसी परिणाम के रूप में एक ही प्रारूप है का प्रतिनिधित्व करता है preg_match ।

दूसरा var_dump ( PREG_PATTERN_ORDER ) यह आउटपुट देता है:

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"
  }
}

जब उसी regexp को preg_match माध्यम से चलाया जाता है, तो निम्न सरणी वापस आ जाती है:

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

स्ट्रिंग कॉलबैक से प्रतिस्थापित करें

preg_replace_callback परिभाषित कॉलबैक में प्रत्येक मिलान किए गए कैप्चरिंग समूह को भेजकर काम करता है और कॉलबैक के वापसी मूल्य के साथ इसे बदलता है। यह हमें किसी भी तरह के तर्क के आधार पर तार बदलने की अनुमति देता है।

$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>