1、创建对象

    1. var reg = /xinlang/;
    2.     var str = 'xinlangasdfasdf';
    3.     // 检验字符串是否匹配正则表达式,用test
    4.     var boo = reg.test(str);
    5.     console.log('boo', boo); // true
    7.     // 2.方式2: 使用构造函数方式创建正则对象
    8.     var reg2 = new RegExp('zhanghuan');
    9.     var str = 'asdfasdfzhanghuanasdfasdf';
    10.     var boo2 = reg2.test(str);
    11.     console.log('boo2', boo2); //
    13.     // 3.正则表达式参数g-全局匹配,i-忽略大小写,m-多行匹配
    14.     var reg3 = /zhanGsan/gi;
    15.     // var reg3 = new RegExp('zhangsan','g');
    16.     var str3 = '111111111zhangsan222222zhangsan333333zhangsan';
    17.     var newStr3 = str3.replace(reg3, '张三');
    18.     console.log('newStr3', newStr3);

    2、常见匹配规则

    1.  var log = function() {
    2.         var len = arguments.length;
    3.         if (len === 1) {
    4.             console.log(arguments[0])
    5.         } else if (len === 2) {
    6.             console.log(arguments[0], arguments[1]);
    7.         } else {
    8.             console.log(arguments[0], arguments[1], arguments[2]);
    9.         }
    10.         console.log('')
    11.     }
    13.     // 1. 任意字符 .
    14.     var reg1 = /.../;
    15.     var str1 = 'aa';
    16.     console.log('boo1', reg1.test(str1)); // false
    18.     // 2. \w 字母、数字、下划线
    19.     var reg2 = /\w\w/;
    20.     var str2 = 'as';
    21.     console.log('boo2', reg2.test(str2)); // true
    22.     console.log('boo2', reg2.test('$a')); // false
    24.     // 3. \s 任意空白字符
    25.     var reg3 = /..\s../;
    26.     console.log('boo3', reg3.test('aa bb')); // true
    27.     console.log('boo3', reg3.test('aa   bb')); // true
    29.     // 4. \d 匹配数字，等同于[0-9]
    30.     var reg4 = /\d\d\d\d/;
    31.     console.log('boo4', reg4.test('9999')); // true
    33.     // 5. \D 匹配非数字，等同于\[^0-9]
    34.     var reg5 = /\d\D\d/;
    35.     console.log('boo5', reg5.test('233')); // false
    36.     console.log('boo5', reg5.test('2a3')); // true
    38.     // 6. | 或匹配，如 /x|y/ 正则可匹配 x 或 y 两个字符
    39.     var reg6 = /abc|xyz/;
    40.     console.log('boo6', reg6.test('asdfasdfabcasdfasdf')); // true
    41.     console.log('boo6', reg6.test('asdfasdfxyzasdfasdf')); // true
    44.     // 7. [xyz] 表示包含 xyz 里面的任意一个,相当于x|y|z
    45.     var reg7 = /[abc]/;
    46.     log('boo7', reg7.test('aaa')); // true
    47.     log('boo7', reg7.test('ddd')); // false
    49.     // [a-zA-Z] // 匹配所有的大小写字母
    50.     var reg7 = /[a-zA-Z]/;
    51.     var reg7 = /[0-9]/; // 匹配0到9,相当于\d
    53.     // 8. [^x] 匹配除“x”之外的所有字符，其中“x”可以为任意字符
    54.     var reg8 = /[^s]/;
    55.     log('boo8', reg8.test('asdf')); // true
    56.     log('boo8', reg8.test('sss')); // false
    58.     // 9. [^xyz] 同上，匹配除“x、y、z”之外的任意字符
    59.     var reg9 = /[^abc]/; // 存在abc以外的字符都能匹配
    60.     log('boo9', reg9.test('d')); // true
    61.     log('boo9', reg9.test('ab')); // false
    63.     // 10. ^ 匹配字符串的开始
    64.     var reg10 = /^[a-zA-Z]\w\w\w/; // 匹配:第一个字符是字母,紧跟三个字符(数字,字母或下划线)
    65.     log('boo10', reg10.test('a_8al2k323')); // true
    66.     log('boo10', reg10.test('8a_8al2k323')); // false
    68.     var reg10 = /^1\d\d\d\d\d\d\d\d\d\d$/; // 11位数字
    69.     log('boo10', reg10.test('13811111111')); // true
    70.     log('boo10', reg10.test('23811111111')); // false
    72.     // 11. \$ 匹配字符串的结束
    74.     // 12. \x 转义字符
    75.     var reg12 = /\.com/;
    76.     log('boo12', reg12.test('acom')); // false
    77.     log('boo12', reg12.test('asdfasdf.com')); // true
    79.     // '2021/05/05'
    80.     var reg12 = /\d\d\d\d\/\d\d\/\d\d/;
    82.     // 13. `？` 重复出现零次或一次
    83.     var reg13 = /^https?/;
    84.     console.log('boo13', reg13.test('http://asdfasdfasdf')); // true
    85.     console.log('boo13', reg13.test('https://asdfasdfasdf')); // true
    87.     // 14. `+` 重复出现一次或多次
    88.     var reg14 = /a+/; // 有一个a或者多个a都能匹配
    89.     log('boo14', reg14.test('sdfsdfsaasdf')); // true
    90.     log('boo14', reg14.test('22222a')); // true
    92.     // 15. `*` 重复出现零次或多次
    93.     var reg15 = /^https?.*/;
    94.     log('boo15', reg15.test('http://asdfasdfsadf')); // true
    96.     // 16. {n} 重复出现 n 次
    97.     var reg16 = /^1\d{10}$/;
    99.     // 17. {n,} 至少重复出现 n 次
    100.     var reg17 = /\d{10,}/; // 至少有10个数字
    102.     // 18. {m,n} 重复重现 m 到 n 次，其中，m<n
    103.     var reg17 = /\d{10,20}/; // 匹配10个到20个数字

    3、惰性匹配

    1.  var reg = /\d+/;
    2.     var str = '23423424234234234';
    3.     var arr = str.match(reg);
    4.     console.log('arr', arr);
    6.     var reg2 = /\d+?/;
    7.     var arr2 = str.match(reg2);
    8.     console.log('arr2', arr2);

    4、分组

    1.  // 分组可以使用 \1-代表第一组, \2-第2组
    2.     var dateReg1 = /^(\d{4})-(\d{2})-(\d{2})$/;
    3.     var dateReg2 = /^(\d{4})-(\d{2})-\2$/; // \d{2} 和 \2 数字要一样
    4.     var str = '2021-06-06';
    5.     console.log('date1', dateReg1.test(str));
    6.     console.log('date2', dateReg2.test(str));
    8.     var phoneReg = /^(1\d{2})(\d{4})\2$/;
    9.     var str = '13800000000';
    10.     console.log('phone', phoneReg.test(str));
    13.     // 字符串替换时,可以使用正则分组,使用$1-第1组,$2-表示第2组
    14.     var str = '13811112222';
    15.     var newStr = str.replace(/(\d{3})(\d{4})(\d{4})/, '$1****$3');
    16.     console.log('newStr', newStr);
    1.  // 字面量的方式创建对象
    2.     var obj = {
    3.         a: 2,
    4.         b: 3
    5.     };
    7.     // 构造函数方式创建对象,构造函数是用来创建对象
    8.     var obj1 = new Object();
    9.     obj1.name = 'zhangsan';
    11.     // 字面量
    12.     var arr = [1, 2, 3];
    13.     // 构造函数
    14.     var arr1 = new Array();
    15.     arr1[0] = 1;
    16.     arr1[1] = 2;
    1.   function add() {
    2.         console.log(arguments[0], arguments[1]);
    3.     }
    5.     add(10, 20);
    8.     var log = function() {
    9.         var len = arguments.length;
    10.         if (len === 1) {
    11.             console.log(arguments[0])
    12.         } else if (len === 2) {
    13.             console.log(arguments[0], arguments[1]);
    14.         } else {
    15.             console.log(arguments[0], arguments[1], arguments[2]);
    16.         }
    17.     }
    19.     log(1);
    20.     log(1, 2);
    21.     log(1, 2, 3);