精华内容
下载资源
问答
  • 精通正则表达式

    2020-10-27 16:59:22
    精通正则表达式 下载地址 https://pan.baidu.com/s/1Ji_qiNU_FNQ_lvYb_qQ1xg 扫码下面二维码关注公众号回复 100134获取分享码 本书目录结构如下: 第一篇 正则表达式基础 第1章 正则表达式概述 3 1.1 ...

    精通正则表达式

    下载地址 https://pan.baidu.com/s/1Ji_qiNU_FNQ_lvYb_qQ1xg

    扫码下面二维码关注公众号回复 100134获取分享码

     

    本书目录结构如下:

    第一篇 正则表达式基础

    第1章 正则表达式概述 3

    1.1 什么是正则表达式 3

    1.2 第一个正则表达式 4

    1.3 测试工具 5

    第2章 正则表达式基础理论 7

    2.1 元字符 7

    2.1.1 匹配位置的元字符 8

    2.1.2 匹配字符的元字符 8

    2.1.3 元字符总结 9

    2.2 字符类 12

    2.3 字符转义 14

    2.4 反义 14

    2.5 限定符 15

    2.6 替换 21

    2.7 分组 23

    2.8 后向引用 24

    2.9 零宽度断言 25

    2.10 负向零宽度断言 27

    2.11 匹配选项 27

    2.12 注释 28

    2.13 优先级顺序 28

    2.14 递归匹配 29

    2.15 典型正则表达式解释 30

    第3章 数字验证 33

    3.1 数值验证 33

    3.1.1 只包含数字 33

    3.1.2 整数验证 37

    3.1.3 指定范围的整数验证 38

    3.1.4 实数验证 42

    3.1.5 指定精度的实数验证 45

    3.1.6 科学计数法的数值验证 45

    3.1.7 二进制数值验证 46

    3.1.8 八进制数值验证 47

    3.1.9 十六进制数值验证 49

    3.2 电话号码验证 50

    3.2.1 手机号码验证 50

    3.2.2 固定电话号码(不包括区号)验证 51

    3.2.3 “区号+固定电话号码”验证 53

    3.2.4 “区号+固定电话号码+分机号码”验证 54

    3.2.5 固定电话号码验证总结 55

    3.3 邮政编码验证 57

    3.3.1 国内邮政编码验证 57

    3.3.2 国际邮政编码验证 57

    3.4 IP地址验证 58

    3.4.1 简单IP地址验证 58

    3.4.2 精确IP地址验证 59

    3.4.3 子网内部IP地址验证 60

    3.4.4 64位IP地址验证 61

    3.5 身份证验证 63

    3.5.1 15位身份证号码验证 63

    3.5.2 18位身份证号码验证 64

    3.6 银行卡号验证 65

    3.6.1 银行卡号验证 65

    3.6.2 信用卡卡号验证 65

    3.6.3 中国建设银行卡号验证 66

    3.6.4 中国工商银行卡号验证 66

    3.6.5 中国农业银行卡号验证 66

    第4章 字符串验证 67

    4.1 英文单词验证 67

    4.1.1 小写单词验证 67

    4.1.2 大写英文单词验证 68

    4.1.3 英文单词的分隔符验证 69

    4.1.4 不包含验证 71

    4.1.5 具有重复特征的英文单词验证 74

    4.2 文件名称和文件路径验证 76

    4.2.1 通配符 76

    4.2.2 指定文件扩展名的验证 76

    4.2.3 指定文件名的验证 77

    4.2.4 包含指定字符串的文件全名验证 78

    4.2.5 排除两端存在空白字符的文件全名验证 79

    4.2.6 文件路径验证 81

    4.3 网络常用元素验证 82

    4.3.1 电子邮件验证 82

    4.3.2 主机名称验证 83

    4.3.3 HTTP地址验证 85

    4.3.4 FTP地址验证 86

    4.4 非单词字符串验证 86

    4.4.1 英文标点符号验证 87

    4.4.2 中文标点符号验证 87

    4.4.3 中文文本验证 88

    4.4.4 特殊字符验证 88

    4.4.5 密码验证 89

    4.4.6 字符表的分类 93

    第5章 数字和字符混合验证 95

    5.1 日期和时间验证 95

    5.1.1 年验证 95

    5.1.2 月验证 96

    5.1.3 日验证 97

    5.1.4 年月日格式的日期验证 98

    5.1.5 24小时制时分秒格式的时间验证 99

    5.1.6 12小时制时分秒格式的时间验证 100

    5.1.7 带毫秒的时间验证 102

    5.1.8 长格式的日期和时间验证 103

    5.2 通用车牌号码验证 104

    5.3 数学表达式验证 106

    5.3.1 操作数验证 106

    5.3.2 操作符验证 107

    5.3.3 简单数学表达式验证 107

    5.3.4 只含操作数和操作符的数学表达式验证 108

    5.3.5 含小括号的数学表达式验证 109

    5.4 编码规范验证 111

    5.4.1 类名称验证 111

    5.4.2 声明变量表达式验证 112

    5.4.3 函数名称验证 112

    5.4.4 声明函数表达式验证 113

    第6章 验证和处理HTML元素 117

    6.1 HTML元素验证基础 117

    6.1.1 HTML标记验证 117

    6.1.2 非封闭HTML标记验证 119

    6.1.3 封闭HTML标记验证 119

    6.1.4 属性赋值表达式验证 120

    6.1.5 HTML中的注释验证 124

    6.1.6 HTML中的脚本代码块验证 125

    6.2 非封闭的HTML元素验证 126

    6.3 封闭的HTML元素验证 127

    6.4 br 元素验证 128

    6.5 hr 元素验证 130

    6.6 a 元素验证 133

    6.7 input 元素验证 137

    6.8 处理HTML元素 139

    6.8.1 提取HTML标记 139

    6.8.2 提取HTML标记之间的内容 140

    6.8.3 提取URL 141

    6.8.4 提取图像的URL 142

    6.8.5 提取HTML页面的标题 142

    第二篇中正则表达式的应用

    第7章 C#常用数据类型检查与转换 147

    7.1 数值数据类型检查与转换 147

    7.1.1 整数检查 147

    7.1.2 实数检查 149

    7.1.3 整数和字符串之间的转换 150

    7.1.4 浮点数和字符串之间的转换 151

    7.2 布尔数据类型检查与转换 153

    7.2.1 布尔值检查 153

    7.2.2 布尔值和字符串之间的转换 153

    7.3 时间数据类型检查与转换 154

    7.3.1 时间数据类型检查 154

    7.3.2 时间和字符串之间的转换 155

    7.4 数据类型检查与转换应用实例 156

    第8章 字符串处理 158

    8.1 不变字符串String处理 158

    8.1.1 String类和对象 158

    8.1.2 插入字符串 159

    8.1.3 删除字符串 160

    8.1.4 替换字符串 160

    8.1.5 分割字符串 161

    8.1.6 填充字符串 161

    8.1.7 比较字符串 162

    8.1.8 连接字符串 163

    8.1.9 处理字符串中的空白 165

    8.1.10 转换字符串大小写 165

    8.1.11 匹配和检索字符串 166

    8.1.12 获取子字符串 168

    8.1.13 格式化字符串 169

    8.1.14 编码字符串 169

    8.1.15 不可变字符串String处理的应用 170

    8.2 可变字符串StringBuilder处理 172

    8.2.1 StringBuilder类和对象 172

    8.2.2 追加字符串 172

    8.2.3 插入字符串 174

    8.2.4 删除字符串 176

    8.2.5 替换字符串 176

    8.2.6 复制字符串 177

    8.2.7 处理字符串容量 178

    8.2.8 可变字符串StringBuilder处理的应用 179

    第9章 .NET框架中正则表达式的应用 181

    9.1 .NET框架中的正则表达式类库 181

    9.1.1 System.Text.RegularExpressions名字空间 181

    9.1.2 正则表达式类Regex 182

    9.1.3 正则表达式选项 183

    9.1.4 检查是否匹配表达式 183

    9.1.5 匹配单个匹配项 185

    9.1.6 匹配多个匹配项 186

    9.1.7 替换 188

    9.1.8 使用委托MatchEvaluator处理匹配结果 189

    9.1.9 获取分组名称 190

    9.1.10 分割表达式 190

    9.2 使用正则表达式类Regex处理字符串 191

    9.2.1 只包含数字验证 191

    9.2.2 整数验证 191

    9.2.3 实数验证 192

    9.2.4 电话号码验证 192

    9.2.5 邮政编码验证 192

    9.2.6 身份证号码验证 192

    9.2.7 银行卡号验证 193

    9.2.8 日期和时间验证 193

    9.2.9 车牌号码验证 193

    9.2.10 IP地址验证 194

    9.2.11 电子邮件验证 194

    9.2.12 URL验证 194

    9.2.13 提取网页标题 194

    9.2.14 提取网页中的HTTP地址 196

    9.2.15 提取网页中的图像地址 197

    第10章 数据验证 199

    10.1 验证概述 199

    10.2 非空验证 201

    10.2.1 无初始值的非空验证 201

    10.2.2 指定初始值的验证 202

    10.3 范围验证 203

    10.3.1 整数范围验证 203

    10.3.2 字母范围验证 204

    10.3.3 日期范围验证 205

    10.4 比较验证 206

    10.4.1 两个控件内容的比较验证 206

    10.4.2 指定的值和控件内容的比较验证 207

    10.4.3 检查控件内容的数据类型 208

    10.5 正则表达式验证 209

    10.5.1 整数验证 209

    10.5.2 数值验证 210

    10.5.3 电话号码验证 211

    10.5.4 身份证号码验证 212

    10.5.5 日期和时间验证 213

    10.5.6 电子邮件验证 214

    10.5.7 URL验证 215

    10.6 自定义验证 217

    10.6.1 自定义服务器端验证 217

    10.6.2 自定义客户端验证 218

    10.7 显示验证摘要 219

    10.7.1 在网页上显示验证摘要 220

    10.7.2 在对话框上显示验证摘要 220

    第三篇 ASP中正则表达式的应用

    第11章 ASP数据类型及其转换 225

    11.1 VBScript数据类型 225

    11.2 VBScript数据类型判断 226

    11.2.1 判断变量是否为数组 226

    11.2.2 判断变量是否为日期 227

    11.2.3 判断变量是否为空 228

    11.2.4 判断变量是否为空值 228

    11.2.5 判断变量是否为数值 229

    11.2.6 判断变量是否为对象 230

    11.2.7 获取变量的子类型 231

    11.2.8 获取变量的类型信息 231

    第12章 ASP字符串处理 233

    12.1 字符串截取、组合 233

    12.1.1 获取字符串长度 233

    12.1.2 正向截取字符串 234

    12.1.3 反向截取字符串 234

    12.1.4 从中截取字符串 235

    12.1.5 删除字符串前导空格 236

    12.1.6 删除字符串后导空格 236

    12.1.7 删除字符串前后导空格 237

    12.1.8 将数组元素连接为字符串 238

    12.1.9 切分字符串 238

    12.2 字符串查找、替换 239

    12.2.1 正向查找字符串 239

    12.2.2 反向查找字符串 241

    12.2.3 字符串替换 242

    12.3 字符串转化 243

    12.3.1 字符串小写转化 243

    12.3.2 字符串大写转化 244

    12.3.3 字符串倒序排列 245

    12.3.4 构造指定元素的字符串 246

    12.3.5 构造空格字符串 247

    第13章 ASP中正则表达式的应用 248

    13.1 正则表达式对象RegExp概述 248

    13.1.1 创建正则表达式对象 248

    13.1.2 指定正则表达式 248

    13.1.3 进行正则匹配检验 249

    13.2 提高匹配效率 250

    13.2.1 设置匹配范围 250

    13.2.2 指定忽略大小写 250

    13.2.3 进行正则匹配替换 251

    13.3 匹配集合Matches 252

    13.3.1 获取Matches集合 252

    13.3.2 Matches集合与Match对象 253

    第四篇 PHP中正则表达式的应用

    第14章 PHP数据类型及其转换 259

    14.1 PHP常见数据类型 259

    14.1.1 布尔型 259

    14.1.2 NULL型 260

    14.1.3 整型 260

    14.1.4 浮点型 260

    14.1.5 字符串 260

    14.1.6 数组 262

    14.1.7 对象 263

    14.2 类型转换 264

    14.2.1 变量类型变化 264

    14.2.2 强制类型转换 266

    14.2.3 字符串转换 268

    14.2.4 数值转换 269

    14.2.5 数组转换 269

    第15章 PHP字符串处理 270

    15.1 字符串分析 270

    15.1.1 访问字符串中的字符 270

    15.1.2 处理子字符串 271

    15.1.3 分割字符串 273

    15.2 字符串的整理 275

    15.2.1 删除字符串的空白 275

    15.2.2 字符串的填充 276

    15.2.3 字符串大小写的转换 277

    15.2.4 字符串的反转 278

    15.3 字符串的比较 278

    15.3.1 按ASCII码顺序比较 278

    15.3.2 按“自然排序”法比较 280

    15.3.3 按相似性比较 281

    15.4 字符串的查找和替换 282

    15.4.1 查找字符串 282

    15.4.2 替换字符串 283

    15.5 字符串的格式化 286

    15.5.1 格式化数字 286

    15.5.2 格式化字符串 286

    15.6 处理HTML和URL 288

    15.6.1 HTML实体的处理 288

    15.6.2 HTML标签的清理 290

    15.6.3 URL字符串的解析 291

    15.6.4 URL编码处理 293

    15.6.5 查询字符串的构造 293

    第16章 PHP中正则表达式的应用 295

    16.1 POSIX扩展库正则表达式函数 295

    16.1.1 模式匹配 295

    16.1.2 模式替换 297

    16.1.3 模式分割 297

    16.2 PCRE库的正则表达式函数 298

    16.2.1 进行正则表达式匹配 298

    16.2.2 取得正则表达式的全部匹配 299

    16.2.3 返回与模式匹配的数组单元 300

    16.2.4 正则表达式的替换 300

    16.2.5 正则表达式的拆分 301

    16.3 PHP与正则表达式的综合应用 302

    16.3.1 表单验证 302

    16.3.2 UBB代码 306

    16.3.3 分析Apache日志文件 310

    第五篇 JSP中正则表达式的应用

    第17章 JSP中数据类型及其转化 317

    17.1 JSP中的常用数据类型 317

    17.1.1 整数类型 317

    17.1.2 浮点类型 320

    17.1.3 字符类型 321

    17.1.4 布尔类型 322

    17.1.5 字符串类型 323

    17.2 JSP中数据类型的转换 325

    17.2.1 自动类型转换 325

    17.2.2 强制类型转换 326

    17.3 JSP中字符串数据的处理 327

    17.3.1 字符串与其他类型数据的转换 327

    17.3.2 字符串的分析 329

    17.3.3 字符串的查找与替换 330

    17.3.4 字符串数据的整理 332

    17.3.5 字符串的比较 333

    17.3.6 字符串的连接 334

    17.3.7 字符串的格式化 335

    第18章 JSP中正则表达式应用 337

    18.1 JSP中的正则表达式函数 337

    18.1.1 Pattern类 337

    18.1.2 Matcher类 339

    18.1.3 正则表达式常用的4种功能 342

    18.2 JSP中正则表达式的常见应用示例 346

    18.2.1 电子邮件地址的校验 346

    18.2.2 URL地址的校验 348

    18.2.3 电话号码的校验 349

    第六篇 JavaScript中正则表达式的应用

    第19章 JavaScript数据类型及其转换 353

    19.1 JavaScript数据类型 353

    19.1.1 数字类型 353

    19.1.2 字符串类型 354

    19.1.3 布尔值类型 355

    19.2 数据类型转换 356

    19.2.1 基本数据类型转换 356

    19.2.2 将字符串转换为整数 356

    19.2.3 将字符串转换为浮点数 356

    第20章 JavaScript字符串和数组 357

    20.1 字符串格式处理 357

    20.1.1 获取字符串的长度 357

    20.1.2 根据指定的Unicode编码返回一个字符串 358

    20.1.3 比较两个字符串的大小 358

    20.1.4 将字符串分割并存储到数组中 359

    20.1.5 将字符串转换为小写格式 360

    20.1.6 将字符串转换为大写格式 360

    20.2 字符串截取、组合 361

    20.2.1 返回字符串中指定位置处的字符 361

    20.2.2 获取指定位置字符的Unicode编码 362

    20.2.3 将一个或多个字符串连接到当前字符串的末尾 364

    20.2.4 从字符串中提取子串(1) 364

    20.2.5 从字符串中提取子串(2) 365

    20.2.6 从字符串中提取子串(3) 366

    20.3 字符串查找、替换 367

    20.3.1 获取指定字符(串)第一次在字符串中出现的位置 367

    20.3.2 获取指定字符(串)最后一次在字符串中出现的位置 368

    20.3.3 替换字符串中指定的内容 369

    20.4 字符串HTML格式化 370

    20.4.1 在字符串两端加入锚点标志 370

    20.4.2 在指定字符串的两端加上大字体标志 370

    20.4.3 在字符串的两端加上粗体标志 371

    20.4.4 在字符串两端加入斜体标签 371

    20.4.5 在字符串两端加上固定宽度字体标记 372

    20.4.6 设置字符串输出时的前景色 373

    20.4.7 设置字符串输出时的字体大小 374

    20.4.8 在字符串上加入超级链接 375

    20.4.9 在字符串两端加入小字体标记 375

    20.4.10 在字符串两端加入下划线标记 376

    20.4.11 在字符串两端加入下标标签 377

    20.4.12 在字符串两端加入上标标签 378

    20.5 Array对象的方法 378

    20.5.1 连接其他数组到当前数组末尾 378

    20.5.2 将数组元素连接为字符串 379

    20.5.3 删除数组中的最后一个元素 380

    20.5.4 将指定的数据添加到数组中 380

    20.5.5 反序排列数组中的元素 381

    20.5.6 删除数组中的第一个元素 382

    20.5.7 获取数组中的一部分数据 382

    20.5.8 对数组中的元素进行排序 383

    20.5.9 删除或替换数组中的部分数据 384

    20.5.10 在数组前面插入数据 385

    20.5.11 返回一个包含数组中全部数据的字符串 386

    第21章 JavaScript中正则表达式的应用 387

    21.1 应用正则表达式对象RegExp 387

    21.1.1 创建正则表达式 387

    21.1.2 判断字符串中是否存在匹配内容 388

    21.1.3 对字符串进行匹配检测 389

    21.1.4 编译正则表达式 389

    21.1.5 替换字符串中的指定内容 390

    21.2 匹配结果处理 391

    21.2.1 获取字符串中所有的匹配信息 391

    21.2.2 获取第一次匹配的起始位置(1) 392

    21.2.3 获取第一次匹配的起始位置(2) 393

    21.2.4 获取子匹配的结果 394

    21.2.5 获取与正则表达式进行匹配检测的字符串 395

    21.2.6 获取匹配内容的最后一个索引位置 395

    21.2.7 获取最近一次匹配的内容 396

    21.2.8 获取最近一次匹配的最后一个子匹配 397

    21.2.9 获取匹配内容左侧的字符信息 397

    21.2.10 获取匹配内容右侧的字符信息 398

     

    展开全文
  • 看完你就会正则表达式了 原文连接:https://baijiahao.baidu.com/s?id=1588848792548192879&wfr=spider&for=pc 最近看了一篇关于正则表达式的学习笔记,觉得讲的非常好,更有图形化的神器相助,想...

    看完你就会正则表达式了

    原文连接:https://baijiahao.baidu.com/s?id=1588848792548192879&wfr=spider&for=pc

    最近看了一篇关于正则表达式的学习笔记,觉得讲的非常好,更有图形化的神器相助,想不学会都难,所以想转给大家看看。

    话说不是开发为啥要学正则表达式这种看似很晦涩的东西呢,因为现在很多搜索的场景都是支持正则表达式的,学会了正则表达式就有如一把利剑在手。

    本文较长,建议抽40分钟完整的时间一次读完再慢慢消化。以下是正文(为了适应难度,做了稍许调整)

    1.什么是正则表达式

    正则表达式,又称正规表示式、正规表示法、正规表达式、规则表达式、常规表示法(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。在很多文本编辑器里,正则表达式通常被用来检索、替换那些匹配某个模式的文本。

    通俗的讲就是按照某种规则去匹配符合条件的字符串

    2.利用图形化工具理解正则表达式

    辅助理解正则表达的在线工具 https://regexper.com/ 我们利用这个工具辅助理解,正则表达式。语法没懂表着急,后面会有,这里只是学会用工具帮助我们学习。

    手机号正则

    /^1[34578][0-9]{9}$/

    注释:以1开头,第二位为3 4 5 7 9 其中一个,以9位(本身1次加重复8次)0-9数字结尾

    单词边界

    /\bis\b/

    注释: is前后都是单词的边界,比较晦涩难懂?感受下两者的区别,\b 会方道语法部分讲解

    URL分组替换

    /http:(\/\/.+\.jpg)/

    看不懂的不要慌语法部分后面会有介绍,这里只是展示利用可视化的图形帮助我们理解正则表达式,可以回来再看木有关系

    正则表达式中括号用来分组,这个时候我们可以通过用$1来获取 group#1的内容

    说下这个正则的意义,如果网站用了https,网站引用静态资源也必须是https,否则报错。如果写成 // 会自动识别 http 或者 https

    日期匹配与分组替换

    /^\d{4}[/-]\d{2}[/-]\d{2}$/

    这个正则比较复杂,画符念咒的地方太多了,一一分析:

    Start of line 是由^生效的表示以此开头

    对应结尾End of line 由$生效表示以此结尾

    接着看digit 由 \d 生效表示数字

    3times 由{4} 生效表示重复4次,开始的时候有疑问,为什么不是 4times 。后来明白作者的用意,正则表达式是一个规则,用这个规则去从字符串开始匹配到结束(注意计算机读字符串可是不会分行的,都是一个串,我们看到的多行,人家会认为是个 \t )这里设计好像小火车的轨道一直开到末尾。digit 传过一次,3times表示再来三次循环,共4次,后面的once同理。 自己被自己啰嗦到了。

    接下来,是 one of 在手机正则里面已经出现了。表示什么都行。只要符合这两个都让通过。

    好了这个正则解释完了,接下来用它做什么呢?

    我们可以验证日期的合法性

    结合URL分组替换所用到的分组特性,我们可以轻松写出日期格式化的方法

    改造下这个正则

    /^(\d{4})[/-](\d{2})[/-](\d{2})$/

    轻松的可以拿到 group#1 #2 #3 的内容,对应 $1$2$3

    到现在已经能结合图形化工具看懂正则表达式表达式了,如果想自己写,还要在正则语法上下点功夫

    4. 正则表达式语法

    1 修饰符 (三个 g i m)

    修饰符与其他语法特殊,字面量方法声名的时候放到//后,构造函数声明的时候,作为第二个参数传入。整个正则表达式可以理解为正则表达式规则字符串+修饰符

    g:global 执行一个全局匹配

    i:ignore case执行一个不区分大小写的匹配

    m: multiple lines多行匹配

    修饰符可以一起用 const reg =/\bis\b/gim

    来说说他们有什么作用

    有g和没有g的区别

    没有g只替换了第一个,有g 所有的都换了

    有i和没有i的区别

    有i忽略大小写,没有i严格区分大小写

    2 元字符

    正则表达式由两种基本字符组成:

    原义字符

    非打印字符

    元字符 (* + ? $ ^ . | \ ( ) { } [ ])

    3. 原义字符

    这个没什么好解释的,我们一直在举例的 /is/ 匹配字符串'is'

    \将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如,n”匹配字符“n”。“\n”匹配一个换行符。序列“\\”匹配“\”而“\(”则匹配“(”。

    4. 非打印字符

    字符

    描述

    \cx

    匹配由x指明的控制字符。例如, \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则,将 c 视为一个原义的 'c' 字符。

    \f

    匹配一个换页符。等价于 \x0c 和 \cL。

    \n

    匹配一个换行符。等价于 \x0a 和 \cJ。

    \r

    匹配一个回车符。等价于 \x0d 和 \cM。

    \s

    匹配任何空白字符,包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。

    \S

    匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

    \t

    匹配一个制表符。等价于 \x09 和 \cI。

    \v

    匹配一个垂直制表符。等价于 \x0b 和 \cK。

    非打印字符,以\n为例

    其他的在前端引用比较少,应该在后端处理文本文件的时候会用到

    5. 字符类 []

    在前面的手机号正则例子中,我们已经使用过[] /^1[34578][0-9]{9}$/ : [34578]表示34578任意一个数字即可。在日期匹配与分组替换例子中 /^\d{4}[/-]\d{2}[/-]\d{2}$/ 表示符合 /- 都可以

    6. 字符类取反 [^]

    表示不属于此类

    空格也不属于,好多狗

    7. 范围类[-]

    正则表达式支持一定范围规则比如 [a-z][A-Z][0-9] 可以连写[a-z0-9] 如果你只是想匹配-在 范围类最后加-即可。请看实例。

    8. 预定义类

    常用为了方便书写

    字符

    等价类

    含义

    .

    [^\n\r]

    除了回车符和换行符之外的所有字符

    \d

    [0-9]

    数字字符

    \D

    [^0-9]

    非数字字符

    \s

    [\t\n\x0B\f\r]

    空白符

    \S

    [^\t\n\x0B\f\r]

    非空白符

    \w

    [a-zA-Z_0-9]

    单词字符(字母、数字、下划线)

    \W

    [^a-zA-Z_0-9]

    非单词字符

    有了这些预定义类,写一些正则就很方便了,比如我们希望匹配一个 ab+数字+任意字符 的字符串,就可以这样写了 /ab\d./

    9. 边界

    字符

    含义

    ^

    以xx开头

    $

    以xx结尾

    \b

    单词边界,指[a-zA-Z_0-9]之外的字符

    \B

    非单词边界

    边界顾名思义即定义匹配的边界条件,上面基本都在前面的例子碰到了,这里演示下\b与\B的区别

    10. 量词

    字符

    含义

    ?

    出现零次或一次

    *

    出现零次或多次(任意次)

    +

    出现一次或多次(至道一次)

    {n}

    对应零次或者n次

    {n,m}

    至少出现n次但不超过m次

    {n,}

    至少出现n次(+的升级版)

    {0,n}

    至多出现n次(其实就是{n,m} 方便记忆而已)

    如果没有量词,要匹配4位数字这样写就可以/\d\d\d\d/, 如果匹配50位100位呢?那不是要疯掉了?

    有了量词,就可以这样写/\d{100}/, 量词的使用我们在手机号中使用过,表现在可视化中就是循环多少次。

    凑一个上面都包含的实例/\d?@\d*@\d+@\d{10}@\d{10,20}@\d{10,}@\d{0,10}/

    11.贪婪与懒惰(非贪婪)

    正则表达式默认会匹配贪婪模式,什么是贪婪模式呢?如其名尽可能多的匹配。我们看个例子。

    /\d{3,6}/

    贪婪模式下,匹配的了最多的情况。

    与贪婪对应就是懒惰模式,懒惰对应的就是匹配的尽可能少的情况。如何开启懒惰模式? 在量词后面加?。继续上面的例子

    /\d{3,6}?/

    如果想知道,正则表达式是如何匹配量词的,请看 进阶正则表达式 文中有介绍,正则是如何回溯的。

    12.分组与反向引用

    分组,又称为子表达式。把正则表达式拆分成小表达式。概念枯燥,说个例子为嘛用分组:

    不分组 /abc{2}/

    量词仅作用到最后的c

    分组 /(abc){2}/

    注意这里 group #1

    分组虽然和运算符() 很像,但是分组在正则表达式中,注意理解组的含义。经常有人滥用分组

    /^(http|https)/ 真的需要这样么?其实 /^https?/就可以了,你正则写的特别长的时候,会出现一堆没用的结果,看着都头疼吧。

    分组往往和反向引用一起使用,别被概念吓到:当一个正则表达式被分组后,每个分组自动被赋予一个组号,一左到右分别是 $1$2…

    再把之前的例子拿出来

    /^(\d{4})[/-](\d{2})[/-](\d{2})$/

    轻松的可以拿到 group#1 #2 #3 的内容,对应 $1$2$3

    如果在反向引用中不想捕获年该如何操作? 加上 ?:即可

    /^(?:\d{4})[/-](\d{2})[/-](\d{2})$/

    12.前瞻

    这部分为进阶部分—选看

    正则表达式中有前瞻(Lookahead)和后顾(Lookbehind)的概念,这两个术语非常形象的描述了正则引擎的匹配行为。需要注意一点,正则表达式中的前和后和我们一般理解的前后有点不同。一段文本,我们一般习惯把文本开头的方向称作“前面”,文本末尾方向称为“后面”。但是对于正则表达式引擎来说,因为它是从文本头部向尾部开始解析的(可以通过正则选项控制解析方向),因此对于文本尾部方向,称为“前”,因为这个时候,正则引擎还没走到那块,而对文本头部方向,则称为“后”,因为正则引擎已经走过了那一块地方。

    注意:后顾性能损耗比较大,js只支持前瞻(知乎上看到的,具体原因不详)

    上面的比较概念话,尝试用大白话讲讲,就说皇上选妃吧,先行条件得是美女吧,长得“如花”那样皇上可不要,漂亮这关过了,皇上想要这个美女也不行,皇室有规矩,必须是贵族血统。

    那么“漂亮”就是正常的匹配,匹配到了,还得看看家室是不是贵族。"贵族"相当于前瞻条件

    前瞻分两种一种是正向前瞻(?=xxx), 另一种是负向前瞻(?!xxx)

    展开全文
  • 正则表达式(Regular Expression)在代码中常常简写为regex。正则表达式通常被用来检索、替换那些符合某个规则的文本,它是一种强大而...针对上面的每个点我会分别写一篇文章来说明,用最短的时间学会正则表达式。...

    正则表达式(Regular Expression)在代码中常常简写为regex。正则表达式通常被用来检索、替换那些符合某个规则的文本,它是一种强大而灵活的文本处理工具。

    正则描述了一个规则,通过这个规则可以匹配一类字符串。

    如何学习正则?

    1、学习正则表达式的语法规则
    2、练习使用正则并能解决实际问题

    针对上面的每个点我会分别写一篇文章来说明,用最短的时间学会正则表达式。

    这篇文章讲述正则表达式的语法和使用说明,让你半小时学会正则表达式。

    学习正则表达式语法,主要就是学习元字符以及它们在正则表达式上下文中的行为。

    为了便于理解,文章所有示例的正则表达式用“regex=正则”表示,“=”号后面就是正则表达式,匹配到的字符会用颜色标注出来,连续匹配到的字符用一深一浅两种颜色区分。比如:regex=\d+,其中\d+就是一个正则,它匹配任意多于1个的数字,如下:

    regex=\d+匹配的字符串

    正则表达式语法汇总

    元字符:
    普通字符、标准字符、特殊字符、限定字符(量词)、定位字符(边界字符)。

    普通字符:
    字母[a-zA-Z]、数字[0-9]、下划线[-]、汉字,标点符号

    匹配字母a可以regex=a
    匹配字母b可以regex=b
    匹配字母a或者b可以regex=a|b,这个正则引入一个特殊字符“|”,专业名称为“或”,你也可以叫它“竖线”,总之它表示“或”的意思。

    匹配字母a或者b或者c可以regex=a|b|c
    匹配字母a或者b或者c或者d可以regex=a|b|c|d
    明显发现这么写有点傻了,如果匹配所有26个字母,这种写法就太二了。

    这里引入两个特殊字符方括号“[ ]”和中划线“-”
    “[ ]”,专业名称为“字符集合”,你也可以叫它“方括号”。
    “-”,表示“范围”,你也可以叫它“到”,regex=[a-z]匹配从a到z26个字母的任意一个。

    那么匹配字母a或者b或者c或者d可以regex=[abcd]
    匹配数字1到8的任意数字可以regex=[1-8],这样就不会匹配到0与9这2个数字了,如下:

    regex=[1-8]匹配的字符串

    标准字符集合:
    标准字符集合是能够与“多种普通字符”匹配的简单表达式,比如:\d、\w、\s

    匹配数字0到9的任意数字可以regex=[0-9]也可以regex=\d
    标准字符集要注意区分大小写,大写是相反的意思
    regex=\D,则匹配非数字字符,即不能匹配数字0到9,如下:

    regex=\D匹配的字符串

    下面是一些常用的标准字符说明

    标准字符含义
    \d匹配0-9中的任意一个数字,等效于[0-9]
    \D匹配非数字字符,等效于[^0-9]
    \w匹配任意一个字母、数字或下划线,等效于[^A-Za-z0-9_]
    \W与任何非字母、数字或下划线字符匹配,等效于[^A-Za-z0-9_]
    \s匹配任何空白字符,包括空格、制表符、换页符,等效于 ?[\f\n\r\t\v]
    \S匹配任何非空白字符,等效于[^\f\n\r\t\v]
    \n匹配换行符
    \r匹配一个回车符
    \t匹配制表符
    \v匹配垂直制表符
    \f匹配换页符

    特殊字符:
    这些字符在正则表达式中表示特殊的含义,比如:*,+,?,\,等等

    “\”是转义字符,用于匹配特殊字符

    匹配反斜杠“\”可以regex=\\,因为“\”是特殊字符,所以需要在它前边再加一个“\”进行转义

    匹配星号“*”,可以regex=\*,因为“*”是特殊字符,所以需要在它前边再加一个“\”进行转义

    下面是一些常用的特殊字符说明,后面都会讲到

    特殊字符含义
    \转义字符,将下一个字符标记为一个特殊字符
    ^匹配字符串开始的位置
    $匹配字符串结尾的位置
    *零次或多次匹配前面的字符或子表达式
    +一次或多次匹配前面的字符或子表达式
    ?零次或一次匹配前面的字符或子表达式
    .“点” 匹配除“\r\n”之外的任何单个字符
    |
    [ ]字符集合
    ( )分组,要匹配圆括号字符,请使用 “(” ?或 “)”

    限定字符(量词)
    限定字符又叫量词,是用于表示匹配的字符数量的。

    匹配任意1位数字可以regex=\d
    匹配任意2位数字可以regex=\d\d
    匹配任意3位数字可以regex=\d\d\d

    匹配任意16位数字,再这么写就有点傻了
    这里引入用于表示数量限定字符“{n}”
    {n},n是一个非负整数,匹配确定的n次

    注意:regex=\d\d{3}匹配任意4个数字不是6个,量词只对它前面的字符负责,regex=\d\d{3}匹配的内容如下:

    regex=\d\d{3}匹配的字符串

    匹配任意16位数字可以regex=\d{16}
    匹配任意16位以上的数字可以regex=\d{16,}
    匹配任意1到16位以上的数字可以regex=\d{1,16}

    regex=\d{1,16}匹配到的字符串

    从上图,我们可以看到regex=\d{1,16},可以匹配到任意1-16个数字

    下面介绍一下匹配次数中的贪婪模式与非贪婪模式

    正则的匹配默认是贪婪模式,即匹配的字符越多越好,
    非贪婪模式是匹配的字符越少越好,在修饰匹配字数的量词后再加上一个问号“?”即可。

    那么同样是上面的字符串,regex=\d{1,16}?匹配到什么呢?

    regex=\d{1,16}?匹配到的字符串

    因为在{1,16}这个量词后面加上了问号“?”,表示非贪婪模式,所以只能匹配到1个数字,即匹配的字符越少越好。

    下面是一些常用的限定字符说明

    限定字符含义
    *零次或多次匹配前面的字符或子表达式
    +一次或多次匹配前面的字符或子表达式
    ?零次或一次匹配前面的字符或子表达式
    {n}n是一个非负整数,匹配确定的n次
    {n,}n是非负整数,至少匹配n次
    {n,m}n和m是非负整数,其中n<=m;匹配至少n次,至多m次

    匹配0个或多个字母A可以regex=A*或者regex=A{0,}
    匹配至少一个字母A可以regex=A+或者regex=A{1,}
    匹配0个或1字母A可以regex=A?或者regex=A{0,1}

    匹配至少一个LOVE可以regex=(LOVE)+,匹配的效果如下:

    regex=(LOVE)+匹配到的字符串

    定位字符(字符边界)
    定位字符也叫字符边界,标记匹配的不是字符而是符合某种条件的位置,所以定位字符是“零宽的”。

    下面是一些常用的定位字符说明

    定位字符含义
    ^匹配字符串开始的位置,表示开始
    $匹配字符串结尾的位置,表示结尾
    \b匹配一个单词边界

    匹配以Hello开头的字符串可以regex=^Hello

    regex=^Hello匹配到的字符串

    匹配以Hello结尾的字符串可以regex=Hello$,如下:

    regex=Hello$匹配到的字符串

    匹配以H开头以o结尾的任意长度字符串可以regex=^H.*o$,如下:

    regex=^H.*o$匹配到的字符串

    \b匹配这样一个位置:前面的字符和后面的字符不全是\w
    如果在“hello,hello1 hello hello1 bhello”这个字符串里匹配regex=hello\b,
    匹配到的结果如下:

    regex=hello\b匹配到的字符串

    分析一下:为什么hello1匹配不了“hello\b”这个正则?

    首先\b是一个定位字符,它是零宽的,标识一个位置,这个位置的前面和这个位置的后面不能全是\w,即不能全是字母数字和下划线[A-Za-z0-9_],而hello1的o与1之间的位置前面是o后面是1,前后全是\w,不符合\b匹配的含义,因此hello1不能匹配正则表达式“hello\b”

    但是bhello可以匹配“hello\b”这个正则,因为hello的结尾的位置,前面是o,后面是空白,所以符合\b匹配的含义,因此bhello可以匹配“hello\b”这个正则。

    自定义字符集合:
    方括号[ ]表示字符集合,即[ ]表示自定义集合,用[ ]可以匹配方括号里的任意一个字符。

    regex=[aeiou]匹配“a”,“e”,“i”,“o”,“u”任意一个字符,也就是可以匹配集合[aeiou]的任意一个字符。

    但是,特殊字符(除了小尖角“^和中划线“-)被包含到方括号中,就会失去特殊意义,只代表其字符本身。

    regex=[abc+?]匹配“a”,“b”,“c”任意一个字符或者“+”,“*”,“?”,即包含在自定义集合中的特殊字符“+”,“*”,“?”*失去了特殊含义,只表示其字符本身的意思。

    特殊字符小尖角“^”,原本含义是匹配字符串的开始位置,如果包含在自定义集合[ ]中,则表示取反的意思。
    比如:regex=[^aeiou]匹配“a”,“e”,“i”,“o”,“u”之外的任意一个字符。

    中划线“-”,在自定义集合[ ]中,表示“范围”,而不是字符“-”本身,regex=[a-z],匹配从a到z中26个字母的任意一个。

    除小数点“.”外,标准字符集合包含在方括号中,仍然表示集合范围。
    regex=[\d.+]匹配0-9的任意一个数字或者小数点“.”或者加号“+”

    也就是说\d在自定义集合中仍然表示数字,但是小数点在字符集合中只表示小数点本身,而不是除“\r\n”之外的任何单个字符。

    选择符和分组

    表达式作用
    pattern1|pattern2或的关系,匹配左边的pattern1或右边的pattern2
    (pattern)匹配pattern并获取这一匹配,并存储
    (?:pattern)匹配pattern但不获取匹配结果,也就是不进行存储

    regex=x|y,匹配字符x或y。

    ( )表示捕获组,( )的作用如下:
    1、括号中的表达式可以作为整体被修饰,用来表示匹配括号中表达式的次数,regex=(abc){2,3},可以匹配连续的2个或3个abc,如下:

    regex=(abc){2,3}匹配到的字符串

    2、括号中的表达式匹配到的内容会存储起来,并可以获取到括号中表达式匹配到的内容
    3、每一对括号会分配一个编号,使用( )的捕获根据左括号的顺序从1开始自动编号,编号为0的捕获是整个正则表达式匹配到的文本。

    捕获组( )可以把匹配的内容存储起来,那么如何获取( )捕获到的内容呢,下面介绍反向引用。

    反向引用“\number”
    每一对括号会分配一个编号,使用( )的捕获根据左括号的顺序从1开始自动编号。通过反向引用,可以对分组已捕获的字符串进行引用。
    “\number”中的number就是组号

    regex=(abc)d\1可以匹配字符串abcdabc,即\1表示把获取到的第一组再匹配一次,如下:

    regex=(abc)d\1匹配到的字符串

    (?:pattern)表示非捕获组,匹配括号中表达式匹配到的内容,但是不进行存储匹配到的内容。这在使用 "或" 字符?(|)?来组合一个正则的各个部分是很有用的。

    例如:匹配字符“story”或者“stories”,regex=stor(?:y|ies)就是一个比 regex=story|stories更简略的表达式。

    预搜索(零宽断言)
    预搜索,又叫零宽断言,又叫环视,它是对位置的匹配,与定位字符(边界字符)类似。

    表达式作用
    (?=pattern)断言此位置的后面能匹配表达式pattern
    (?<=pattern)断言此位置的前面能匹配表达式pattern
    (?!pattern)断言此位置的后面不能匹配表达式pattern
    (?<!pattern)断言此位置的前面不能匹配表达式pattern

    regex=love (?=story)匹配的结果如下(匹配“love?”后面是story):

    regex=love (?=story)匹配到的字符串

    regex=love (?!story)匹配的结果如下(匹配“love ”后面不能是story):

    regex=love (?!story)匹配到的字符串

    运算符的优先级
    正则表达式从左到右进行计算,并遵循优先级顺序,这与算术表达式非常类似。

    下表的优先级从高到低排序

    运算符描述
    \转义字符
    (), (?:), (?=), []圆括号和方括号,分组和自定义集合
    *, +, ?, {n}, {n,}, {n,m} 限定字符(量词)
    ^, $, 标准字符,字符定位字符(边界字符)和字符
    |

    说明:“|”或操作是优先级最低的,它比普通字符的优先级低。
    因此,regex=r|loom匹配“r”或“loom”,如下:

    regex=r|loom匹配到的字符串

    如果想匹配“room”或“loom”,请用括号创建子表达式,regex=(r|l)oom,如下:

    regex=(r|l)oom匹配到的字符串

    至此,正则表达式的语法介绍完了,大家是不是已经掌握了呢,赶快去体验一下吧。

    最后给大家介绍一下开发中使用正则表达式的流程:
    1、分析所要匹配的数据特点,模拟各种测试数据;
    2、利用正则工具,写正则表达式与测试数据进行匹配,从而验证你写的正则;
    3、在程序里调用在正则工具中验证通过的正则表达式。

    在这里给大家推荐一个正则工具“RegexBuddy”,你可以从网上下载,或者回复关键词“正则表达式”获取。



    作者:追梦人_奋斗青年
    链接:https://www.jianshu.com/p/059f8a66c28a
    来源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    转载于:https://www.cnblogs.com/yanzi-meng/p/10694904.html

    展开全文
  • 正则表达式

    2016-04-17 11:22:20
    正则表达式30分钟入门教程 版本:v2.21 (2007-8-3) 作者:deerchao 来源:unibetter大学生社区 转载请注明来源 目录 本文目标 如何使用本教程 正则表达式到底是什么? 入门 测试正则表达式 元字符 字符...

    正则表达式30分钟入门教程

    版本:v2.21 (2007-8-3) 作者:deerchao 来源:unibetter大学生社区 转载请注明来源

    目录

    1. 本文目标
    2. 如何使用本教程
    3. 正则表达式到底是什么?
    4. 入门
    5. 测试正则表达式
    6. 元字符
    7. 字符转义
    8. 重复
    9. 字符类
    10. 反义
    11. 替换
    12. 分组
    13. 后向引用
    14. 零宽断言
    15. 负向零宽断言
    16. 注释
    17. 贪婪与懒惰
    18. 处理选项
    19. 平衡组/递归匹配
    20. 还有些什么东西没提到
    21. 联系作者
    22. 一些我认为你可能已经知道的术语的参考
    23. 网上的资源及本文参考文献
    24. 更新说明

    本文目标

    30分钟内让你明白正则表达式是什么,并对它有一些基本的了解,让你可以在自己的程序或网页里使用它。

    如何使用本教程

    最重要的是——请给我30分钟,如果你没有使用正则表达式的经验,请不要试图在30内入门。当然,如果你是超人,那自然得另当别论。

    别被下面那些复杂的表达式吓倒,只要跟着我一步一步来,你会发现正则表达式其实并没有你想像中的那么困难。当然,如果你看完了这篇教程之后,发现自己明白了很多,却又几乎什么都记不得,那也是很正常的——我认为,没接触过正则表达式的人在看完这篇教程后,能把提到过的语法记住80%以上的可能性为零。这里只是让你明白基本的原理,以后你还需要多练习,多使用,才能熟练掌握正则表达式。

    除了作为入门教程之外,本文还试图成为可以在日常工作中使用的正则表达式语法参考手册。就作者本人的经历来说,这个目标还是完成得不错的——你看,我自己也没能把所有的东西记下来,不是吗?

    文本格式约定:专业术语 元字符/语法格式 正则表达式 正则表达式中的一部分(用于分析) 用于在其中搜索的字符串 对正则表达式或其中一部分的说明清除格式

    正则表达式到底是什么?

    在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。

    很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard),也就是*?。如果你想查找某个目录下的所有的Word文档的话,你会搜索*.doc。在这里,*会被解释成任意的字符串。和通配符类似,正则表达式也是用来进行文本匹配的工具,只不过比起通配符,它能更精确地描述你的需求——当然,代价就是更复杂——比如你可以编写一个正则表达式,用来查找所有以0开头,后面跟着2-3个数字,然后是一个连字号“-”,最后是7或8位数字的字符串(像010-123456780376-7654321)。

    正则表达式是用于进行文本匹配的工具,所以本文里多次提到了在字符串里搜索/查找,这种说法的意思是在给定的字符串中,寻找与给定的正则表达式相匹配的部分。有可能字符串里有不止一个部分满足给定的正则表达式,这时每一个这样的部分被称为一个匹配。匹配在本文里可能会有三种意思:一种是形容词性的,比如说一个字符串匹配一个表达式;一种是动词性的,比如说在字符串里匹配正则表达式;还有一种是名词性的,就是刚刚说到的“字符串中满足给定的正则表达式的一部分”。

    入门

    学习正则表达式的最好方法是从例子开始,理解例子之后再自己对例子进行修改,实验。下面给出了不少简单的例子,并对它们作了详细的说明。

    假设你在一篇英文小说里查找hi,你可以使用正则表达式hi

    这是最简单的正则表达式了,它可以精确匹配这样的字符串:由两个字符组成,前一个字符是h,后一个是i。通常,处理正则表达式的工具会提供一个忽略大小写的选项,如果选中了这个选项,它可以匹配hi,HI,Hi,hI这四种情况中的任意一种。

    不幸的是,很多单词里包含hi这两个连续的字符,比如him,history,high等等。用hi来查找的话,这里边的hi也会被找出来。如果要精确地查找hi这个单词的话,我们应该使用\bhi\b

    \b是正则表达式规定的一个特殊代码(好吧,某些人叫它元字符,metacharacter),代表着单词的开头或结尾,也就是单词的分界处。虽然通常英文的单词是由空格或标点符号或换行来分隔的,但是\b并不匹配这些单词分隔符中的任何一个,它只匹配一个位置。(如果需要更精确的说法,\b匹配这样的位置:它的前一个字符和后一个字符不全是(一个是,一个不是或不存在)\w

    假如你要找的是hi后面不远处跟着一个Lucy,你应该用\bhi\b.*\bLucy\b

    这里,.是另一个元字符,匹配除了换行符以外的任意字符*同样是元字符,不过它代表的不是字符,也不是位置,而是数量——它指定*前边的内容可以连续重复出现任意次以使整个表达式得到匹配。因此,.*连在一起就意味着任意数量的不包含换行的字符。现在\bhi\b.*\bLucy\b的意思就很明显了:先是一个单词hi,然后是任意个任意字符(但不能是换行),最后是Lucy这个单词

    如果同时使用其它的一些元字符,我们就能构造出功能更强大的正则表达式。比如下面这个例子:

    0\d\d-\d\d\d\d\d\d\d\d匹配这样的字符串:以0开头,然后是两个数字,然后是一个连字号“-”,最后是8个数字(也就是中国的电话号码。当然,这个例子只能匹配区号为3位的情形)。

    这里的\d是一个新的元字符,匹配任意的数字(0,或1,或2,或……)-不是元字符,只匹配它本身——连字号。

    为了避免那么多烦人的重复,我们也可以这样写这个表达式:0\d{2}-\d{8}。 这里\d后面的{2}({8})的意思是前面\d必须连续重复匹配2次(8次)

    测试正则表达式

    如果你不觉得正则表达式很难读写的话,要么你是一个天才,要么,你不是地球人。正则表达式的语法很令人头疼,即使对经常使用它的人来说也是如此。由于难于读写,容易出错,所以很有必要创建一种工具来测试正则表达式。

    由于在不同的环境下正则表达式的一些细节是不相同的,本教程介绍的是Microsoft .Net 2.0下正则表达式的行为,所以,我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0,然后下载Regex Tester。这是个绿色软件,下载完后打开压缩包,直接运行RegexTester.exe就可以了。

    下面是Regex Tester运行时的截图:

    Regex Tester运行时的截图

    元字符

    现在你已经知道几个很有用的元字符了,如\b,.,*,还有\d.当然还有更多的元字符可用,比如\s匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格等\w匹配字母或数字或下划线或汉字等

    下面来试试更多的例子:

    \ba\w*\b匹配以字母a开头的单词——先是某个单词开始处(\b),然后是字母a,然后是任意数量的字母或数字(\w*),最后是单词结束处(\b)(好吧,现在我们说说正则表达式里的单词是什么意思吧:就是几个连续的\w。不错,这与学习英文时要背的成千上万个同名的东西的确关系不大)。

    \d+匹配1个或更多连续的数字。这里的+是和*类似的元字符,不同的是*匹配重复任意次(可能是0次),而+则匹配重复1次或更多次

    \b\w{6}\b 匹配刚好6个字母/数字的单词

    表1.常用的元字符
    代码说明
    .匹配除换行符以外的任意字符
    \w匹配字母或数字或下划线或汉字
    \s匹配任意的空白符
    \d匹配数字
    \b匹配单词的开始或结束
    ^匹配字符串的开始
    $匹配字符串的结束

    元字符^(和数字6在同一个键位上的符号)以及$\b有点类似,都匹配一个位置。^匹配你要用来查找的字符串的开头,$匹配结尾。这两个代码在验证输入的内容时非常有用,比如一个网站如果要求你填写的QQ号必须为5位到12位数字时,可以使用:^\d{5,12}$

    这里的{5,12}和前面介绍过的{2}是类似的,只不过{2}匹配只能不多不少重复2次{5,12}则是重复的次数不能少于5次,不能多于12次,否则都不匹配。

    因为使用了^$,所以输入的整个字符串都要用来和\d{5,12}来匹配,也就是说整个输入必须是5到12个数字,因此如果输入的QQ号能匹配这个正则表达式的话,那就符合要求了。

    和忽略大小写的选项类似,有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项,^$的意义就变成了匹配行的开始处和结束处

    字符转义

    如果你想查找元字符本身的话,比如你查找.,或者*,就出现了问题:你没法指定它们,因为它们会被解释成其它的意思。这时你就必须使用\来取消这些字符的特殊意义。因此,你应该使用\.\*。当然,要查找\本身,你也得用\\.

    例如:www\.unibetter\.com匹配www.unibetter.comc:\\Windows匹配c:\Windows

    重复

    你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码,例如*,{5,12}等):

    表2.常用的限定符
    代码/语法说明
    *重复零次或更多次
    +重复一次或更多次
    ?重复零次或一次
    {n}重复n次
    {n,}重复n次或更多次
    {n,m}重复n到m次

    下面是一些使用重复的例子:

    Windows\d+匹配Windows后面跟1个或更多数字

    13\d{9}匹配13后面跟9个数字(中国的手机号)

    ^\w+匹配一行的第一个单词(或整个字符串的第一个单词,具体匹配哪个意思得看选项设置)

    字符类

    要想查找数字,字母或数字,空白是很简单的,因为已经有了对应这些字符集合的元字符,但是如果你想匹配没有预定义元字符的字符集合(比如元音字母a,e,i,o,u),应该怎么办?

    很简单,你只需要在中括号里列出它们就行了,像[aeiou]就匹配任何一个英文元音字母[.?!]匹配标点符号(.或?或!)(英文语句通常只以这三个标点结束)。

    我们也可以轻松地指定一个字符范围,像[0-9]代表的含意与\d就是完全一致的:一位数字,同理[a-z0-9A-Z_]也完全等同于\w(如果只考虑英文的话)。

    下面是一个更复杂的表达式:\(?0\d{2}[) -]?\d{8}

    这个表达式可以匹配几种格式的电话号码,像(010)88886666,或022-22334455,或02912345678等。我们对它进行一些分析吧:首先是一个转义字符\(,它能出现0次或1次(?),然后是一个0,后面跟着2个数字(\d{2}),然后是)-空格中的一个,它出现1次或不出现(?),最后是8个数字(\d{8})。不幸的是,它也能匹配010)12345678(022-87654321这样的“不正确”的格式。要解决这个问题,请在本教程的下面查找答案。

    反义

    有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外,其它任意字符都行的情况,这时需要用到反义

    表3.常用的反义代码
    代码/语法说明
    \W匹配任意不是字母,数字,下划线,汉字的字符
    \S匹配任意不是空白符的字符
    \D匹配任意非数字的字符
    \B匹配不是单词开头或结束的位置
    [^x]匹配除了x以外的任意字符
    [^aeiou]匹配除了aeiou这几个字母以外的任意字符

    例子:\S+匹配不包含空白符的字符串

    <a[^>]+>匹配用尖括号括起来的以a开头的字符串

    替换

    好了,现在终于到了解决3位或4位区号问题的时间了。正则表达式里的替换指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,具体方法是用|把不同的规则分隔开。听不明白?没关系,看例子:

    0\d{2}-\d{8}|0\d{3}-\d{7}这个表达式能匹配两种以连字号分隔的电话号码:一种是三位区号,8位本地号(如010-12345678),一种是4位区号,7位本地号(0376-2233445)

    \(0\d{2}\)[- ]?\d{8}|0\d{2}[- ]?\d{8}这个表达式匹配3位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号与本地号间可以用连字号或空格间隔,也可以没有间隔。你可以试试用替换|把这个表达式扩展成也支持4位区号的。

    \d{5}-\d{4}|\d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字,或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题:使用替换时,顺序是很重要的。如果你把它改成\d{5}|\d{5}-\d{4}的话,那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配替换时,将会从左到右地测试每个分枝条件,如果满足了某个分枝的话,就不会去管其它的替换条件了。

    Windows98|Windows2000|WindosXP这个例子是为了告诉你替换不仅仅能用于两种规则,也能用于更多种规则。

    分组

    我们已经提到了怎么重复单个字符(直接在字符后面加上限定符就行了);但如果想要重复多个字符又该怎么办?你可以用小括号来指定子表达式(也叫做分组),然后你就可以指定这个子表达式的重复次数了,你也可以对子表达式进行其它一些操作(后面会有介绍)。

    (\d{1,3}\.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式,请按下列顺序分析它:\d{1,3}匹配1到3位的数字(\d{1,3}\.}{3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(\d{1,3})。

    不幸的是,它也将匹配256.300.888.999这种不可能存在的IP地址(IP地址中每个数字都不能大于255。题外话,好像反恐24小时第三季的编剧不知道这一点,汗...)。如果能使用算术比较的话,或许能简单地解决这个问题,但是正则表达式中并不提供关于数学的任何功能,所以只能使用冗长的分组,选择,字符类来描述一个正确的IP地址:((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)

    理解这个表达式的关键是理解2[0-4]\d|25[0-5]|[01]?\d\d?,这里我就不细说了,你自己应该能分析得出来它的意义。

    后向引用

    使用小括号指定一个子表达式后,匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下,每个分组会自动拥有一个组号,规则是:从左向右,以分组的左括号为标志,第一个出现的分组的组号为1,第二个为2,以此类推。

    后向引用用于重复搜索前面某个分组匹配的文本。例如,\1代表分组1匹配的文本。难以理解?请看示例:

    \b(\w+)\b\s+\1\b可以用来匹配重复的单词,像go go, kitty kitty。首先是一个单词,也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b),然后是1个或几个空白符(\s+),最后是前面匹配的那个单词(\1)。

    你也可以自己指定子表达式的组名。要指定一个子表达式的组名,请使用这样的语法:(?<Word>\w+)(或者把尖括号换成'也行:(?'Word'\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容,你可以使用\k<Word>,所以上一个例子也可以写成这样:\b(?<Word>\w+)\b\s+\k<Word>\b

    使用小括号的时候,还有很多特定用途的语法。下面列出了最常用的一些:

    表4.分组语法
    捕获
    (exp)匹配exp,并捕获文本到自动命名的组里
    (?<name>exp)匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name'exp)
    (?:exp)匹配exp,不捕获匹配的文本,也不给此分组分配组号
    零宽断言
    (?=exp)匹配exp前面的位置
    (?<=exp)匹配exp后面的位置
    (?!exp)匹配后面跟的不是exp的位置
    (?<!exp)匹配前面不是exp的位置
    注释
    (?#comment)这种类型的组不对正则表达式的处理产生任何影响,用于提供注释让人阅读

    我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式,只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面

    零宽断言

    接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西,也就是说它们像\b,^,$那样用于指定一个位置,这个位置应该满足一定的条件(断言),因此它们也被称为零宽断言。最好还是拿例子来说明吧:

    (?=exp)也叫零宽度正预测先行断言,它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b),匹配以ing结尾的单词的前面部分(除了ing以外的部分),如查找I'm singing while you're dancing.时,它会匹配singdanc

    (?<=exp)也叫零宽度正回顾后发断言,它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分),例如在查找reading a book时,它匹配ading

    假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了),你可以这样查找需要在前面和里面添加逗号的部分:((?<=\d)\d{3})*\b,用它对1234567890进行查找时结果是234567890

    下面这个例子同时使用了这两种断言:(?<=\s)\d+(?=\s)匹配以空白符间隔的数字(再次强调,不包括这些空白符)

    负向零宽断言

    前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现,但并不想去匹配它时怎么办?例如,如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样:

    \b\w*q[^u]\w*\b匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐,直接就观察出来了),你会发现,如果q出现在单词的结尾的话,像Iraq,Benq,这个表达式就会出错。这是因为[^u]总要匹配一个字符,所以如果q是单词的最后一个字符的话,后面的[^u]将会匹配q后面的单词分隔符(可能是空格,或者是句号或其它的什么),后面的\w*\b将会匹配下一个单词,于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting负向零宽断言能解决这样的问题,因为它只匹配一个位置,并不消费任何字符。现在,我们可以这样来解决这个问题:\b\w*q(?!u)\w*\b

    零宽度负预测先行断言(?!exp)断言此位置的后面不能匹配表达式exp。例如:\d{3}(?!\d)匹配三位数字,而且这三位数字的后面不能是数字\b((?!abc)\w)+\b匹配不包含连续字符串abc的单词

    同理,我们可以用(?<!exp),零宽度正回顾后发断言断言此位置的前面不能匹配表达式exp(?<![a-z])\d{7}匹配前面不是小写字母的七位数字

    一个更复杂的例子:(?<=<(\w+)>).*(?=<\/\1>)匹配不包含属性的简单HTML标签内里的内容(<?(\w+)>)指定了这样的前缀被尖括号括起来的单词(比如可能是<b>),然后是.*(任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/,它用到了前面提过的字符转义;\1则是一个反向引用,引用的正是捕获的第一组,前面的(\w+)匹配的内容,这样如果前缀实际上是<b>的话,后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒,不包括前缀和后缀本身)。

    注释

    小括号的另一种用途是能过语法(?#comment)来包含注释。例如:2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)

    要包含注释的话,最好是启用“忽略模式里的空白符”选项,这样在编写表达式时能任意的添加空格,Tab,换行,而实际使用时这些都将被忽略。启用这个选项后,在#后面到这一行结束的所有文本都将被当成注释忽略掉。

    例如,我们可以前面的一个表达式写成这样:

          (?<=    # 断言要匹配的文本的前缀
          <(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
          )       # 前缀结束
          .*      # 匹配任意文本
          (?=     # 断言要匹配的文本的后缀
          <\/\1>  # 查找尖括号括起来的内容:前面是一个"/",后面是先前捕获的标签
          )       # 后缀结束
        

    贪婪与懒惰

    当正则表达式中包含能接受重复的限定符时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符。考虑这个表达式:a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。

    有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧:

    a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aabab(为什么第一个匹配是aab而不是ab?简单地说,因为正则表达式有另一条规则,比懒惰/贪婪规则的优先级更高:最先开始的匹配最有最大的优先权——The Match That Begins Earliest Wins)。

    表5.懒惰限定符
    *?重复任意次,但尽可能少重复
    +?重复1次或更多次,但尽可能少重复
    ??重复0次或1次,但尽可能少重复
    {n,m}?重复n到m次,但尽可能少重复
    {n,}?重复n次以上,但尽可能少重复

    处理选项

    上面介绍了几个选项如忽略大小写,处理多行等,这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项:

    表6.常用的处理选项
    名称说明
    IgnoreCase(忽略大小写)匹配时不区分大小写。
    Multiline(多行模式)更改^$的含义,使它们分别在任意一行的行首和行尾匹配,而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配\n之前的位置以及字符串结束前的位置.)
    Singleline(单行模式)更改.的含义,使它与每一个字符匹配(包括换行符\n)。
    IgnorePatternWhitespace(忽略空白)忽略表达式中的非转义空白并启用由#标记的注释。
    RightToLeft(从右向左查找)匹配从右向左而不是从左向右进行。
    ExplicitCapture(显式捕获)仅捕获已被显式命名的组。
    ECMAScript(JavaScript兼容模式)使表达式的行为与它在JavaScript里的行为一致。

    一个经常被问到的问题是:是不是只能同时使用多行模式和单行模式中的一种?答案是:不是。这两个选项之间没有任何关系,除了它们的名字比较相似(以至于让人感到疑惑)以外。

    平衡组/递归匹配

    注意:这里介绍的平衡组语法是由.Net Framework支持的;其它语言/库不一定支持这种功能,或者支持此功能但需要使用不同的语法。

    有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构,这时简单地使用\(.+\)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式,懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等,比如( 5 / ( 3 + 2 ) ) ),那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的,配对的括号之间的内容呢?

    为了避免(\(把你的大脑彻底搞糊涂,我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx < aa <bbb> <bbb> aa> yy这样的字符串里,最长的配对的尖括号内的内容捕获出来?

    这里需要用到以下的语法构造:

    • (?'group') 把捕获的内容命名为group,并压入堆栈
    • (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容,如果堆栈本来为空,则本分组的匹配失败
    • (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话,继续匹配yes部分的表达式,否则继续匹配no部分
    • (?!) 零宽负向先行断言,由于没有后缀表达式,试图匹配总是失败

    如果你不是一个程序员(或者你是一个对堆栈的概念不熟的程序员),你就这样理解上面的三种语法吧:第一个就是在黑板上写一个 "group",第二个就是从黑板上擦掉一个"group",第三个就是看黑板上写的还有没有"group",如果有就继续匹配yes部分,否则就匹配 no部分。

    我们需要做的是每碰到了左括号,就在黑板上写一个"group",每碰到一个右括号,就擦掉一个,到了最后就看看黑板上还有没有--如果有那就证明左括号比右括号多,那匹配就应该失败。

    <                         #最外层的左括号
        [^<>]*                #最外层的左括号后面的不是括号的内容
        (
            (
                (?'Open'<)    #碰到了左括号,在黑板上写一个"Open"
                [^<>]*       #匹配左括号后面的不是括号的内容
            )+
            (
                (?'-Open'>)   #碰到了右括号,擦掉一个"Open"
                [^<>]*        #匹配右括号后面不是括号的内容
            )+
        )*
        (?(Open)(?!))         #在遇到最外层的右括号前面,判断黑板上还有没有没擦掉的"Open";如果还有,则匹配失败
    >                         #最外层的右括号

    平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>.

    还有些什么东西没提到

    我已经描述了构造正则表达式的大量元素,还有一些我没有提到的东西。下面是未提到的元素的列表,包含语法和简单的说明。你可以在网上找到更详细的参考资料来学习它们--当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到关于.net下正则表达式详细的文档。

    表7.尚未详细讨论的语法
    \a报警字符(打印它的效果是电脑嘀一声)
    \b通常是单词分界位置,但如果在字符类里使用代表退格
    \t制表符,Tab
    \r回车
    \v竖向制表符
    \f换页符
    \n换行符
    \eEscape
    \0nnASCII代码中八进制代码为nn的字符
    \xnnASCII代码中十六进制代码为nn的字符
    \unnnnUnicode代码中十六进制代码为nnnn的字符
    \cNASCII控制字符。比如\cC代表Ctrl+C
    \A字符串开头(类似^,但不受处理多行选项的影响)
    \Z字符串结尾或行尾(不受处理多行选项的影响)
    \z字符串结尾(类似$,但不受处理多行选项的影响)
    \G当前搜索的开头
    \p{name}Unicode中命名为name的字符类,例如\p{IsGreek}
    (?>exp)贪婪子表达式
    (?<x>-<y>exp)平衡组
    (?im-nsx:exp)在子表达式exp中改变处理选项
    (?im-nsx)为表达式后面的部分改变处理选项
    (?(exp)yes|no)把exp当作零宽正向先行断言,如果在这个位置能匹配,使用yes作为此组的表达式;否则使用no
    (?(exp)yes)同上,只是使用空表达式作为no
    (?(name)yes|no)如果命名为name的组捕获到了内容,使用yes作为表达式;否则使用no
    (?(name)yes)同上,只是使用空表达式作为no

    联系作者

    好吧,我承认,我骗了你,读到这里你肯定花了不止30分钟.相信我,这是我的错,而不是因为你太笨.我之所以说"30分钟",是为了让你有信心,有耐心继续下去.既然你看到了这里,那证明我的阴谋成功了.上这种当的滋味还不错吧?

    要投诉我,或者觉得我其实可以做得更好,或者有任何其它问题,欢迎来我的博客进行讨论.

    一些我认为你可能已经知道的术语的参考

    字符
    程序处理文字时最基本的单位,可能是字母,数字,标点符号,空格,换行符,汉字等等。
    字符串
    0个或更多个字符的序列。
    文本
    文字,字符串。
    匹配
    符合规则,检验是否符合规则,符合规则的部分。
    断言
    声明一个应该为真的事实。只有当断言为真时才会对正则表达式继续进行匹配。

    网上的资源及本文参考文献

    更新说明

    1. 2006-3-27 第一版
    2. 2006-10-12 第二版
      • 修正了几个细节上的错误和不准确的地方
      • 增加了对处理中文时的一些说明
      • 更改了几个术语的翻译(采用了MSDN的翻译方式)
      • 增加了平衡组的介绍
      • 放弃了对The Regulator的介绍,改用Regex Tester
    3. 2007-3-12 V2.1
      • 修正了几个小的错误
      • 增加了对处理选项(RegexOptions)的介绍
    4. 2007-5-28 V2.2
      • 重新组织了对零宽断言的介绍
      • 删除了几个不太合适的示例,添加了几个实用的示例
      • 其它一些微小的更改
    5. 2007-8-3 V2.21
      • 修改了几处文字错误
      • 修改/添加了对$,\b的精确说明
      • 承认了作者是个骗子
      • 给RegexTester添加了Singleline选项的相关功能 
    展开全文
  • 1小时学会正则表达式

    2014-09-01 14:30:00
    正则表达式是一种查找以及字符串替换操作。正则表达式在文本编辑器中广泛使用,比如正则表达式被用于: 检查文本中是否含有指定的特征词 找出文中匹配特征词的位置 从文本中提取信息,比如:字符串的子串 修改...
  • js 正则表达式

    2019-01-08 02:35:53
    正则表达式 关键字:正则表达式 模式匹配 Javascript 摘要:收集一些常用的正则表达式正则表达式用于字符串处理,表单验证等场合,实用高效,但用到时总是不太把握,以致往往要上网查一番。我将一些常用的表达式...
  • 正则表达式 简介

    千次阅读 2013-08-02 15:41:13
    在很多文本编辑器或其他工具里,正则表达式通常被用来检索和/或替换那些符合某个模式的文本内容。许多程序设计语言都支持利用正则表达式进行字符串操作。例如,在Perl中就内建了一个功能强大的正则表达式引擎。正则...
  • 正则表达式学习笔记

    2021-08-29 22:04:48
    1 正则表达式入门 ​ Web上搜索单词满足: 同时检查多文件和多行,对应单词高亮 跨行查找,存在换行的情况 不区分大小写,单词间出现任意数量空白符(空格符、制表符、换行符) HTML tag分隔的字符 正则...
  • ——————·今天距2021年还有315天·——————这是ITester软件测试小栈第97次推文对于正则表达式,第一眼时觉得完全没有规律可寻,而且全是一堆各种各样的特殊符号,完全不知所...
  • 正则表达式教程

    2017-07-19 09:02:00
    正则表达式30分钟入门教程 目录 本文目标 如何使用本教程 正则表达式到底是什么? 入门 测试正则表达式 元字符 字符转义 重复 字符类 反义 替换 分组 后向引用 零宽断言 负向零宽断言 注释 ...
  • 正则表达式文档学习及练习 正则表达式文档学习及练习 字符 捕捉和替换 使用正则表达式编程 其他建议 总结 最近在做爬虫,一直很头疼正则表达式,不会写也不会认,这次终于下定决心来学习一下,并做一下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,417
精华内容 8,966
关键字:

自动时间小时正则表达式