正则表达式及多语言操纵指南

1. 正则表达式

正则表达式是对字符串操纵的一种逻辑公式，就是用事前定义好的一些特定字符、及这些特定字符的组合，构成一个“划定规矩字符串”，这个“划定规矩字符串”用来表达对字符串的一种过滤逻辑。

正则表达式是对字符串（包括平常字符（比方，a 到 z 之间的字母）和迥殊字符（称为“元字符”））操纵的一种逻辑公式，就是用事前定义好的一些特定字符、及这些特定字符的组合，构成一个“划定规矩字符串”，这个“划定规矩字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种文本情势，情势形貌在搜刮文本时要婚配的一个或多个字符串。

1.1 正则表达式标记

1.1.1 标记类

通用的标记：

迥殊的标记：

重点：关于 .

单行情势下(gs)：能婚配\n
多行情势下(gm)：不能婚配 \n

1.1.2 字符鸠合

1.1.3 字符边境

1.1.4 数目界定符

重点：关于 ?

贪欲情势下：数目限定符都是在满⾜前提下尽量的婚配更多的字符
非贪欲情势下：假如愿望在满⾜前提下尽量少的婚配字符, 在数目限定符后⾯加上“?”

1.1.5 分支前提

1.1.6 分组与后向引⽤

1.1.7 断⾔

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 经常使用的正则表达式

2. Python操纵正则表达式

参考文献：
https://www.liaoxuefeng.com/w…

2.1 婚配字符串

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

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)……示意第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'如许的不法日期，用正则照样辨认不了，或者说写出来非常难题，这时候就须要顺序合营辨认了。

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类来操纵正则表达式,其经常使用的要领以下：

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