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

摘要：能匹配中的，但不能匹配中的数量界定符符号定义是一个非负整数。则等价于和均为非负整数，其中。该方法接受一个正则表达式作为它的第一个参数。是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
正则表达式是对字符串（包括普通字符（例如，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 ↩