正则表达式

最新推荐文章于 2022-07-28 16:44:36 发布

花江夏树

最新推荐文章于 2022-07-28 16:44:36 发布

阅读量335

点赞数

本文链接：https://blog.youkuaiyun.com/onepunchmen00/article/details/78720209

版权

找出字符串中符合规则的字符

由普通字符（26个英文字母和数字等）

和特殊字符 . / 等组成

创建正则表达式的正确方法？

 1.new RegExp('lg exp ');
2./正则表达式/


<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>创建正则表达式的两种方式</title>
</head>
<body>
   
<script>
   // 字面量或直接量
   // []
   // {}
   // /js/
   // // 构造函数
   // new Array()
   // new Object()
   // // regular expression 正则表达式英文
   // new RegExp()

   // var str = 'I love js';
   // var pattern = /js/;  匹配到的一定是字符串内容
   // '3.4'
   // /js5_正则 ,;!@./

   // var str = 'I love js';
   // var pattern = /js/;
   // // test exec 找到匹配的字符
   // console.log(pattern.test(str));//返回布尔值
   // console.log(pattern.exec(str));//将找到的字符放到数组中返回

   // var str = 'I love Js';
   // var pattern = /js/;
   // // test exec
   // console.log(pattern.test(str));
   // console.log(pattern.exec(str));//null

   // var str = 'I love Js';
   // var pattern = /Js/;
   // console.log(pattern.test(str));
   // console.log(pattern.exec(str)); 返回匹配到的字符串的数组   找不到返回null

    //i ignoreCase 忽略大小写
    //g global 全局匹配
    // m multiline 多行匹配


    // var str = 'I love Js';
   // var pattern = /js/i;
   // console.log(pattern.test(str));
   // console.log(pattern.exec(str));


//与位置无关 这几个随便排
   // /js/ig
   // /js/gi
   // /js/igm
   // /js/img

   // var str = 'I love js';
   // var pattern = new RegExp('js');
   // console.log(pattern.test(str));
   // console.log(pattern.exec(str));

   // var str = 'I love Js';
   // var pattern = new RegExp('js', 'i');
   // console.log(pattern.test(str));
   // console.log(pattern.exec(str));

   // /js/i
   // new RegExp('js', 'i')

   // var str = 'I love Js';
   // var userInput = 'love';
   // var pattern = /userInput/i;   不可取的方法
//错误的方法
   // var str = 'I love Js';
   // var userInput = 'love';
   // var pattern = '/' + userInput + '/i';
   // console.log(typeof pattern);

   var str = 'I love Js';
   var userInput = 'love';
   var pattern = new RegExp(userInput, 'i');//体现了构造方法的优势  userInput随时可以改变
   console.log(pattern);
   console.log(typeof pattern);
   console.log(pattern.exec(str));
</script>

</body>
</html>

正则表达式工具

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>正则表达式测试工具</title>
<style>
   #regexp {
      width: 650px;
      margin: 100px auto;
      font-size: 14px;
   }
   #regexp .title {
      color: #777;
      font-size: 24px;
      text-align: center;
   }
   #regexp .textbox {
      width: 638px;
      height: 150px;
      border: 1px solid #ccc;
      border-radius: 5px;
      padding: 5px;
      resize: none;
   }
   #regexp .textfield {
      width: 215px;
      padding: 5px;
      border: 1px solid #ccc;
   }
</style>
</head>
<body>

   <div id="regexp">
      <h1 class="title">正则表达式测试工具</h1>
      <textarea id="userText" class="textbox" placeholder="在此输入待匹配的文本"></textarea>
      <p>
         正则表达式：<input type="text" id="userRegExp" class="textfield" placeholder="在此输入正则表达式" />
         <input type="checkbox" name="userModifier" value="i" />忽略大小写
         <input type="checkbox" name="userModifier" value="g" />全局匹配
         <input type="checkbox" name="userModifier" value="m" />多行匹配
         <input type="button" id="matchingBtn" value="测试匹配" />
      </p>
      匹配结果：
      <textarea id="matchingResult" class="textbox" disabled="disabled"></textarea>
   </div>

<script>
   var userText = document.getElementById('userText'),
      userRegExp = document.getElementById('userRegExp'),
      userModifier = document.getElementsByName('userModifier'),
      matchingBtn = document.getElementById('matchingBtn'),
      matchingResult = document.getElementById('matchingResult');
   var pattern,
      modifier = '';

   for (var i = 0; i < userModifier.length; i++) {//给每个复选框添加上点击事件
      userModifier[i].onclick = function () {
         modifier = '';//每次被点击要被清空 复选框
         for (var j = 0; j < userModifier.length; j++) {//任意一个被勾选的时候要检测哪几个被选上
            if (userModifier[j].checked) {
               modifier += userModifier[j].value;
            }
         }
      }
   }

   matchingBtn.onclick = function () {
      if (!userText.value) {
         alert('请输入待匹配的文本！');
         userText.focus();//光标定位
         return;
      }
      if (!userRegExp.value) {
         alert('请输入正则表达式！');
         userRegExp.focus();
         return;
      }
      pattern = new RegExp(userRegExp.value, modifier);
      matchingResult.value = pattern.exec(userText.value) || '(没有匹配)';
   }
</script>
</body>
</html>

简单的转义字符

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>简单的转义字符</title>
</head>
<body>
<script>
   // \
   // var str = '// 我是注释';
   // var pattern = /\/\//;      //     匹配// 需要用\转义
   // console.log(pattern.exec(str));

   // var str = '\\\\';       //  '\'默认视为把右边引号转义了  所以要用\\   字符串和正则表达式关系亲密
   // var pattern = /\\\\/;
   // console.log(str);
   // console.log(pattern.exec(str));

   // var str = 'nba';
   // var pattern = /\n/;  //换行
//console.log(pattern.exec(str)
   // var str = '1.html\n2.css\n3.js';
   // var pattern = /\n/;
   // console.log(str);
   // console.log(pattern.exec(str));

   // var str = ' js';
   // var pattern = /\t/;//tab
   // console.log(pattern.exec(str));

   // var str = 'a\nb';
   // var pattern = /\x61\x0A\x62/;//ascll 用16进制表示的  不常用
   // console.log(pattern.exec(str));

   // var str = ' js';
   // var pattern = /\u0009/;//unicode编码 表示的tab 常用 匹配汉字会用到
   // console.log(pattern.exec(str));

   var str = 'Alex帅';
   var pattern = /衰/;
   //中文的unicode 范围  \u4e00-\u9fa5
</script>
</body>
</html>

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>字符类</title>
</head>
<body>
   

<script>
   // var str = 'sjavascript';
   // var pattern = /[js]/; //匹配[]中任意一个字符 先匹配到谁就是谁

   // var str = 'javascript';
   // var pattern = /[^js]/; //除了js以外的任何字符
   // console.log(pattern.exec(str));//a

   // var str = 'javascript';
   // var pattern = /[a-z]/;  //26个字母
   // console.log(pattern.exec(str));

   // var str = 'javascript';
   // var pattern = /[c-d]/;
   // console.log(pattern.exec(str));

   // var str = 'javascript';
   // var pattern = /[c-c]/;
   // console.log(pattern.exec(str));

   // var str = 'Alex帅';
   // var pattern = /[\u4e00-\u9fa5]/;
   // console.log(pattern.exec(str));

   // var str = 'JavaScript';
   // var pattern = /[a-zA-Z]/;
   // console.log(pattern.exec(str));

   // var str = '00544';
   // var pattern = /[0-9]/;
   // console.log(pattern.exec(str));


   // var str = 'JavaScript2.0';
   // var pattern = /[a-zA-Z0-9]/;
   // console.log(pattern.exec(str));

   // /[a-zA-Z0-9@_asdf]/
   // /[^\n]/ 除了\n之外的字符被匹配
   // /./   等同于除了\n以外的字符

   // var str = '3.1415926';
   // var pattern = /./;
   // console.log(pattern.exec(str));

   // var str = '3.1415926';
   // var pattern = /\./;
   // console.log(pattern.exec(str));

   // var str = '\n';
   // var pattern = /./;
   // console.log(pattern.exec(str));

   // /[a-zA-Z0-9_]/ /\w/      后者是简写
   // /[^a-zA-Z0-9_]/ /\W/

   // var str = '_@';
   // var pattern = /\w/;
   // console.log(pattern.exec(str));

   // var str = '00544';
   // var pattern = /\d/;   相当于[0-9]
   // console.log(pattern.exec(str));

   // var str = ' ';
   // var pattern = /\s/;   代表空格和tab
   // console.log(pattern.exec(str));
   // \S

   var str = '1 1';
   var pattern = /[\s\d]/; //[]表示不管里面有多少 只匹配一个
</script>
</body>
</html>

重复和贪婪

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>重复</title>
</head>
<body>
   

<script>
   // var str = '110';
   // var pattern = /\d{2}/;   //匹配0-9 可以匹配两个
   // console.log(pattern.exec(str));

   // var str = '110';
   // var pattern = /\d{1,2}/; //匹配一个或者两个
   // console.log(pattern.exec(str));
   // // for (var i = 0; i < 3; i++) {

   // // }
   // var pattern = /\d{1, 2}/;//不能乱写空格

   // var str = '110';
   // var pattern = /\d{1,}/; //匹配至少一个
   // console.log(pattern.exec(str));

   // var str = '110';
   // var pattern = /\d{,2}/; //XX 不能这么写
   // console.log(pattern.exec(str));

   // var str = '110';
   // var pattern = /\d?/; // {0,1}
   // console.log(pattern.exec(str));

   // var str = '110';
   // var pattern = /\d+/; // {1,}
   // console.log(pattern.exec(str));

   // var str = '110';
   // var pattern = /\d*/; // {0,}
   // console.log(pattern.exec(str));

   // var str = '肯德基豪华午餐：￥15.5！';
   // // var pattern = /\d+\.?\d*/;  //匹配数字 不确定整数位是否是一个以上所以是 \d+  匹配.因为.可能因为价格是整数没有. 用|.？  最后一个是匹配小数位
   // var pattern = /\d{1,}\.{0,1}\d{0,}/;
   // console.log(pattern.exec(str));

   // var str = 'aaab';
   // var pattern = /a+/; //匹配aaa  条件允许就匹配尽量多
   // console.log(pattern.exec(str));

   // var str = 'aaab';
   // var pattern = /a+?/; //a
   // console.log(pattern.exec(str));

   // var str = 'aaab';
   // var pattern = /a+b/;//aaab
   // console.log(pattern.exec(str));

   // var str = 'aaab';
   // var pattern = /a+?b/;//aaab 第一个就匹配上了a  而不是第三个a
   // console.log(pattern.exec(str));

   // var str = '<td><p>a</p></td><td><p>b</p></td>';
   // var pattern = /<td>.*<\/td>/;//.*最少0最多无限
    // console.log(pattern.exec(str)); //全部被匹配

   var str = '<td><p>a</p></td><td><p>b</p></td>';
   var pattern = /<td>.*?<\/td>/;
   console.log(pattern.exec(str));  //只匹配第一个td中间的内容    转换为非贪婪模式只用加个？
</script>
</body>
</html>

分组、引用、捕获

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>选择、分组和引用</title>
</head>
<body>
   
<script>
    //选择
   // var str = 'css html js';
   // var pattern = /html|css|js/; // | 表示或者
   // console.log(pattern.exec(str));

   // var str = 'ab';
   // var pattern = /a|ab/;//a
   // console.log(pattern.exec(str));

    //分组
   // var str = 'abab';
   // var pattern = /(ab)+/;
   // console.log(pattern.exec(str));//abab ab

   // var str = 'abcd';
   // var pattern = /(ab)c/; //捕获
   // console.log(pattern.exec(str));//abc ab

   // var str = 'abcd';
   // var pattern = /(?:ab)c/;//非捕获 abc 
   // console.log(pattern.exec(str));

   // var str = 'abcd';
   // var pattern = /(ab)(c)/; //abc ab c
   // console.log(pattern.exec(str));

   // var str = 'abcd';
   // var pattern = /(a(b(c)))/; //abc abc bc c
   // console.log(pattern.exec(str));
//引用
   // var str = 'ab cd ab';
   // var pattern = /(ab) cd \1/;   // \1代表第一个分组 也就是 （ab）    abcd ab
   // console.log(pattern.exec(str));
// <> 这个括号不用转义
   var str = '<p><a>这是一段文字</a></p>';
   var pattern = /<([a-zA-Z]+)>(.*?)<\/\1>/;
   console.log(pattern.exec(str));

   'abc' /c/ index
</script>
</body>
</html>

问：现有类似’javascript is js’的字符串，其中javascript中的j和s的大小写与后面js中j和s的大小写保持一致，即’Javascript is Js’或’JavaScript is JS’等，请用引用的方式写出能够匹配它的正则表达式，下列选项中哪个是用分组和引用的方式来匹配的？

/([Jj])ava([Ss])cript\sis\s(\1\2)/

边界匹配

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>指定匹配位置</title>
</head>
<body>
   
<!-- <p class="odd2      odd    ">1</p>
<p class="even">2</p>
<p class="odd">3</p>
<p class="even">4</p> -->

<script>
    //首尾匹配
   // var str = 'html js';
   // var pattern = /^js/; //表示j必须在字符串开头
   // console.log(pattern.exec(str));
   //与 /[^0-9]不同 /

   // var str = 'html js css';
   // var pattern = /js$/; //尾匹配
   // console.log(pattern.exec(str));

   // var str = '110119120';
   // var pattern = /^\d+$/;
   // console.log(pattern.exec(str));
   // if (pattern.test(str)) {
   //     console.log('全是数字！');
   // } else {
   //     console.log('不全是数字！');
   // }

   // var str = '11011a9120';
   // var pattern = /\D/;//非数字
   // console.log(pattern.exec(str));
   // if (pattern.test(str)) {
   //     console.log('不全是数字！');
   // } else {
   //     console.log('全是数字！');
   // }


    //边界匹配
   // var str = 'js html';
   // var pattern = /js\b/;   //   匹配到js   js后的空格是一个边界
   // console.log(pattern.exec(str));

   // var str = '@@@js@@@';
   // var pattern = /\bjs\b/;
   // console.log(pattern.exec(str));

   // var oddP = getByClassName('odd');
   // var evenP = getByClassName('even');
   // for (var i = 0; i < oddP.length; i++) {
   //     oddP[i].style.backgroundColor = 'red';
   // }
   // for (var i = 0; i < evenP.length; i++) {
   //     evenP[i].style.backgroundColor = 'yellow';
   // }

   // function getByClassName(className, parentNode) {
   //     if (document.getElementsByClassName) {
   //        return document.getElementsByClassName(className);
   //     } else {console.log(1);
   //        parentNode = parentNode || document;
   //        var nodeList = [];
   //        var allNodes = parentNode.getElementsByTagName('*');
   //        var pattern = new RegExp('\\b' + className + '\\b');//方法二 只要保证这个单词前后都有

   //        for (var i = 0; i < allNodes.length; i++) {
   //           if (pattern.test(allNodes[i].className)) {
   //              nodeList.push(allNodes[i]);
   //           }
   //        }

   //        return nodeList;
   //     }
   // }

   // function getByClassName(className, parentNode) {
   //     if (document.getElementsByClassName) {
   //        return document.getElementsByClassName(className);
   //     } else {console.log(1);
   //        parentNode = parentNode || document;
   //        var nodeList = [];
   //        var allNodes = parentNode.getElementsByTagName('*');
   //        var pattern = new RegExp('(^|\\s+)' + className + '($|\\s+)');//方法一

   //        for (var i = 0; i < allNodes.length; i++) {
   //           if (pattern.test(allNodes[i].className)) {
   //              nodeList.push(allNodes[i]);
   //           }
   //        }

   //        return nodeList;
   //     }
   // }

   // function getByClassName(className, parentNode) {
   //     if (document.getElementsByClassName) {
   //        return document.getElementsByClassName(className);
   //     } else {console.log(1);
   //        parentNode = parentNode || document;
   //        var nodeList = [];
   //        var allNodes = parentNode.getElementsByTagName('*');

   //        for (var i = 0; i < allNodes.length; i++) {
   //           if (allNodes[i].className === className) {
   //              nodeList.push(allNodes[i]);
   //           }
   //        }

   //        return nodeList;
   //     }
   // }

    //前瞻性匹配
   // var str = 'java';
   // var pattern = /java(?=script)/;  //如果后面是script就匹配java
   // console.log(pattern.exec(str));

   var str = 'javasda';
   var pattern = /java(?!script)/;//如果后面不是script就匹配java
   console.log(pattern.exec(str));
</script>
</body>
</html>

RegExp实例方法

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>RegExp对象</title>
</head>
<body>

<script>
   // /js/
   // new RegExp('js')
   // var className = 'box';
   // new RegExp(className)

   // console.log(new RegExp('\\b'));  //注意转义字符要双重转义
   // /\\/
   // new RegExp('\\\\')  //等同于 /\\/  要双倍

   // RegExp实例方法
   // var pattern = /js/;
   // var pattern = new RegExp('js');

   // pattern.test pattern.exec

   // var str = 'js js js';
   // var pattern = /js/;
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));

   // var str = 'js js js';
   // var pattern = /js/g;
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));

   // pattern.lastIndex  //匹配上的字符下一个位置

   // var str = 'js js js';
   // var pattern = /(j)s/;
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));

   // var str = 'js js js';
   // var pattern = /(j)s/g;
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));
   // console.log(pattern.exec(str));

   // var str = '1.js 2.js 3.js';
   // var pattern = /js/g;
   // var total = 0,
   //     match = '',
   //     result;
//每次执行exec只返回找到的一个  所以需要循环
   // while ((result = pattern.exec(str)) != null) {
   //     total++;
   //     match += '第' + total + '个匹配到的是：' + result[0] + ', 它的位置是：' + result.index + '\n';
   // }
   // match += '共找到' + total + '处匹配\n';
   // console.log(str);
   // console.log(match);

   // var str = 'js js js';
   // var pattern = /js/g;
   // console.log(pattern.test(str));
   // console.log(pattern.test(str));
   // console.log(pattern.test(str));
   // console.log(pattern.test(str));
   // console.log(pattern.test(str));

   // var pattern = new RegExp('a\\nb')
   // console.log(pattern.toString());
   // console.log(pattern.toLocaleString());//和上面的tostring类似  用不上
   // console.log(pattern.valueOf() === pattern);//返回正则表达式本身

   // RegExp实例属性

   // var str = 'js js js';
   // var pattern = new RegExp('\\b', 'i');
   // console.log(pattern.ignoreCase);//判断一下前面有没有i
   // console.log(pattern.global);
   // console.log(pattern.multiline); //这三个返回布尔值
   // console.log(pattern.source);//和tostring类似  这一组用处都不大
   // console.log(pattern.lastIndex);

   // var str = 'js js js';
   // var pattern = /js/;
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);

   // var str = 'js js js';
   // var pattern = /js/g;
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);//匹配不到了就重新开始
   // pattern.test(str);
   // console.log(pattern.lastIndex);
   // pattern.test(str);
   // console.log(pattern.lastIndex);

   // 构造函数属性  不常用
   // var str = 'js js js';
   // var pattern = /(j)s/;
   // pattern.exec(str);
   // console.log(RegExp.input);
   // console.log(RegExp.$_); // 字母、_、$开头，后面字母、_、$、数字
   // console.log(RegExp['$_']);
   // console.log(RegExp.lastMatch);
   // console.log(RegExp['$&']);
   // console.log(RegExp.leftContext);
   // console.log(RegExp['$`']);
   // console.log(RegExp.rightContext);
   // console.log(RegExp["$'"]);
   // console.log(RegExp.lastParen);
   // console.log(RegExp["$+"]);

   // exec
   // /\1\2/
   // console.log(RegExp.$1);

   
</script>
</body>
</html>

string中操作正则表达式的方法

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>String对象中与正则表达式相关的方法</title>
</head>
<body>

<script>
   // var str = 'html js js';
   // var pattern = /js/g;
   // console.log(str.search(pattern));//没找到返回-1 返回找到的位置 不用加g也可以

   // var str = 'html js js';
   // console.log(str.search('js'));//会自己转为正则表达式

   // var str = 'js js js';
   // var pattern = /(j)s/;
   // console.log(str.match(pattern)); js j

   // var str = 'js js js';
   // var pattern = /(j)s/g;
   // console.log(str.match(pattern)); js js js

   // match VS exec
//match 在非全局匹配的情况下才会返回分组中匹配的内容   全局匹配只能匹配到所有匹配到的字符

   // var str = '1.js\n2.js\n3.js';
   // var pattern = /js/m;
   // console.log(str);
   // console.log(str.match(pattern));
//m要配合g
   // var str = '1.js\n2.js\n3.js';
   // var pattern = /js/mg;
   // console.log(str);
   // console.log(str.match(pattern));

   // var str = '1.js\n2.js\n3.js';
   // var pattern = /js$/mg;//不加m只匹配到最后一个js
   // console.log(str);
   // console.log(str.match(pattern));

   // var str = 'js1\njs2\njs3';
   // var pattern = /^js/mg;
   // console.log(str);
   // console.log(str.match(pattern));

   // var str = 'html,css,js';
   // console.log(str.split(','));

   // var str = 'html,css,js';
   // var pattern = /,/g;
   // console.log(str.split(pattern));

   // var str = 'html ,   css  ,   js';
   // var pattern = /\s*,\s*/;
   // console.log(str.split(pattern));

   // var str = 'I love js js';
   // console.log(str.replace('js', 'html'));

   // var str = 'I love js js';
   // var pattern = /js/g;
   // console.log(str.replace(pattern, 'html'));

   // var str = '1111-11-11';
   // var pattern = /-/g;
   // console.log(str.replace(pattern, '.'));

   // var str = 'I love js';
   // var pattern = /(js)/;
   // document.write(str.replace(pattern, '<strong style="color: red;">$1</strong>'));//$1表示第一个分组

   // var str = '中国军队和阿扁一起办证';
   // var pattern = /国军|阿扁|办证/g;
   // console.log(str.replace(pattern, '*'));

   // var str = '中国军队和阿扁一起办证';
   // var pattern = /国军|阿扁|办证/g;
   // console.log(str.replace(pattern, function ($0) {//随便用一个字符串接受 这里用的$0
   //     // console.log($0);
   //     var result = '';
   //     for (var i = 0; i < $0.length; i++) {
   //        result += '*';
   //     }

   //     return result;
   // }));
</script>
</body>
</html>

常用的正则表达式

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<title>常用的正则表达式</title>
</head>
<body>

<script>
   // 1.QQ
   //     全是数字
   //     首位不能为0
   //     最少5位(10000)
   //     目前最多11位？

   // /^[1-9]\d{4,10}$/   这里不是为了匹配qq号  而是验证qq号是否符合规则
   // /^[1-9]\d{4,}$/    不设置最多位数

   // 2.昵称
   //     中、英文、数字以及下划线
   //     2-18位
   // /^[\u4e00-\u9fa5a-zA-Z0-9_]{2,18}$/
   // /^[\u4e00-\u9fa5\w]{2,18}$/

   // 3.密码
   //     6-16位
   //     不能用空白字符\s
   // /^\S{6,16}$/
   // /^[\w~!@#$%^\[\]]{6,16}$/    这里是把所有允许输入的字符都包括进来

   // 4.去除字符串首尾的空白字符
   // var str = '        Alex         ';
   // var pattern = /^\s+/;
   // console.log('|' + str.replace(pattern, '') + '|');

   // var str = '        Alex         ';
   // var pattern = /\s+$/;
   // console.log('|' + str.replace(pattern, '') + '|');

   // var str = '        Alex         ';
   // var pattern = /^\s+|\s+$/g;   方法一
   // console.log('|' + str.replace(pattern, '') + '|');

   // var str = '        Alex         ';
   // var pattern1 = /^\s+/;
   // var pattern2 = /\s+$/;  方法二  性能不好
   // console.log('|' + str.replace(pattern1, '').replace(pattern2, '') + '|');

//     function trim(str) {      封装一个方法
//        return str.replace(/^\s+/, '').replace(/\s+$/, '');
//     }
//     trimLeft trimRight  可以细分一下功能
//     var str = '        Alex         ';
// console.log('|' + trim(str) + '|');

   // 5.转驼峰-
   //     css: background-color: red;
   //     js: elem.style.backgroundColor = 'red';
   //     jquery: $(elem).css('background-color', 'red');

   // var str = 'background-color';
   // var pattern = /-([a-z])/gi;
   // console.log(str.replace(pattern, function (all, letter) {
   //     return letter.toUpperCase();
   // }));

   // function toCamelCase(str) {
   //     return str.replace(pattern, function (all, letter) {
   //        return letter.toUpperCase();
   //     })
   // }
   // all,letter都是参数。all用来传递正则匹配到的所有字符。letter用来传递正则中小括号内匹配到的字符。

   // 6.匹配HTML标签
   // var str = '<p class="odd" id="odd">123</p>';
   // var pattern = /<\/?[a-zA-Z]+(\s+[a-zA-Z]+=".*")*>/g;
   // console.log(str.match(pattern));

   // var str = '<p class="odd" id="odd">123</p>';
   // var pattern = /<[^>]+>/g;
   // console.log(str.match(pattern));
//下面的特例不能用上面的方法
   // var str = '<input type="text" value=">" name="username" />';
   // var pattern = /<(?:[^"'>]|"[^"]*"|'[^']*')*>/g;//看成两部分 引号外和引号内用 或 连接
   // console.log(str.match(pattern));

   // var str = '<input type="text" value=">" name="username" />';
   // var pattern = /<(?:[^"'>]|(["'])[^"']*\1)*>/g; //看成<p> <\1>
   // console.log(str.match(pattern));

   // 7.邮箱
   //     alex@yahoo.com.cn
   //     alex_1@yahoo.com.cn
   //     alex_1.a-sdasd.asdasdas.com@yah-o_o.com.adasdsd.cn
   // /(?:\w+\.)*\w+@(?:\w+\.)+[a-z]/i
   // /^[a-z0-9]+(?:[._-][a-z0-9]+)*@[a-z0-9]+(?:[._-][a-z0-9]+)*\.[a-z]{2,4}$/i

   // 8.URL
   // (协议:\/\/)主机名(:端口号)(/路径)  //协议可有可无  主机名是在端口号： 和路径/之前
// ftp|http|https|mailto|file:///
   // /^(https?:\/\/)?([^:\/]+)(:\d+)?(\/.*)?$/               这里是只考虑了http或者https的协议

   // 匹配主机名
   // /[^:\/]+/
   // -www.-imos-oc.casfasf.sadasd.co-m  //不能以-开头结尾
   // ai
   // /[a-z0-9]|[a-z0-9][-a-z0-9]*[a-z0-9]/i
   // /^([a-z0-9]\.|[a-z0-9][-a-z0-9]*[a-z0-9]\.)*(com|edu|gov|net|org|[a-z]{2})$/i
   // /^([a-z0-9]\.|[a-z0-9][-a-z0-9]*[a-z0-9]\.)*([a-z]+)$/i

   // var regexp = {
   //     'chinese': /[\u4e00-\u9fa5]/, // 
   //     'qq': /^[1-9]\d{4,}$/,
   //     ....
   // };
   // regexp.qq
</script>
</body>
</html>