正則表達式及多語言操做指南

時間  2019-12-09
標籤 正則 表達式 多語言 指南 欄目 正則表達式 简体版
原文   原文鏈接

正則表達式及多語言操做指南

1. 正則表達式

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

1.1 正則表達式符號

1.1.1 符號類

通用的符號：javascript

符號 含義 範例
. 任意字符 「A」, 「 」(空格), 「囧」, 「1」
d 匹配一個數字字符。等價於[0-9] 「1」, 「2」, 「3」
D 匹配一個非數字字符。等價於[^0-9] 「a」, 「b」, 「c」
w 匹配包括下劃線的任何單詞字符。等價於「[A-Za-z0-9_]」 「Y」, 「x」, 「_」, 「9」
W 匹配任何非單詞字符。等價於「[^A-Za-z0-9_]」 「 」(空格)
s 匹配任何空白字符，包括空格、製表符、換頁符等等。等價於[ fnrtv] 「 」(空格), 「r」, 「t」, 「n」
S 匹配任何非空白字符。等價於[^fnrtv] 「B」, 「囧」, 「5」

特殊的符號：html

符號 含義 範例
r 匹配一個回車符。等價於x0d和cM
f 匹配一個換頁符。等價於x0c和cL
n 匹配一個換行符。等價於x0a和cJ
t 匹配一個製表符。等價於x09和cI
\\ 匹配 「」
xhh 以ASCII碼進⾏匹配 x41能夠匹配」A」
uhhhh 以UNICODE碼進⾏匹配 u4e00-u9fa5 中⽂的範圍

重點：關於 .java

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

1.1.2 字符集合

符號 含義
[a-z] 字符範圍。匹配指定範圍內的任意字符。例如，「[a-z]」能夠匹配「a」到「z」範圍內的任意小寫字母字符
[abc] 字符集合。匹配所包含的任意一個字符。例如，「[abc]」能夠匹配「plain」中的「a」
[^xyz] 負值字符集合。匹配未包含的任意字符。例如，「1」能夠匹配「plain」中的「p」
[^a-c] 負值字符範圍。匹配任何不在指定範圍內的任意字符。例如，「2」能夠匹配任何不在「a」到「z」範圍內的任意字符
[\-] 匹配 「-」

1.1.3 字符邊界

符號 含義
^ 匹配輸入字符串的開始位置。若是設置了RegExp對象的Multiline屬性，^也匹配「n」或「r」以後的位置
& 匹配輸入字符串的結束位置。若是設置了RegExp對象的Multiline屬性，$也匹配「n」或「r」以前的位置
\b 匹配一個單詞邊界，也就是指單詞和空格間的位置。例如，「erb」能夠匹配「never」中的「er」，但不能匹配「verb」中的「er」
\B 匹配非單詞邊界。「erB」能匹配「verb」中的「er」，但不能匹配「never」中的「er」

1.1.4 數量界定符

符號 定義
x{n} n是一個非負整數。匹配肯定的n次。例如，「o{2}」不能匹配「Bob」中的「o」，可是能匹配「food」中的兩個o
x{n,} n是一個非負整數。至少匹配n次。例如，「o{2,}」不能匹配「Bob」中的「o」，但能匹配「foooood」中的全部o。「o{1,}」等價於「o+」。「o{0,}」則等價於「o*」
x{n,m} m和n均爲非負整數，其中n<=m。最少匹配n次且最多匹配m次。例如，「o{1,3}」將匹配「fooooood」中的前三個o。「o{0,1}」等價於「o?」。請注意在逗號和兩個數之間不能有空格
x* 匹配前面的子表達式零次或屢次。例如，zo*能匹配「z」以及「zoo」。*等價於{0,}
x+ 匹配前面的子表達式一次或屢次。例如，「zo+」能匹配「zo」以及「zoo」，但不能匹配「z」。+等價於{1,}
x? 匹配前面的子表達式零次或一次。例如，「do(es)?」能夠匹配「does」或「does」中的「do」。?等價於{0,1}

重點：關於 ?正則表達式

貪婪模式下：數量限定符都是在滿⾜條件下儘量的匹配更多的字符
非貪婪模式下：若是但願在滿⾜條件下儘量少的匹配字符, 在數量限定符後⾯加上「?」express

1.1.5 分支條件

符號 定義
x\ y 匹配x或y。例如，「z\ food」能匹配「z」或「food」。「(z\ f)ood」則匹配「zood」或「food」。

1.1.6 分組與後向引⽤

符號 定義
(x) 匹配pattern並獲取這一匹配。所獲取的匹配能夠從產生的Matches集合獲得，在VBScript中使用SubMatches集合，在JScript中則使用$0…$9屬性。要匹配圓括號字符，請使用「(」或「)」
1..n 引⽤第1-n組匹配
(?:x) 匹配pattern但不獲取匹配結果，也就是說這是一個非獲取匹配，不進行存儲供之後使用。這在使用或字符「( )」來組合一個模式的各個部分是頗有用。例如「industr(?:y ies)」就是一個比「industry industries」更簡略的表達式

1.1.7 斷⾔

符號 定義
(?=pattern) 正向確定預查，在任何匹配pattern的字符串開始處匹配查找字符串。這是一個非獲取匹配，也就是說，該匹配不須要獲取供之後使用。例如，「Windows(?=95 98 NT 2000)」能匹配「Windows2000」中的「Windows」，但不能匹配「Windows3.1」中的「Windows」。預查不消耗字符，也就是說，在一個匹配發生後，在最後一次匹配以後當即開始下一次匹配的搜索，而不是從包含預查的字符以後開始
(?!pattern) 正向否認預查，在任何不匹配pattern的字符串開始處匹配查找字符串。這是一個非獲取匹配，也就是說，該匹配不須要獲取供之後使用。例如「Windows(?!95 98 NT 2000)」能匹配「Windows3.1」中的「Windows」，但不能匹配「Windows2000」中的「Windows」。預查不消耗字符，也就是說，在一個匹配發生後，在最後一次匹配以後當即開始下一次匹配的搜索，而不是從包含預查的字符以後開始
(?<=pattern) 反向確定預查，與正向確定預查類擬，只是方向相反。例如，「(?<=95 98 NT 2000)Windows」能匹配「2000Windows」中的「Windows」，但不能匹配「3.1Windows」中的「Windows」
(?<!pattern) 反向否認預查，與正向否認預查類擬，只是方向相反。例如「(?<!95 98 NT 2000)Windows」能匹配「3.1Windows」中的「Windows」，但不能匹配「2000Windows」中的「Windows」

1.2 正則表達式網站

如下是經常使用的一些在線正則表達式測試工具，其中我的感受第一個最好！數組

  1. http://regex101.com/
  2. http://regexr.com/
  3. http://tool.lu/regex/
  4. http://tool.oschina.net/regex/
  5. http://tool.chinaz.com/regex/

1.3 正則表達式工具

  1. RegexBuddy
  2. RegexMagic

1.4 經常使用的正則表達式

需求 正則表達式
用戶名 ^[a-z0-9_-]{3,16}$
密碼 ^[a-z0-9_-]{6,18}$
十六進制值 ^#?([a-f0-9]{6} [a-f0-9]{3})$
電子郵箱 ^([a-z0-9_.-]+)@([da-z.-]+).([a-z.]{2,6})$/
URL ^(https?://)?([da-z.-]+).([a-z.]{2,6})([/w .-]*)*/?$
IP 地址 /((2[0-4]d 25[0-5] [01]?dd?).){3}(2[0-4]d 25[0-5] [01]?dd?)/
/^(?:(?:25[0-5] 20-4 [01]?0-9?).){3}(?:25[0-5] 20-4 [01]?0-9?)$/</div>
HTML 標籤 ^<([a-z]+)([^<]+)*(?:>(.*)</1> s+/>)$
刪除代碼\註釋 (?<!http: S)//.*$
Unicode編碼中的漢字範圍 ^[u2E80-u9FFF]+$
一個單詞連續出現的位置 b([a-z]+) 1b/gi
匹配空行 ^s*$
匹配中文字符 [u4e00-u9fa5]
匹配雙字節字符(包括漢字在內) [^x00-xff]
匹配空白行 ns*r
匹配國內電話號碼 d{3}-d{8} d{4}-{7,8}
匹配騰訊QQ號 1-9{4,}
匹配中國郵政編碼 [1-9]d{5}(?!d)
匹配18位身份證號 ^(d{6})(d{4})(d{2})(d{2})(d{3})([0-9] X)$
匹配(年-月-日)格式日期 ([0-9]{3}[1-9]
匹配正浮點數 ^[1-9]d*.d* 0.d*[1-9]d*$
匹配負浮點數 ^-[1-9]d*.d* -0.d*[1-9]d*$

2. Python操做正則表達式

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

2.1 匹配字符串

Python提供re模塊，包含全部正則表達式的功能。因爲Python的字符串自己也用\轉義，因此要特別注意：dom

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

2.2 切分字符串

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

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

若是用戶輸入了一組標籤，下次記得用正則表達式來把不規範的輸入轉化成正確的數組。

2.3 分組

除了簡單地判斷是否匹配以外，正則表達式還有提取子串的強大功能。用()表示的就是要提取的分組（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)……表示第一、二、……個子串。

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

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

2.4 貪婪匹配

最後須要特別指出的是，正則匹配默認是貪婪匹配，也就是匹配儘量多的字符。舉例以下，匹配出數字後面的0：

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

因爲\d+採用貪婪匹配，直接把後面的0所有匹配了，結果0*只能匹配空字符串了。

必須讓\d+採用非貪婪匹配（也就是儘量少匹配），才能把後面的0匹配出來，加個?就可讓\d+採用非貪婪匹配：

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

2.5 編譯

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

  1. 編譯正則表達式，若是正則表達式的字符串自己不合法，會報錯；
  2. 用編譯後的正則表達式去匹配字符串。

若是一個正則表達式要重複使用幾千次，出於效率的考慮，咱們能夠預編譯該正則表達式，接下來重複使用時就不須要編譯這個步驟了，直接匹配：

>>> 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對象，因爲該對象本身包含了正則表達式，因此調用對應的方法時不用給出正則字符串。

3. Java操做正則表達式

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

3.1 基礎

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

  1. Pattern 類：pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要建立一個 Pattern 對象，你必須首先調用其公共靜態編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達式做爲它的第一個參數。
  2. Matcher 類：Matcher 對象是對輸入字符串進行解釋和匹配操做的引擎。與Pattern 類同樣，Matcher 也沒有公共構造方法。你須要調用 Pattern 對象的 matcher 方法來得到一個 Matcher 對象。
  3. 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

3.2 捕獲組

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

  1. ((A)(B(C)))
  2. (A)
  3. (B(C))
  4. (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?

4. C#操做正則表達式

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

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

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

public bool IsMatch( string input )  指示 Regex 構造函數中指定的正則表達式是否在指定的輸入字符串中找到匹配項
public bool IsMatch( string input, int startat )  指示 Regex 構造函數中指定的正則表達式是否在指定的輸入字符串中找到匹配項，從字符串中指定的開始位置開始
public static bool IsMatch( string input, string pattern )  指示指定的正則表達式是否在指定的輸入字符串中找到匹配項
public MatchCollection Matches( string input )  在指定的輸入字符串中搜索正則表達式的全部匹配項

<div>public string Replace( string input, string replacement ) </div>

| 在指定的輸入字符串中，把全部匹配正則表達式模式的全部匹配的字符串替換爲指定的替換字符串 |
| 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, @"\bS\S*");
         Console.ReadKey();
      }
   }
}

輸出：

Matching words that start with 'S':
The Expression: \bS\S*
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, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}

輸出：

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
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

5. C++操做正則表達式

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

C++裏面使用正則表達式通常有三種：C regex，C ++regex，boost regex

實例一：電子郵件

// Regex.cpp : 定義控制檯應用程序的入口點。
//
#include <regex>
#include <iostream>
#include <stdio.h>
#include <string>
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<std::string::const_iterator> result;
   bool valid = std::regex_match(email, result,pattern);
   //此處result參數無關緊要，result是一個字符串數組，用來存儲正則表達式裏面括號的內容。
   if(valid&&(result.length()>0))
  {
      for(int i =0;i<result.length();i++)
      {
          cout<<result[i]<<endl;
      }
    }
   return valid;
}

實例二：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<std::string::const_iterator> result;
  bool valid = std::regex_match(ipaddress, result, pattern);
  if(valid&&(result.length()>0))
  {
      for(int i =0;i<result.length();i++)
      {
          cout<<result[i]<<endl;
      }
  }
  return valid;
}

測試：

int main(int argc,char** argv)
{

    cout<<"測試4個電子郵件選項"<<endl;
    std::string email1 = "marius.bancila@domain.com";
    std::string email2 = "mariusbancila@domain.com";
    std::string email3 = "marius_b@domain.co.uk";
    std::string email4 = "marius@domain";

    std::cout << email1 << " : " << (is_email_valid(email1) ? "valid" : "invalid") << std::endl;
    std::cout << email2 << " : " << (is_email_valid(email2) ? "valid" : "invalid") << std::endl;
    std::cout << email3 << " : " << (is_email_valid(email3) ? "valid" : "invalid") << std::endl;
    std::cout << email4 << " : " << (is_email_valid(email4) ? "valid" : "invalid") << std::endl;

    cout<<"測試4個IP地址選項"<<endl;
    std::string IPAddress1 = "202.20.144.3";
    std::string IPAddress2 = "255.02.233.02";
    std::string IPAddress3 = "127.256.2.36";
    std::string IPAddress4 = "123.-25.56.125";

    std::cout << IPAddress1 << " : " << (is_IPAddress_valid(IPAddress1) ? "valid" : "invalid") << std::endl;
    std::cout << IPAddress2 << " : " << (is_IPAddress_valid(IPAddress2) ? "valid" : "invalid") << std::endl;
    std::cout << IPAddress3 << " : " << (is_IPAddress_valid(IPAddress3) ? "valid" : "invalid") << std::endl;
    std::cout << IPAddress4 << " : " << (is_IPAddress_valid(IPAddress4) ? "valid" : "invalid") << std::endl;
    return 0 ;
}

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語句中，舉例以下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Regular Expression</title>
</head>
<body>
    <input type="text" id="phoneNumber">
    <button id="submit">提交</button>
    <script>
    window.onload=function(){
        var btn=document.getElementById("submit");
        btn.onclick=function(){
            var phoneNumber=document.getElementById("phoneNumber").value;
            var pattern=/1[358]\d{9}/gi;
            if(pattern.test(phoneNumber)){
                alert("Yes！ Your phoneNumber is legal");
            }else{
                alert("No！Your phoneNumber is illegal");
            }
        }
    }
    </script>
</body>
</html>

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構造函數也包含了一些屬性。值得注意的是，這些屬性有兩種方式來訪問---長屬性名和短屬性名。介紹以下：

  1. input $_ 最近一次要匹配的字符串 。（注意：前者是長屬性名，後者是短屬性名，下同）
  2. lastMatch $& 最近一次的匹配向。
  3. lastParen $+ 最近一次匹配的捕獲組。
  4. leftContext $` input字符串中lastMatch以前的文本
  5. RightContext $' input字符串中lastMatch以後的文本
  6. 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
    }
  1. abc ↩
  2. a-z ↩
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程