js 正则 数据类型检测四种方式

数据类型检测

1.typeof

	    1.返回字符串，字符串包含了对应数据类型
        2.不能检测null
        3.不能检测对象数据类型

2.instanceof 检测实例是否属于某个类的方法

		1.只要当前类的原型在当前实例的原型上，都是true
        2.只有改变了当前实例的原型链，检测结果就不再准确
        3.不能检测字面量方式创建的基本数据类型值

			 var ary  = [];
             console.log(ary instanceof Array);//true
             var obj  = {};
            console.log(obj instanceof Array);//false

             console.log(ary instanceof Object);//true
             function fn(){

             }
             console.log(fn instanceof Object);//true

             function fn(){
                 arguments.__proto__ = Array.prototype
                 console.log(arguments instanceof Array); //true
                
             }
             fn(1,2,3,4)
            

             var num = 1;
             console.log(num instanceof Number);//false
            
             var nom = new Number(1)
             console.log(nom instanceof Number);//true

3.constructor 原型中天生自带的属性名

		1.不能检测基本数据类型值得null.或undefined
        2.如果原型扩展以及继承都有可能导致原型指向发生改变，结果不准确

			 var ary = [];
             console.log(ary.constructor === Array);//true
             console.log(ary.constructor === Object);//false
             var obj = {};
             console.log(obj.constructor === Array);//false
             var num = 1;
             console.log(num.constructor === Number);//true

4.Object.prototype.toString.call()

        Object原型上的toString方法执行，会默认返回当前方法中this对应的结果
        toString  转字符串

            var num = 1;
            var arr = [1,2,3]
            var obj = {};
            console.log(obj.toString());//'[object Object]'
            console.log(num.toString());//'1'
            console.log( Object.prototype.toString.call(arr));//'[object Array]'
            console.log( Object.prototype.toString.call(null))//'[object Null]'
            console.log( Object.prototype.toString.call(undefined))//'[object Undefined]'
            num.toString === obj.toString//false
            console.dir(toString.call(window))//[object Window]
           

正则

 正则    引用数据类型 
  	  正则是js的内置类  RegExp
      正则就是处理字符串的，他是跟字符串相互配合使用
      字符串方法： charAt   substr  substring   slice   replace   split  indexOf  lastIndexOf  toUpperCase   toLowerCase   trim  trimLeft()  trimRight()
 1.字面量创建
	   var reg = /\d+/;
 2.实例创建   RegExp  
	  可以引入变量    
      如果出现转义字符  转义前面再加一个\

正则：正则由两部分组成：元字符和修饰符

	元字符  ：在正则中有特殊含义的一些字符

 修饰符：就是把正则额外的修饰一下
             i: 不区分大小写
             m：多行匹配
             g：全局匹配
 
         元字符：量词元字符、普通元字符、特殊元字符
             量词元字符：代表出现的次数
                 *:代表0到多次
                 +:出现一到多次
                 ？：出现0到1次
                 {n}:出现n次
                 {n,}:至少出现n次
                 {n,m}出现n到m次
             特殊元字符：单个或者多字符组合在一起具有特殊意义
                 \：转义字符：可以把普通元字符字符转换为特殊的元字符，也可以把特殊元字符转换为普通元字符  //
                 .:除了换行符以外的任意字符
                 ^:以什么什么开头  //
                 $：以什么什么结尾  //
                 \n：换行符
                 \d：0-9之间的数字  //
                 \D：非0-9之间的数字
                 \w:数字、字母、下划线
                 \s：空白字符
                 \t：制表符
                 \b：单词边界
                 x|y：取x或y的任意一个  // 
                 [xyz]:取x、y、z中的任意一个  //
                 [a-z]:在a到z单位内取一个  //
                 [^a-z]:取反
                 ():分组  //
                 (?:):只匹配不捕获
                 (?=):正向预查
                 (?!)：负向预查
 
             普通元字符：
             let reg = /name/
     
 
             正则捕获不到位null
             匹配不到位false

test:检测，匹配，如果检测成功，返回true,没有成功返回false

exec 捕获 返回一个数组 第一项就是捕获到的内容 第二项捕获内容开始的索引 第三项检测的整个字符串的整体

	1.返回一个数组   数组第一项是字符串中满足大正则中的内容
 	2.如果捕获不到  返回null

    var reg = /\d+/ 
    console.log(reg.exec('zhufeng2000peixun2019'));//["2000", index: 7, input: "zhufeng2000peixun2019", groups: undefined]

    1.正则的懒惰性 ：正则找到符合正则的值以后，就不再向后捕获    reg:lastIndex  不加g每次默认从索引0开始捕获
    g:原理 ：没捕获一次，当前正则的lastIndex就会修改成下一轮开始捕获的索引位置
    取消正则的懒惰性，用正则的修饰符g

        var reg = /\d+/g
        console.log(reg.lastIndex);//0
        console.log(reg.exec('zhufeng2000peixun2019'));//["2000", index: 7, input: "zhufeng2000peixun2019", groups: undefined]
        console.log(reg.lastIndex);//11   下一轮要开始的索引
        console.log(reg.exec('zhufeng2000peixun2019'));//["2019", index: 17, input: "zhufeng2000peixun2019", groups: undefined]
        console.log(reg.lastIndex);//21

    2.正则的贪婪性
    ?:放在量词的后面，是取消捕获的贪婪性
   一个一个字符进行捕获
    小括号
    小括号  也要进行一次捕获，从左往右依次进行捕获
     (?：) 取消捕获

正则简单案例

 手机号
    let reg = /^1\d{10}$/
    console.log(reg.test('12345678911'));//true

    有效数字
    let reg = /^-?(\d|[1-9]\d+)(\.\d+)?$/
    console.log(reg.test('a8864.aad'));//false

    身份证号
    let reg = /^(\d{6})([12]\d{3})(0[1-9]|1[0-2])(0[1-9]|12\d|3[0-1])(\d{3})(\d|x)/
    console.log(reg.exec('1406021996120375151203'));
    
    18-65
    let reg = /^(1[89]{1}|[2-5]\d{1}|6[0-5]{1})$/
    console.log(reg.test('66'));
    
    汉字  unicode [\u4E00-\u9FA5]  所有汉字编码范围
    let reg = /[\u4E00-\u9FA5]+/
    console.log(reg.test('的撒大苏打啊大苏打'));
    
    邮箱 
    let reg = /^[0-9a-zA-Z_\u4E00-\u9FA5]+@[0-9a-zA-Z]+(\.[0-9a-zA-Z]+)+$  /
    

正则的括号

	[]   中括号中，不识别多位数

 	var reg = /[abc]/
    console.log(reg.test('abc'));//true
     var reg1 = /^[1-9_]$/  //表示1到9或者_的任意一个
    console.log(reg1.test('9'));
    var reg2 = /[18-65]/  //1 8-6 5

 ()正则的小括号  
		1.改变正则的优先级

  		var reg = /^a|food$/;       //以a开头，以food结尾都返回true
        console.log(reg.test('a'));//true
        console.log(reg.test('aood'));//true
        console.log(reg.test('aoog'));//true
        console.log(reg.test('erfood'));//true

	 2.分组引用

  // \1 代指和第一个分组一模一样的内容
    var reg = /^(zhufeng)(peixun)\1\2$/
    console.log(reg.test('zhufeng'));//false
    console.log(reg.test('zhufengpeixunzhufeng'));//false
    console.log(reg.test('zhufengpeixunzhufengpeixun'));//true

	3.用于小正则捕获
    小括号要进行捕获，从左往右依次进行    

    var reg = /^-?(\d|[1-9]\d+)(\.(\d+))?$/
    console.log(reg.exec('35.6789'));

正则的match

 //match : 字符串方法  匹配   返回数组
        var str = 'zhufeng123peixun456';
        var arr = str.match(/\d+/g)
        console.log(arr);//正则match.html:14 (2) ["123", "456"]
        //加g代表全局捕获，捕获多次，把符合正则内容的字符串放到一个数组中

        //正则的修饰符
        //g:global ：全局
        //i：ignoreCase ：忽略大小写
        //m: mutiline  : 多行匹配

        var reg = /A/i;  //在字符串中出现a或A ，都返回true
        console.log(reg.test('abc'));//true

正则的replace

replace ： 字符串替换    原字符串不发生改变   会得到替换之后的返回值
    每次只能替换一个
  	var str = 'trueortrue'
    var newStr = str.replace('true','false').replace('true','false')
    console.log(newStr);//falseorfalse 

    结合正则
        (1)replacee(reg,str);用该正则对字符串形成捕获，把捕获到内容替换成后面的字符串

		var str = 'trueortrue'
        var newStr = str.replace(/true/g,false)
        console.log(newStr);//falseorfalse 

    正则和回调函数
        1.正则对字符串进行捕获，并且将回调函数的返回值覆盖捕获到的内容
        2.正则捕获几次，回调函数执行几次
        3.形参分别代表不同的值         

		  var str = 'trueortrue'
        var newStr = str.replace(/true/g,function(a,b,c){
            console.log(a);//true   true     //第一个参是捕获到的内容
            console.log(b);//0  6            //第二个参捕获的内容开始的索引位置
            console.log(c);//trueortrue     //原来字符串
        
            //console.log(100);
            return false
            
        })
        console.log(newStr);//falseorfalse  

replace案例

//把所有首字母大写
      var str = 'my name is niu,i am 28 years old';
        var ary = str.replace(/\b[a-z]/g,function(a,b){   //左边界
            a = a.toUpperCase() 
            console.log(a,b)   
            return a
        })
        console.log(ary);
         


 //把数字首字母大写
        var str = '20191224'
        var ary = ["零","壹","贰","叁","肆","伍","陆","柒","捌","玖","万","仟"];
        var aoe = str.replace(/\d/g,function(a,b){
            for(var i = 0;i<ary.length;i++){
                console.log(a);
                if(i = a ){
                    return ary[i]
                }
            }
            return a    
            //  return ary[arguments[0]]   //让捕获到的数字作为数组ary的索引，再返回
        })
        console.log(aoe);//贰零壹玖壹贰贰肆 */
        
     //把下面时间格式化成2019年12月24日16时02分30秒
        var  str = "2019-12-24 16:02:30";
        var  ary = ["年","月","日","时","分","秒"];
        var i = 0
        var aoe = '';
        var one = str.replace(/\d+/g,function(a,b){
            
           aoe += a + ary[i++]
           console.log(aoe);
            return aoe
        })
        console.log(aoe);
        



        // 加千分符，给下面的数字加','使其成为13,234,567,753,224
         var str = "13234567753224";
        var newStr = str.replace(/^(\d{1,3})((\d{3})+)$/,function(a,b,c){
            // console.dir(a);
            // console.log(b);
            // console.log(c);
            var part2 = c.replace(/\d{3}/g,function (d,e) {
                console.log(d);
                
                return ','+d
            })
            return b +part2
        })
        console.log(newStr);


        var str = "13234567753224";
        var newStr = str.replace(/\d/g,function(a,b){
            //arguments[0]  捕获到数字内容   arguments[1] 捕获内容对应的索引
            console.log(str.length);
            
            if((str.length-b-1)%3 === 0 && str.length-1 !== b){
                return a + ','
            }else{
                return a
            }
        })
        console.log(newStr);
        ```