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

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

通用的符號：

特殊的符號：

重點：關于 .

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

重點：關于 ?

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

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

http://regex101.com/

http://regexr.com/

http://tool.lu/regex/

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

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

RegexBuddy

RegexMagic

參考文獻：https://www.liaoxuefeng.com/w...

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

s = "ABC-001" # Python的字符串
# 對應的正則表達式字符串變成：
# "ABC-001"

因此我們強烈建議使用Python的r前綴，就不用考慮轉義的問題了：

s = r"ABC-001" # Python的字符串
# 對應的正則表達式字符串不變：
# "ABC-001"

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

>>> 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"正則表達式", test):
    print("ok")
else:
    print("failed")

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

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

嗯，無法識別連續的空格，用正則表達式試試：

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

如果用戶輸入了一組標簽，下次記得用正則表達式來把不規范的輸入轉化成正確的數組。

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

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

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

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

注意到group(0)永遠是原始字符串，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")

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

"^(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"這樣的非法日期，用正則還是識別不了，或者說寫出來非常困難，這時就需要程序配合識別了。

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

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

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

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

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

當我們在Python中使用正則表達式時，re模塊內部會干兩件事情：

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

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

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

>>> 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對象，由于該對象自己包含了正則表達式，所以調用對應的方法時不用給出正則字符串。

參考文獻：http://www.runoob.com/java/ja...

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

Pattern 類：pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要創建一個 Pattern 對象，你必須首先調用其公共靜態編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達式作為它的第一個參數。

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

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

以下實例中使用了正則表達式 .*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

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

((A)(B(C)))

(A)

(B(C))

(C)

可以通過調用 matcher 對象的 groupCount 方法來查看表達式有多少個分組。groupCount 方法返回一個 int 值，表示matcher對象當前有多個捕獲組。
還有一個特殊的組（group(0)），它總是代表整個表達式。該組不包括在 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+)(.*)";
 
      // 創建 Pattern 對象
      Pattern r = Pattern.compile(pattern);
 
      // 現在創建 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?

參考文獻：http://www.runoob.com/csharp/...

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

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

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

實例一：下面的實例匹配了以 "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" 結尾的單詞：

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 

參考文獻：https://blog.csdn.net/makenot...

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

實例一：電子郵件

// Regex.cpp : 定義控制臺應用程序的入口點。
//
#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參數可有可無，result是一個字符串數組，用來存儲正則表達式里面括號的內容。
   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})");
    //三位數的都可以，沒有設置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操作正則表達式
參考文獻：http://www.runoob.com/js/js-r...
參考文獻：https://www.cnblogs.com/zhuzh...

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

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


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

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

舉例如下所示：
// var pattern = RegExp("[ba]at","gi");//使用RegExp構造函數創建得到的效果和下面使用的字面量方法創建得到的效果相同
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
當然，上面代碼中使用了大量的console.log（）顯得很復雜，也可以將這5個屬性作為5個參數直接傳入到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個屬性保存在一個數組中，再通過console.log()直接輸出數組，如下所示：
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()方法
這個方法接收一個參數，即要應用模式的字符串，用于捕獲組。
如果匹配，則返回一個數組；否則返回null。
且其中返回的數組還有額外的兩個方法：index和input。index表示匹配項在字符串中的位置，input表示應用正則表達式的字符串。
舉例如下所示：
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；如果匹配，將會在控制臺中輸出一個數組
6.4.2 RegExp實例的test()方法
這個方法同樣也接收一個字符串，如果pattern（模式）和字符串匹配，則返回true，否則返回false。
并且test()方法經常被用在if語句中，舉例如下：



    
    


    
    提交
    


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

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

注意：Opera不支持上面的1236對應的四個屬性，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 ?