摘要：能匹配中的，但不能匹配中的數(shù)量界定符符號定義是一個非負(fù)整數(shù)。則等價于和均為非負(fù)整數(shù)，其中。該方法接受一個正則表達(dá)式作為它的第一個參數(shù)。是一個非強(qiáng)制異常類，它表示一個正則表達(dá)式模式中的語法錯誤。

正則表達(dá)式是對字符串操作的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個“規(guī)則字符串”，這個“規(guī)則字符串”用來表達(dá)對字符串的一種過濾邏輯。
正則表達(dá)式是對字符串（包括普通字符（例如，a 到 z 之間的字母）和特殊字符（稱為“元字符”））操作的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個“規(guī)則字符串”，這個“規(guī)則字符串”用來表達(dá)對字符串的一種過濾邏輯。正則表達(dá)式是一種文本模式，模式描述在搜索文本時要匹配的一個或多個字符串。

通用的符號：

特殊的符號：

重點(diǎn)：關(guān)于 .

單行模式下(gs)：能匹配
多行模式下(gm)：不能匹配

重點(diǎn)：關(guān)于 ?

貪婪模式下：數(shù)量限定符都是在滿?條件下盡可能的匹配更多的字符
非貪婪模式下：如果希望在滿?條件下盡可能少的匹配字符, 在數(shù)量限定符后?加上“?”

以下是常用的一些在線正則表達(dá)式測試工具，其中個人感覺第一個最好！

http://regex101.com/

http://regexr.com/

http://tool.lu/regex/

http://tool.oschina.net/regex/

http://tool.chinaz.com/regex/

RegexBuddy

RegexMagic

參考文獻(xiàn)：https://www.liaoxuefeng.com/w...

Python提供re模塊，包含所有正則表達(dá)式的功能。由于Python的字符串本身也用轉(zhuǎn)義，所以要特別注意：

s = "ABC-001" # Python的字符串
# 對應(yīng)的正則表達(dá)式字符串變成：
# "ABC-001"

因此我們強(qiáng)烈建議使用Python的r前綴，就不用考慮轉(zhuǎn)義的問題了：

s = r"ABC-001" # Python的字符串
# 對應(yīng)的正則表達(dá)式字符串不變：
# "ABC-001"

先看看如何判斷正則表達(dá)式是否匹配：

>>> import re
>>> re.match(r"^d{3}-d{3,8}$", "010-12345")
<_sre.SRE_Match object; span=(0, 9), match="010-12345">
>>> re.match(r"^d{3}-d{3,8}$", "010 12345")
>>>

match()方法判斷是否匹配，如果匹配成功，返回一個Match對象，否則返回None。常見的判斷方法就是：

test = "用戶輸入的字符串"
if re.match(r"正則表達(dá)式", test):
    print("ok")
else:
    print("failed")

用正則表達(dá)式切分字符串比用固定的字符更靈活，請看正常的切分代碼：

>>> "a b   c".split(" ")
["a", "b", "", "", "c"]

嗯，無法識別連續(xù)的空格，用正則表達(dá)式試試：

>>> re.split(r"s+", "a b   c")
["a", "b", "c"]

無論多少個空格都可以正常分割。加入,試試：

>>> re.split(r"[s,]+", "a,b, c  d")
["a", "b", "c", "d"]

再加入;試試：

>>> re.split(r"[s,;]+", "a,b;; c  d")
["a", "b", "c", "d"]

如果用戶輸入了一組標(biāo)簽，下次記得用正則表達(dá)式來把不規(guī)范的輸入轉(zhuǎn)化成正確的數(shù)組。

除了簡單地判斷是否匹配之外，正則表達(dá)式還有提取子串的強(qiáng)大功能。用()表示的就是要提取的分組（Group）。比如：

^(d{3})-(d{3,8})$分別定義了兩個組，可以直接從匹配的字符串中提取出區(qū)號和本地號碼：

>>> m = re.match(r"^(d{3})-(d{3,8})$", "010-12345")
>>> m
<_sre.SRE_Match object; span=(0, 9), match="010-12345">
>>> m.group(0)
"010-12345"
>>> m.group(1)
"010"
>>> m.group(2)
"12345"

如果正則表達(dá)式中定義了組，就可以在Match對象上用group()方法提取出子串來。

注意到group(0)永遠(yuǎn)是原始字符串，group(1)、group(2)……表示第1、2、……個子串。

提取子串非常有用。來看一個更兇殘的例子：

>>> t = "19:05:30"
>>> m = re.match(r"^(0[0-9]|1[0-9]|2[0-3]|[0-9]):(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9]):(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$", t)
>>> m.groups()
("19", "05", "30")

這個正則表達(dá)式可以直接識別合法的時間。但是有些時候，用正則表達(dá)式也無法做到完全驗證，比如識別日期：

"^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$"

對于"2-30"，"4-31"這樣的非法日期，用正則還是識別不了，或者說寫出來非常困難，這時就需要程序配合識別了。

最后需要特別指出的是，正則匹配默認(rèn)是貪婪匹配，也就是匹配盡可能多的字符。舉例如下，匹配出數(shù)字后面的0：

>>> re.match(r"^(d+)(0*)$", "102300").groups()
("102300", "")

由于d+采用貪婪匹配，直接把后面的0全部匹配了，結(jié)果0*只能匹配空字符串了。

必須讓d+采用非貪婪匹配（也就是盡可能少匹配），才能把后面的0匹配出來，加個?就可以讓d+采用非貪婪匹配：

>>> re.match(r"^(d+?)(0*)$", "102300").groups()
("1023", "00")

當(dāng)我們在Python中使用正則表達(dá)式時，re模塊內(nèi)部會干兩件事情：

編譯正則表達(dá)式，如果正則表達(dá)式的字符串本身不合法，會報錯；

用編譯后的正則表達(dá)式去匹配字符串。

如果一個正則表達(dá)式要重復(fù)使用幾千次，出于效率的考慮，我們可以預(yù)編譯該正則表達(dá)式，接下來重復(fù)使用時就不需要編譯這個步驟了，直接匹配：

>>> import re
# 編譯:
>>> re_telephone = re.compile(r"^(d{3})-(d{3,8})$")
# 使用：
>>> re_telephone.match("010-12345").groups()
("010", "12345")
>>> re_telephone.match("010-8086").groups()
("010", "8086")

編譯后生成Regular Expression對象，由于該對象自己包含了正則表達(dá)式，所以調(diào)用對應(yīng)的方法時不用給出正則字符串。

參考文獻(xiàn)：http://www.runoob.com/java/ja...

Java提供了java.util.regex 包來操作正則表達(dá)式，主要包含以下三個類：

Pattern 類：pattern 對象是一個正則表達(dá)式的編譯表示。Pattern 類沒有公共構(gòu)造方法。要創(chuàng)建一個 Pattern 對象，你必須首先調(diào)用其公共靜態(tài)編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達(dá)式作為它的第一個參數(shù)。

Matcher 類：Matcher 對象是對輸入字符串進(jìn)行解釋和匹配操作的引擎。與Pattern 類一樣，Matcher 也沒有公共構(gòu)造方法。你需要調(diào)用 Pattern 對象的 matcher 方法來獲得一個 Matcher 對象。

PatternSyntaxException：PatternSyntaxException 是一個非強(qiáng)制異常類，它表示一個正則表達(dá)式模式中的語法錯誤。

以下實例中使用了正則表達(dá)式 .*runoob.* 用于查找字符串中是否包了 runoob 子串：

import java.util.regex.*;
 
class RegexExample1{
   public static void main(String args[]){
      String content = "I am noob " +
        "from runoob.com.";
 
      String pattern = ".*runoob.*";
 
      boolean isMatch = Pattern.matches(pattern, content);
      System.out.println("字符串中是否包含了 "runoob" 子字符串? " + isMatch);
   }
}

輸出：

字符串中是否包含了 "runoob" 子字符串? true

捕獲組是把多個字符當(dāng)一個多帶帶單元進(jìn)行處理的方法，它通過對括號內(nèi)的字符分組來創(chuàng)建。
例如，正則表達(dá)式 (dog) 創(chuàng)建了單一分組，組里包含"d"，"o"，和"g"。
捕獲組是通過從左至右計算其開括號來編號。例如，在表達(dá)式（（A）（B（C））），有四個這樣的組：

((A)(B(C)))

(A)

(B(C))

(C)

可以通過調(diào)用 matcher 對象的 groupCount 方法來查看表達(dá)式有多少個分組。groupCount 方法返回一個 int 值，表示matcher對象當(dāng)前有多個捕獲組。
還有一個特殊的組（group(0)），它總是代表整個表達(dá)式。該組不包括在 groupCount 的返回值中。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    public static void main( String args[] ){
 
      // 按指定模式在字符串查找
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(D*)(d+)(.*)";
 
      // 創(chuàng)建 Pattern 對象
      Pattern r = Pattern.compile(pattern);
 
      // 現(xiàn)在創(chuàng)建 matcher 對象
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
         System.out.println("Found value: " + m.group(3) ); 
      } else {
         System.out.println("NO MATCH");
      }
   }
}

輸出：

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?

參考文獻(xiàn)：http://www.runoob.com/csharp/...

使用的命名空間 using System.Text.RegularExpressions;

C#中主要使用Regex類來操作正則表達(dá)式,其常用的方法如下：

| 在指定的輸入字符串中，把所有匹配正則表達(dá)式模式的所有匹配的字符串替換為指定的替換字符串 |
| public string[] Split( string input )? | 把輸入字符串分割為子字符串?dāng)?shù)組，根據(jù)在 Regex 構(gòu)造函數(shù)中指定的正則表達(dá)式模式定義的位置進(jìn)行分割 |

實例一：下面的實例匹配了以 "S" 開頭的單詞：

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "A Thousand Splendid Suns";

         Console.WriteLine("Matching words that start with "S": ");
         showMatch(str, @"SS*");
         Console.ReadKey();
      }
   }
}

輸出：

Matching words that start with "S":
The Expression: SS*
Splendid
Suns

實例 2: 下面的實例匹配了以 "m" 開頭以 "e" 結(jié)尾的單詞：

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with "m" and ends with "e":");
         showMatch(str, @"mS*e");
         Console.ReadKey();
      }
   }
}

輸出：

Matching words start with "m" and ends with "e":
The Expression: mS*e
make
maze
manage
measure

實例 3:下面的實例替換掉多余的空格：

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input = "Hello   World   ";
         string pattern = "s+";
         string replacement = " ";
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine("Original String: {0}", input);
         Console.WriteLine("Replacement String: {0}", result);    
         Console.ReadKey();
      }
   }
}

輸出：

Original String: Hello   World   
Replacement String: Hello World 

參考文獻(xiàn)：https://blog.csdn.net/makenot...

C++里面使用正則表達(dá)式一般有三種：C regex，C ++regex，boost regex

實例一：電子郵件

// Regex.cpp : 定義控制臺應(yīng)用程序的入口點(diǎn)。
//
#include 
#include 
#include 
#include 
using namespace std;

//電子郵件匹配
bool is_email_valid(const std::string& email)
{
   const regex pattern("(w+)(.|_)?(w*)@(w+)(.(w+))+");
   /****
    const std::regex pattern("(w+)(.|_)?(w*)@(w+)(.(w+))+"); 
   std:: match_results result;
   bool valid = std::regex_match(email, result,pattern);
   //此處result參數(shù)可有可無，result是一個字符串?dāng)?shù)組，用來存儲正則表達(dá)式里面括號的內(nèi)容。
   if(valid&&(result.length()>0))
  {
      for(int i =0;i
實例二：IP
bool is_IPAddress_valid(const std::string& ipaddress)
{
    const std::regex pattern("(d{1,3}).(d{1,3}).(d{1,3}).(d{1,3})");
    //三位數(shù)的都可以，沒有設(shè)置1-255 的條件
   std:: match_results result;
  bool valid = std::regex_match(ipaddress, result, pattern);
  if(valid&&(result.length()>0))
  {
      for(int i =0;i
測試：
int main(int argc,char** argv)
{

    cout<<"測試4個電子郵件選項"<
6. Javasript操作正則表達(dá)式
參考文獻(xiàn)：http://www.runoob.com/js/js-r...
參考文獻(xiàn)：https://www.cnblogs.com/zhuzh...

6.1 JavaScript對正則表達(dá)式的支持程度
下面的這些都是JavaScript所不支持的：
匹配字符串開始和結(jié)尾的A和Z錨。（但我們?nèi)钥梢允褂胇和$來匹配字符串的開始和結(jié)尾）
向后查找（lookbehind）(注：但是JavaScript完全支持向前查找（lookahead）)
并集和交集類
原子組（atomic grouping）
Unicode支持（單個字符除外，如uFFFF）
命名的捕獲組
s(single，單行)和x(free-spacing,無間隔)匹配模式
條件匹配
正則表達(dá)式注釋
6.2 支持正則表達(dá)式的RegExp類型
JavaScript是通過RegExp類型來支持正則表達(dá)式的。而創(chuàng)建RegExp類型有兩種方法。一種是字面量方法（類似于Perl的語法），另一種是使用JavaScript的RegExp構(gòu)造函數(shù)，下面將逐一介紹。
6.2.1 字面量方法
var expression = /pattern/flags;
其中expression即為正則表達(dá)式的名稱，模式(pattern)可以是任何復(fù)雜或簡單的正則表達(dá)式（但必須是在JavaScript支持范圍內(nèi)的），標(biāo)志(flags)即用來表明正則表達(dá)式行為。
下面介紹JavaScript中支持的三個標(biāo)志（flags）：

g: 表示全局（global）模式，表示pattern會應(yīng)用于所有字符串，而不是找到一個匹配項后立即停止。
i ：表示不區(qū)分大小寫(ignore)模式。即忽略pattern和字符串的大小寫。
m:表示多行（multiple）模式。 即到一行文本末尾時還會繼續(xù)查找下一行中是否存在匹配的項。
說明：在字面量方法中的flags可以是g、i、m中的任意一個或幾個且這里的標(biāo)志完全適用于之后要講的RegExp構(gòu)造函數(shù)方法。


舉例：
var pattern=/at/gi;
此字面量形式的正則表達(dá)式表示在不區(qū)分大小寫的情況下在全局范圍內(nèi)匹配at。
6.2.2 RegExp構(gòu)造函數(shù)法
var pattern = new RegExp("pattern","flags");
即這種方法使用了RegExp構(gòu)造函數(shù)，并且傳遞了兩個參數(shù)（同字面量方法），但值得注意的是：pattern（模式）和flags(標(biāo)志)都需要使用引號括起來。
6.2.3 對模式中的元字符轉(zhuǎn)義的方法
當(dāng)我們希望使用元字符本身的含義時，我們就需要對元字符進(jìn)行轉(zhuǎn)義。比如[ab]c表示ac或bc；若通過轉(zhuǎn)義，即[ab]c就表示成了[ab]c。但是對于上述兩種不同的創(chuàng)建方法有不同的轉(zhuǎn)義方式。
首先，請記住在JavaScript中的元字符有 ( [ {  ^ $ | ) ? * + . ] ) }。
使用字面量方法創(chuàng)建正則表達(dá)式轉(zhuǎn)義：在需要轉(zhuǎn)義的正則表達(dá)式前加即可。如var pattern = /[ab]c/g;表示在全局范圍內(nèi)匹配abc
使用RegExp構(gòu)造函數(shù)創(chuàng)建正則表達(dá)式轉(zhuǎn)義：在需要轉(zhuǎn)義的正則表達(dá)式前加。如var pattern = RegExp("[ab]c","g");同樣表示在全局范圍內(nèi)匹配abc
舉例：
如果希望知道字符串XxxxoOoooommmm中o的數(shù)量（不區(qū)分大小寫），這時就可以使用match方法傳入字符串，如：
var string = "XxxxoOoooommmm";　console.log(string.match(/o/ig).length);  
輸出為6，這種方法還是很容易的。
6.3 RegExp的實例屬性
無論是何種方法創(chuàng)建的正則表達(dá)式，他們都具有下面幾種屬性來描述有關(guān)模式的信息：

global---表示flags(標(biāo)志)中是否設(shè)置了g標(biāo)志。
ignoreCase---表示flags(標(biāo)志)中是否設(shè)置了i標(biāo)志。
lastIndex---表示開始搜索下一個匹配項的字符位置的整數(shù)，從0算起。
multiple---表示flags(標(biāo)志)中是否設(shè)置了m標(biāo)志。
source---按照字面量形式返回正則表達(dá)式的字符串表示。

舉例如下所示：
// var pattern = RegExp("[ba]at","gi");//使用RegExp構(gòu)造函數(shù)創(chuàng)建得到的效果和下面使用的字面量方法創(chuàng)建得到的效果相同
var pattern = /[ba]at/gi;
console.log(pattern.global); //true
console.log(pattern.ignoreCase); //true
console.log(pattern.multiline);  //ture
console.log(pattern.lastIndex);  //0 
console.log(pattern.source);  //  [ba]at
當(dāng)然，上面代碼中使用了大量的console.log（）顯得很復(fù)雜，也可以將這5個屬性作為5個參數(shù)直接傳入到console.log()中。如下所示：
var pattern = /[ba]at/gi;
console.log(pattern.global,pattern.ignoreCase,pattern.multiline,pattern.lastIndex,pattern.source); //true true false 0 "[ba]at"
我們還可以將這5個屬性保存在一個數(shù)組中，再通過console.log()直接輸出數(shù)組，如下所示：
var pattern = /[ba]at/gi;
var properties=[pattern.global,pattern.ignoreCase,pattern.multiline,pattern.lastIndex,pattern.source];
console.log(properties);
6.4 RegExp的實例方法
RegExp的實例主要有兩個方法exec()和test()，并且還有從Object繼承的toString()和toLocaleString()方法，下面將會逐一介紹。
6.4.1 RegExp實例的exec()方法
這個方法接收一個參數(shù)，即要應(yīng)用模式的字符串，用于捕獲組。
如果匹配，則返回一個數(shù)組；否則返回null。
且其中返回的數(shù)組還有額外的兩個方法：index和input。index表示匹配項在字符串中的位置，input表示應(yīng)用正則表達(dá)式的字符串。
舉例如下所示：
var text="mom and dad and baby";
    var pattern=/mom( and dad( and baby)?)?/gi;
    var matches=pattern.exec(text);
    console.log(matches);
如果匹配不了，則matches為null；如果匹配，將會在控制臺中輸出一個數(shù)組
6.4.2 RegExp實例的test()方法
這個方法同樣也接收一個字符串，如果pattern（模式）和字符串匹配，則返回true，否則返回false。
并且test()方法經(jīng)常被用在if語句中，舉例如下：



    
    


    
    提交
    


6.4.3 RegExp實例的toString()和toLocalString()方法
這兩個方法都會返回正則表達(dá)式的字面量，與創(chuàng)建正則表達(dá)式的方式無關(guān)。
舉例如下：
var pattern=/1[358]d{9}/gi;
console.log(pattern.toString());
console.log(pattern.toLocaleString());
6.5 RegExp的構(gòu)造函數(shù)屬性
RegExp構(gòu)造函數(shù)也包含了一些屬性。值得注意的是，這些屬性有兩種方式來訪問---長屬性名和短屬性名。介紹如下：

input             $_    最近一次要匹配的字符串 。（注意：前者是長屬性名，后者是短屬性名，下同）
lastMatch       $&   最近一次的匹配向。
lastParen       $+   最近一次匹配的捕獲組。
leftContext     $`   input字符串中l(wèi)astMatch之前的文本
RightContext  $"   input字符串中l(wèi)astMatch之后的文本
multiline        $*   布爾值，表示是否所有表達(dá)式都使用多行模式

注意：Opera不支持上面的1236對應(yīng)的四個屬性，IE不支持multiline屬性。
舉例如下所示：
var text="this has been a short summer";
    var pattern=/(.)hort/g;
    if(pattern.test(text)){
        console.log(RegExp.input);//this has been a short summer
        console.log(RegExp.leftContext);//this has been a 
        console.log(RegExp.rightContext);//summer
        console.log(RegExp.lastParen);//s
        console.log(RegExp.lastMatch);//short
        console.log(RegExp.multiline);//undefined
    }


abc ?

a-z ?