您现在的位置是：主页 > news > 网站使用网络图片做素材 侵权/推客平台

网站使用网络图片做素材 侵权/推客平台

admin2025/6/4 2:09:25【news】

简介网站使用网络图片做素材 侵权,推客平台,产品设计在线,大连企业网站建设模板正则一直都没有好好学习过，每次做输入框验证，都到处找正则。今天就学习一下，以后不要在到处找了。大部分是在网上找的资料，加上自己的理解。有不对的地方，请一定帮忙指出来。 参考资料：www.cnblogs.com/rub…

网站使用网络图片做素材 侵权,推客平台,产品设计在线,大连企业网站建设模板正则一直都没有好好学习过，每次做输入框验证，都到处找正则。今天就学习一下，以后不要在到处找了。大部分是在网上找的资料，加上自己的理解。有不对的地方，请一定帮忙指出来。 参考资料：www.cnblogs.com/rub…

正则一直都没有好好学习过，每次做输入框验证，都到处找正则。今天就学习一下，以后不要在到处找了。
大部分是在网上找的资料，加上自己的理解。有不对的地方，请一定帮忙指出来。
参考资料：www.cnblogs.com/rubylouvre/… 和 MDN。

创建一个正则表达式

  let regex = /pattern/flags;
复制代码

其中的模式(pattern)部分就是各种各样的正则表达式，可以包含字符类、限定类、分组、向前查找一级反向引用。每个正则表达式都可带有一个或多个标志(flags)，用来表明正则表达式的行为。正则表达式的匹配模式支持下列3个标志。

正则表达式中的标志

  • g : 表示全局模式(global),模式将被应用于所有字符串，而不是在发现第一个匹配项时立即停止。
  • i : 表示不区分大小写模式，在确定匹配项时，会忽略大小写。
  • m : 表示多行模式，在到达一行文本末尾时，继续查找下一行。

一个正则表达式就是一个模式与以上三个标志的组合体。

正则表达式的模式。

  • 简单模式
    简单模式就是要查找的字符直接匹配的。
    /abc/这个模式就匹配了一个字符串中，abc同时出现并按照这个顺序。
let regex = /abc/;
regex.test('ahkbcjjkabnc');  // false; 没有匹配到
regex.test('abcaaalkjlkjlacjabc'); // true; 有匹配到
"abaaakjljabc".replace(regex, 'love'); // abaaakjljlove;  把匹配到的字符串'abc'替换为 'love';
"aaabcaldjflj".search(regex) // 2  返回第一次匹配到的索引。没有匹配到返回 -1;
复制代码
  • 使用特殊字符
    如果需要搜索的条件比较复杂时，就要用到特殊字符。\

字符类

  1. 简单类。
    原则上正则的一个字符对应一个字符，可以用[]把它们括起来，让[]这个整体对应一个字符。
let reg = /[abc]/;
reg.test('a'); // true;
reg.test('c'); // true;
reg.test('ab'); // true;
reg.test('ac'); // true;
reg.test('ag'); // true;
reg.test('e'); // false;
复制代码
  1. 负向类
    在[]里，前面加个 ^元字符进行取反，表示匹配不能为[]里的字符。
let reg = /[^abc]/;
reg.test('a'); // false;
reg.test('ab'); // false;
reg.test('ag'); // true;   只要有一个字符不在 [] 里就返回 true；
复制代码
  1. 范围类
    在 []里，有时匹配的东西过多，而且类型都一样，就可以使用-符号，表示一个范围。
let reg1 = /[a-d]/;
reg1.test('c'); // true;
reg1.test('e'); // false;
reg1.test('A'); // false;let reg2 = /[A-Z]/;
reg2.test('a');     // false;
reg2.test('FGH');   // true;let reg3 = /[1-8]/;
reg3.test(0);       // false;
reg3.test(456);     // true;
reg3.test(456.7);   // true;let reg4 = /[^4-8]/;
reg4.test(3); // true;
reg4.test(6); // false;
复制代码
  1. 预定义类\
字符等同于描述
. [^\n\r] 除了换行和回车之外的任意字符
\d[0-9]数字字符
\D[^0-9]非数字字符
\s[ \t\n\xOB\f\r]空白字符(注意是' ', 而不是 '')
\S[^ \t\n\xOB\f\r]非空白字符
\w[a-zA-Z_0-9]单词字符
\W[^a-zA-Z_0-9]非单词字符
console.log(/\d/.test("3"))  // true;
console.log(/\d/.test("a"))  // false;
console.log(/\D/.test("a"))  // true;
console.log(/\D/.test("2"))  // false;
console.log(/\s/.test(" "))  // true;
console.log(/\s/.test(""))   // false;
console.log(/\s/.test("a"))  // false;
console.log(/\S/.test(" "))  // false;
console.log(/\S/.test(""))   // false;
console.log(/\S/.test("a"))  // true;
console.log(/\w/.test("d"))  // true;
console.log(/\w/.test("9"))   // true;
console.log(/\w/.test("!"))  // false;
console.log(/\W/.test("!"))  // true;
console.log(/\W/.test("@"))  // true;
console.log(/\W/.test("a"))  // false;
复制代码

量词

由于元字符、特殊字符、或者字符类组合都是一对一进行匹配。有的时候需要匹配多次。这个时候就要用到量词了。

代码类型描述
?软性量词出现 0 次或 1 次
*软性量词出现 0 次或多次（任意次）
+软性量词出现一次或多次（至少一次）
{n}硬性量词对应 n 次
{n, m}软性量词至少 n 次但不超过m 次
{n,}软性量词至少出现 n 次
``` javascript
console.log(/啊?/.test(''));        // true;
console.log(/啊?/.test('啊'));      // true;
'啊啊'.replace(/啊?/, '哈');        // 哈啊; // 只会匹配第一个满足条件的字符。console.log(/啊*/.test('啊'));      // true;
console.log(/啊*/.test('就了解了解'));      // true;
'啊啊'.replace(/啊*/, '哈');       // 哈  匹配到所有的 啊（全部），然后替换为 哈（一个）。console.log(/啊+/.test('拉进来看见了就'))   // false;
console.log(/啊+/.test('啊哈哈哈路径栏'))   // true;
'啊哈哈哈啊啊，啊哦哦'.replace(/啊+/, '不')  // "不哈哈哈啊啊，啊哦哦" 匹配到第一个 啊 ，替换为 不。console.log(/啊{3}/.test('拉进来看见了就'))   // false;
console.log(/啊{3}/.test('啊啊哦哦哦哦哦哦')) // false;
console.log(/啊{3}/.test('啊啊哦哦哦哦哦哦啊')) // false;
console.log(/啊{3}/.test('啊啊哦哦哦哦哦哦啊啊啊'))  // true; 必须是连续的。
'哦哦啊啊啊哈哈哈'.replace(/啊{3}/, '哦');  // "哦哦哦哈哈哈"  匹配到 '啊啊啊', 然后替换为 '哦';
'哦哦啊啊啊哈哈哈'.replace(/啊/g, '哦');    // "哦哦哦哦哦哈哈哈"  每一个'啊' 都替换为 '哦';console.log(/啊{2,5}/.test('啊哈哈哈哈哈哈'))  // false;
console.log(/啊{2,5}/.test('啊哈哈哈哈哈哈啊')) // false;
console.log(/啊{2,5}/.test('啊啊哈哈哈哈哈哈啊')) // true;
console.log(/啊{2,5}/.test('啊啊啊啊啊啊啊哈哈哈哈哈哈啊')) // true; 虽然超过了 5 个，但是还是返回 true; 这个时候匹配到的是前面 5 个 '啊'。
'啊啊啊啊啊啊啊哈哈哈哈哈哈啊'.replace(/啊{2,5}/, '哈'); // "哈啊啊哈哈哈哈哈哈啊" 匹配了5个'啊'，替换为'哈';console.log(/啊{3,}/.test('啊哈哈哈哈哈哈'))  // false;
console.log(/啊{3,}/.test('啊哈哈哈哈哈哈啊啊啊'))  // true;
'啊啊啊啊啊啊啊哈哈哈哈哈哈啊'.replace(/啊{3,}/, '哈');  // "哈哈哈哈哈哈哈啊"/[\u4e00-\u9fa5]/用于匹配单个汉字。
console.log(/[\u4e00-\u9fa5]/.test('a')); //  false;
console.log(/[\u4e00-\u9fa5]/.test('啊a')); // true;
console.log(/[\u4e00-\u9fa5]/.test('34')); //  false;
```
复制代码

量词分为 贪婪量词与惰性量词。

  • 贪婪量词
    先看整个字符串是不是一个匹配。如果没有发现匹配，它去掉最后字符串中的最后一个字符，并再次尝试。如果还是没有发现匹配，那么 再次去掉最后一个字符串，这个过程会一直重复直到发现一个匹配或者字符串不剩任何字符。简单量词都是贪婪量词。
  • 惰性量词 先看字符串中的第一个字母是不是一个匹配，如果单独着一个字符还不够，就读入下一个字符，组成两个字符的字符串。如果还没有发现匹配，惰性量词继续从字符串中添加字符直到发现一个匹配或者整个字符串都检查过也没有匹配。惰性量词和贪婪量词的工作方式恰好相反。

分组

上面介绍的都是单字符匹配，量词虽然可以帮我们处理一排紧密相连的同类型字符，但这远远不够。下面介绍一下小括号。 小括号允许重复多个字符，中括号表示范围内选择，大括号表示重复次数。

字符： (x)。

let reg = /(sky)+/;
reg.test('lkjljskjjiuy');  // false
reg.test('skyjkjlsky');    // true;
复制代码

反向引用

正则表达式捕获组匹配的字符串，可以用编号进行标识，并通过 "\编号"进行引用。
有 九个 用来存储捕获组的构造函数属性。访问这些属性的语法是： RegExp.$1、RegExp.$2.....RegExp.$9，分别用来存储第一、第二......第九个匹配的捕获组。在调用test()、exec()方法时，这些属性会自动填充。

let text = "this has been a short summer";
let reg = /(..)or(.)/g;if (reg.test(text)) {console.log(RegExp.$1);  //  shconsole.log(RegExp.$2);  //  t 
}
复制代码

上面创建了一个包含两个捕获组的模式，然后用该模式测试了一个字符串，尽管test()方法只返回了true，但RegExp构造函数的属性$1、$2也会被匹配相应捕获组的字符串自动填充。

字符：\n。
n是一个正整数，一个反向引用，指向正则表达式中第n个括号(从左往右)中匹配的字符串。

let reg = /abc(de)(fg)\1/; 相当于： /abc(de)(fg)(de)/;
reg.test('abcdefg');   // false
reg.test('abcdefgde');   // true
复制代码

候选

在分组中插入|管道符，可以划分多个候选项。

let reg = /(red|yellow|green)\?/;
reg.test('bloackred');  // false;
reg.test('bloackred?');  // true;
reg.test('yellow?');    // true;
reg.test('green?');     // true;
复制代码

非捕获分组

并不是所有的分组都能创建反向引用（也就是创建捕获组）。要创建一个非捕获性分组，只要在分组的左括号的后面加一个问号?与冒号:。字符(?:x);

let text = "this has been a short summer";
let reg = /(?:..)or(?:.)/g;if (reg.test(text)) {console.log(RegExp.$1);  //  ''; 非捕获组。
}
复制代码

查找

  • 正向肯定查找
    用来检查接下来出现的是不是某个特定的字符集。
    字符：x(?=y)。
let reg = /我的天(?=空)/;
reg.test('这是我的天空');  // true
reg.test('哦！我的天啊');  // false;
'我的天下'.replace(reg, '啊啊');  // "我的天下"。 并没有匹配到，所以就没有替换。
'我的天空为何'.replace(reg, '阿');  // "阿空为何"
复制代码
  • 正向否定查找
    用来检查接下来不应该出现的字符集。
    字符：x(?!y)。
let reg = /abc(?!de)/;
reg.test('abcdefg');  // false;
reg.test('abcd');  // true;
reg.test('abcabc');   // true;
复制代码

边界

一个要与字符类合用的东西。

正则名称描述
^开头注意不能紧跟在[中括号的后面。
$结尾
\b单词边界指[a-zA-Z_o-9]之外的字符。匹配一个零宽单词边界，如一个字母与一个空格之间。
\B非单词边界

边界详解

  • 单词边界(\b)
    匹配一个零宽单词边界，如一个字母与一个空格之间。

    let reg1 = /\bde/;
reg.test('abcde');  // false;
reg.test('abc de');  // true;
reg.test('abc&de');  // true;let reg2 = /fg\b/;
reg2.test('abcdefg');  // true;
reg2.test('abcdefghh');  // false;
reg2.test('abcdefg#');  // true;
复制代码

  • 非单词边界(\B)
    匹配一个零宽非单词边界，如两个字母之间，或两个空格之间。

    let reg1 = /\Bde/;
reg.test('abcdefg');   // true;
reg.test('abc defg');  // false;
reg.test('abc&defg'); // false;
reg.test('abc de fg');  // false;let reg2 = /de\B/;
reg2.test('abcdefg');  // true;
reg2.test('abcde');    // false;
reg2.test('abcde&fg');  // false;
复制代码

    一些常用的正则总结

    • 正整数

    验证规则：
    1、允许0
    2、不允许01、02...

    reg = /^[1-9]\d*|0$/;
console.log('02');   // false;
console.log(02);     // true;  因为程序在处理的时候，把02作为2进行处理，所以会返回true。需要先转为字符串。
复制代码
    • 手机号码

    验证规则：
    1、11位数字
    2、以1开头

    reg = /^1\d{10}$/;
复制代码
    • 电话号码

    验证规则
    1、区号 + 号码
    2、区号以 0 开头，3位或4位
    3、号码由7位或8位数字组成
    4、区号与号码之间可以无连接符，也可以“-”连接

    reg =  /^0\d{2,3}-?\d{7,8}$/;
复制代码

转载于:https://juejin.im/post/5b46bfd6f265da0f5e32d156

相关文章

最新文章