• 正则表达式


    构造函数创建正则表达式

     1 <!DOCTYPE html>
     2 <html>
     3     <head>
     4         <meta charset="UTF-8">
     5         <title></title>
     6         <script type="text/javascript">
     7             /*
     8              * 正则表达式
     9              *     - admin@atguigu.com
    10              *  - admin@.com   adminatguigu.com
    11              *  - 邮件的规则:
    12              *         1.前边可以是xxxx乱七八糟
    13              *         2.跟着一个@
    14              *         3.后边可以是xxxx乱七八糟
    15              *         4..com获取其他的乱七八糟
    16              * 
    17              *     - 正则表达式用于定义一些字符串的规则,
    18              *         计算机可以根据正则表达式,来检查一个字符串是否符合规则,
    19              *         获取将字符串中符合规则的内容提取出来
    20              */
    21             
    22             //创建正则表达式的对象
    23             /*
    24              * 语法:
    25              *     var 变量 = new RegExp("正则表达式","匹配模式");
    26              *  使用typeof检查正则对象,会返回object
    27              *     var reg = new RegExp("a"); 这个正则表达式可以来检查一个字符串中是否含有a
    28              * 在构造函数中可以传递一个匹配模式作为第二个参数,
    29              *         可以是 
    30              *             i 忽略大小写 
    31              *             g 全局匹配模式
    32              */
    33             var reg = new RegExp("ab","i");
    34             console.log(reg) //  /ab/i
    35             console.log(typeof reg)  //object
    36             
    37             var str = "a";
    38             
    39             /*
    40              * 正则表达式的方法:
    41              *     test()
    42              *      - 使用这个方法可以用来检查一个字符串是否符合正则表达式的规则,
    43              *         如果符合则返回true,否则返回false
    44              */
    45             var result = reg.test(str);
    46             //console.log(result);
    47             console.log(reg.test("Ac")); //false
    48             console.log(reg.test("Abc")); //true
    49             
    50             
    51             
    52             
    53         </script>
    54     </head>
    55     <body>
    56     </body>
    57 </html>
    使用字面量来创建正则表达式
     1 <!DOCTYPE html>
     2 <html>
     3     <head>
     4         <meta charset="UTF-8">
     5         <title></title>
     6         <script type="text/javascript">
     7             
     8             /*
     9              * 使用字面量来创建正则表达式
    10              *     语法:var 变量 = /正则表达式/匹配模式
    11              * 使用字面量的方式创建更加简单
    12              *     使用构造函数创建更加灵活
    13              * 
    14              */
    15             //var reg = new RegExp("a","i");
    16             
    17             var reg = /a/i;
    18             
    19             //console.log(typeof reg);
    20             //console.log(reg.test("abc"));
    21             
    22             //创建一个正则表达式,检查一个字符串中是否有a或b
    23             /*
    24              * 使用 | 表示或者的意思
    25              */
    26             reg = /a|b|c/;
    27             
    28             /*
    29              * 创建一个正则表达式检查一个字符串中是否有字母
    30              */
    31             //reg = /a|b|c|d|e|f|g/;
    32             
    33             /*
    34              * []里的内容也是或的关系
    35              * [ab] == a|b
    36              * [a-z] 任意小写字母
    37              * [A-Z] 任意大写字母
    38              * [A-z] 任意字母
    39              * [0-9] 任意数字
    40              */
    41             reg = /[A-z]/;
    42             
    43             //检查一个字符串中是否含有 abc 或 adc 或 aec
    44             reg = /a[bde]c/;
    45             
    46             /*
    47              * [^ ] 除了
    48              */
    49             reg = /[^ab]/; //除了ab
    50             
    51             reg = /[^0-9]/;
    52             
    53             console.log(reg.test("12a3456"));
    54             
    55         </script>
    56     </head>
    57     <body>
    58     </body>
    59 </html>

    字符串和正则表达式的方法

     1 <!DOCTYPE html>
     2 <html>
     3     <head>
     4         <meta charset="UTF-8">
     5         <title></title>
     6         <script type="text/javascript">
     7             
     8             var str = "1a2b3c4d5e6f7";
     9             /*
    10              * split()
    11              *     - 可以将一个字符串拆分为一个数组
    12              *     - 方法中可以传递一个正则表达式作为参数,这样方法将会根据正则表达式去拆分字符串
    13              *     - 这个方法即使不指定全局匹配,也会全都插分
    14              */
    15             
    16             /*
    17              * 根据任意字母来将字符串拆分
    18              */
    19             var result = str.split(/[A-z]/);
    20 
    21             //console.log(result);
    22             console.log(result[0])//1
    23             
    24             /*
    25              * search()
    26              *     - 可以搜索字符串中是否含有指定内容
    27              *     - 如果搜索到指定内容,则会返回第一次出现的索引,如果没有搜索到返回-1
    28              *     - 它可以接受一个正则表达式作为参数,然后会根据正则表达式去检索字符串
    29              *     - serach()只会查找第一个,即使设置全局匹配也没用
    30              */
    31             str = "hello abc hello aec afc abc";
    32             /*
    33              * 搜索字符串中是否含有abc 或 aec 或 afc
    34              */
    35             result = str.search(/a[bef]c/);
    36             
    37             //console.log(result);
    38             var result= str.search(/[abc]/);
    39             console.log(result)//6
    40             var  result= str.search(/[abc]/g)
    41             console.log(result)//6
    42             
    43             
    44             /*
    45              * match()
    46              *     - 可以根据正则表达式,从一个字符串中将符合条件的内容提取出来
    47              *     - 默认情况下我们的match只会找到第一个符合要求的内容,找到以后就停止检索
    48              *         我们可以设置正则表达式为全局匹配模式,这样就会匹配到所有的内容
    49              *         可以为一个正则表达式设置多个匹配模式,且顺序无所谓
    50              *     - match()会将匹配到的内容封装到一个数组中返回,即使只查询到一个结果
    51              * 
    52              *     
    53              */
    54             str = "1a2a3a4a5e6f7A8B9C";
    55             
    56             result = str.match(/[a-z]/ig);
    57             console.log(Array.isArray(result)) //true
    58             
    59             //console.log(result[2]);
    60             
    61             /*
    62              * replace()
    63              *     - 可以将字符串中指定内容替换为新的内容
    64              *  - 参数:
    65              *         1.被替换的内容,可以接受一个正则表达式作为参数
    66              *         2.新的内容
    67              *  - 默认只会替换第一个
    68              */
    69             //result = str.replace(/[a-z]/gi , "@_@");
    70             result = str.replace(/[a-z]/gi , "");
    71             
    72             //console.log(result);
    73             
    74         </script>
    75     </head>
    76     <body>
    77     </body>
    78 </html>

    正则量词

     1 <!DOCTYPE html>
     2 <html>
     3     <head>
     4         <meta charset="UTF-8">
     5         <title></title>
     6         <script type="text/javascript">
     7             
     8             /*
     9              * 创建一个正则表达式检查一个字符串中是否含有aaa
    10              */
    11             
    12             /*
    13              * 量词
    14              *     - 通过量词可以设置一个内容出现的次数
    15              *     - 量词只对它前边的一个内容起作用
    16              *     - {n} 正好出现n次
    17              *     - {m,n} 出现m-n次
    18              *     - {m,} m次以上
    19              *     - + 至少一个,相当于{1,}
    20              *     - * 0个或多个,相当于{0,}
    21              *     - ? 0个或1个,相当于{0,1}
    22              */
    23             var reg = /a{3}/;
    24             //ababab
    25             reg = /(ab){3}/;
    26             
    27             reg = /b{3}/;
    28             
    29             reg = /ab{1,3}c/;
    30             
    31             reg = /ab{3,}c/;
    32             
    33             reg = /ab+c/;
    34             
    35             reg = /ab*c/;
    36             
    37             reg = /ab?c/;
    38             
    39             //console.log(reg.test("abbc"));
    40             
    41             /*
    42              * 检查一个字符串中是否以a开头
    43              *     ^ 表示开头
    44              *     $ 表示结尾
    45              */
    46             reg = /^a/; //匹配开头的a
    47             
    48             reg = /a$/; //匹配结尾的a
    49             
    50             //console.log(reg.test("abcabca"));
    51             
    52             /*
    53              * 如果在正则表达式中同时使用^ $则要求字符串必须完全符合正则表达式
    54              */
    55             reg = /^a$/;
    56             
    57             //console.log(reg.test("a"));
    58             
    59             /*
    60              * 创建一个正则表达式,用来检查一个字符串是否是一个合法手机号
    61              * 
    62              * 手机号的规则:
    63              *     1 3 567890123 (11位)
    64              *     
    65              *     1. 以1开头
    66              *  2. 第二位3-9任意数字
    67              *     3. 三位以后任意数字9个
    68              * 
    69              *  ^1   [3-9]  [0-9]{9}$  
    70              * 
    71              */
    72             
    73             var phoneStr = "13067890123";
    74             
    75             var phoneReg = /^1[3-9][0-9]{9}$/;
    76             
    77             console.log(phoneReg.test(phoneStr));
    78             
    79             
    80         </script>
    81     </head>
    82     <body>
    83     </body>
    84 </html>

    正则转义

     1 <!DOCTYPE html>
     2 <html>
     3     <head>
     4         <meta charset="UTF-8">
     5         <title></title>
     6         <script type="text/javascript">
     7             
     8             /*
     9              * 检查一个字符串中是否含有 .
    10              * . 表示任意字符
    11              * 在正则表达式中使用\作为转义字符
    12              * \. 来表示.
    13              * \\  表示\
    14              * 
    15              * 注意:使用构造函数时,由于它的参数是一个字符串,而\是字符串中转义字符,
    16              *     如果要使用\则需要使用\\来代替
    17              */
    18             var reg = /\./;
    19             
    20             reg = /\\/;
    21             
    22             reg = new RegExp("\\.");
    23             reg = new RegExp("\\\\");
    24             
    25             /*
    26              * \w
    27              *     - 任意字母、数字、_  [A-z0-9_]
    28              * \W
    29              *     - 除了字母、数字、_  [^A-z0-9_]
    30              * \d
    31              *     - 任意的数字 [0-9]
    32              * \D
    33              *     - 除了数字 [^0-9]
    34              * \s
    35              *     - 空格
    36              * \S
    37              *     - 除了空格
    38              * \b
    39              *     - 单词边界
    40              * \B
    41              *     - 除了单词边界
    42              */
    43             
    44             reg = /\w/;
    45             reg = /\W/;
    46             
    47             reg = /\d/;
    48             reg = /\D/;
    49             
    50             reg = /\s/;
    51             reg = /\S/;
    52             
    53             /*
    54              * 创建一个正则表达式检查一个字符串中是否含有单词child
    55              */
    56             
    57             reg = /\bchild\b/;
    58             
    59             //console.log(reg.test("hello child "));
    60             
    61             //接收一个用户的输入
    62             //var str = prompt("请输入你的用户名:");
    63             
    64             var str = "              he      llo                ";
    65             
    66             //去除掉字符串中的前后的空格
    67             //去除空格就是使用""来替换空格
    68             console.log(str);
    69             
    70             //str = str.replace(/\s/g , "");
    71             
    72             //去除开头的空格
    73             //str = str.replace(/^\s*/, "");
    74             //去除结尾的空格
    75             //str = str.replace(/\s*$/, "");
    76             // /^\s*|\s*$/g 匹配开头和结尾的空格
    77             str = str.replace(/^\s*|\s*$/g,"");
    78             
    79             
    80             console.log(str);
    81             
    82         </script>
    83     </head>
    84     <body>
    85     </body>
    86 </html>

    邮件正则

     1 <!DOCTYPE html>
     2 <html>
     3     <head>
     4         <meta charset="UTF-8">
     5         <title></title>
     6         <script type="text/javascript">
     7             
     8             /*
     9              * 电子邮件
    10              *     hello  .nihao          @     abc  .com.cn
    11              * 
    12              * 任意字母数字下划线    .任意字母数字下划线  @   任意字母数字     .任意字母(2-5位)   .任意字母(2-5位)
    13              * 
    14              * \w{3,}  (\.\w+)*  @  [A-z0-9]+  (\.[A-z]{2,5}){1,2}
    15              */
    16             
    17             var emailReg = /^\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}$/;
    18             
    19             var email = "abc.hello@163.com";
    20             
    21             console.log(emailReg.test(email));
    22             
    23             
    24         </script>
    25     </head>
    26     <body>
    27     </body>
    28 </html>
  • 相关阅读:
    LeetCode OJ--Sort Colors
    LeetCode OJ--Single Number II **
    LeetCode OJ--Single Number
    LeetCode OJ--Subsets II
    LeetCode OJ--ZigZag Conversion
    3ds Max学习日记(三)
    3ds Max学习日记(二)
    3ds Max学习日记(一)
    PokeCats开发者日志(十三)
    PokeCats开发者日志(十二)
  • 原文地址:https://www.cnblogs.com/fsg6/p/12870653.html
Copyright © 2020-2023  润新知