JS基础笔记（3）

第70-82课（2020-3-28）

内建对象
宿主对象
自定义对象

数组Array 也是一个对象，和普通对象功能类似，也是用来存储一些值的，不同的是普通对象是使用字符串作为属性名的，而数组是使用数字来作为索引操作元素
索引从0开始的整数就是索引
数组的存储性能比普通对象要好，在开发中我们经常使用数组来存储一些数据

向数组中添加元素
语法： 数组 [ 索引 ] = 值 ;
读取数组中的元素
语法： 数组 [ 索引 ]
如果读取不存在的索引，不会报错，而是返回undefined

获取数组的长度，可以用length属性来获取数组的长度（元素的个数）
语法：数组 . lenth
对于连续的数组，使用length可以获取到数组的长度（元素的个数）
对于非连续的数组，使用length会获取到数组最大的索引+1，尽量不要创建非连续数组

修改length
如果修改的length大于原长度，则多出部分会空出来
如果修改的length小于原长度，则多出的元素会被删除

向数组的最后一个位置添加元素
语法：数组 [ 数组 . length ] =值 ;

var arr =new Array();    //创建数组对象
console.log(arr);       //输出""
console.log(typeof arr);    //输出object
arr[0]=10; 
arr[1]=22;
console.log(arr);    //输出"10,22"
console.log(arr[0]);    //输出"10"
console.log(arr[3]);    //输出undefined
//第一种情况
console.log(arr.length);   //输出"2"
arr[5]=7;
arr[11]=99;
console.log(arr);    //输出"10，22，，，，7，，，，，，99"
//第二种情况
arr.length=10;
console.log(arr.length);    //输出"10"
conaole.log(arr);   //输出"10,22,,,,,,,,"
arr.length=1;
console.log(arr.length);    //输出"1"
conaole.log(arr);    //输出"10"
//第三种情况
arr[arr.length] = 33;     
arr[arr.length] = 44;     //向数组最后一位置后添加元素
console.log(arr);   //输出"10,22,33,44"

使用字面量创建数组
语法 ：[ ];
使用字面量创建数组时，可以在创建时就指定数组中的元素
使用构造函数创建数组时，也可以同时添加元素，将要添加的元素作为构造函数的参数传递
元素之间使用逗号（，）隔开
var arr2 = new Array (10); //创建一个数组，长度为10，值都为空
var arr2 = new Array (10,22,33,44); //创建一个数组，长度为4，值分别为10，22，33，44

var arr =[1,2,3,4,10];
console.log(arr);    //输出"1，2，3，4，10"
arr =[10];    //创建一个数组，数组中只有一个元素10
var arr2 = new Array(10);   //创建一个长为10的数组
console.log(arr);   //输出"10"
console.log(arr2);  //输出",,,,,,,,,"
console.log(arr2.length);   //输出10

数组中的元素可以是任意的数据类型，也可以是对象，也可以是一个函数
数组中也可以放数组（称为二维数组）

var arr = ["hello",1,true,null,undefined];
var obj ={name:"孙悟空"};
arr[arr.length]=obj;   //添加对象
var arr2 =[{name:"孙悟空"},{name:"猪八戒"},{name:"沙和尚"}];  
var arr3 = [function(){alert(1)},function(){alert(2)}};
arr[0]();    //调用arr中的函数
var arr4 = [[1,2,3],[4,5,6],[7,8,9]};
console.log(arr);    //输出"1,2,3,4,5,6,7,8,9"
console.log(arr[0]);    //输出"1,2,3"

数组的方法
push()
可以向数组的末尾添加一个或多个元素，并返回数组的新长度，可以将要添加的元素作为方法的参数传递，这样这些元素将会自动添加到数组的末尾
该方法会将数组新的长度作为返回值返回
比length更方便，可以添加多个

pop()
可以删除数组的最后一个元素，并将被删除的元素作为返回值返回

unshift()
向数组开头添加一个或多个元素，并返回新的数组长度
向前面插入元素后，其他元素的索引会依次调整

shift()
可以删除数组的第一个元素，并将被删除的元素作为返回值返回

var arr = ["孙悟空","猪八戒","沙和尚"];
var result = arr.push("唐僧","蜘蛛精");
console.log(result);   //输出5
//第一种情况
arr.pop();
console.long(arr);   //输出"孙悟空，猪八戒，沙和尚，唐僧"
result = arr.pop();
console.log("result="result);   //输出唐僧
//第二种情况
arr.unshift("牛魔王","二郎神");
console.log(arr);   //输出"牛魔王,二郎神,孙悟空,猪八戒,沙和尚,唐僧,蜘蛛精"
result = arr.shift();
console.log(result);    //输出牛魔王

slice()
可以用来从数组提取指定元素
该方法不会改变原数组，而是将截取到的元素封装到一个新数组中返回
参数：
第一个，截取开始位置的索引 ，包含开始索引
第二个，截取结束位置的索引，不包含结束索引。第二个参数可以省略不写，此时会截取开始索引往后的所有元素
索引可以传递一个负值，如果传递一个负值，则从后往前计算 -1 倒数第一个，-2倒数第二个

splice()
可以用于删除数组中的指定元素
使用splice()会影响到原数组，会将指定元素从原数组中删除，并将被删除的元素作为返回值返回
参数：
第一个，表示开始位置的索引
第二个，表示删除的数量
第三个及以后，可以传递一些新的元素，这些元素将会自动插入到开始位置索引前面

var arr=["孙悟空","猪八戒","沙和尚","唐僧","白骨精"];
var result = arr.slice(0,2);
console.log(result);    //输出"孙悟空，猪八戒"
result = arr.slice(1,-2);
console.log(result);    //输出"猪八戒，沙和尚"

var result = arr.splice(0,2);
console.log(arr);   //输出"沙和尚，唐僧，白骨精"
console.log(result);    //输出"孙悟空，猪八戒"

var result = arr.splice(1,2);
console.log(result);    //输出"猪八戒，沙和尚"
。。
var result = arr.splice(0,1,"牛魔王");
console.log(arr);   //输出"牛魔王，猪八戒，沙和尚，唐僧，白骨精"
var result = arr.splice(,1,"牛魔王");
console.log(arr);   //输出"牛魔王，孙悟空，猪八戒，沙和尚，唐僧，白骨精" 会在开始位置索引的前面插入

练习

    var arr=[1,2,3,2,1,3,4,2,5];
    for(var i=0;i<arr.length;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]==arr[i]){
                arr.splice(j,1);
            }
        }
    }
    console.log(arr);

没有考虑两个相同的数连续的情况
如果出现了两个连续相同的数，如 [ 1,2,3,2,2]，则会输出 [1,2,3,2 ]
因为删除了j所在的元素后，后面的元素自动补位，此时不会再比较这个元素，所以我们需要再比较一次j所在位置的元素，使j自减

    var arr=[1,2,3,2,1,3,4,2,5];
    for(var i=0;i<arr.length;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]==arr[i]){
                arr.splice(j,1);
                j--;
            }
        }
    }
    console.log(arr);

concat()
可以连接两个或多个数组，并将新的数组返回
该方法不会对原数组产生影响

join()
该方法可以将数组转换为一个字符串
该方法不会对原数组产生影响，而是将转换后的字符串作为结果返回
在join()中可以指定一个字符串作为参数，这个字符串将会成为数组中元素的连接符。如果不知道链接符，则默认使用逗号（，）作为连接符

reverse()
该方法用来反转数组（前面的去后面，后面的去前面）
该方法会直接修改原数组

var arr = ["孙悟空","猪八戒"];
var arr2 = ["沙和尚","唐僧"];
//测试 concat()
var result = arr.concat(arr2);
var arr3 = ["白龙马"];
result = arr.concat(arr2,arr3,"牛魔王");
//测试 join()
var result = arr.join();
console.log(typeof arr);   //输出object
console.log(typeof result);   //输出string
result = arr.join("hello");
console.log(result);    //输出"孙悟空hello猪八戒"
result = arr.join("-");
console.log(result);    //输出"孙悟空-猪八戒"
//测试reverse()
arr.reverse();
console.log(arr);    //输出"猪八戒，孙悟空"

sort()
可以用来对数组中的元素进行排序
会影响原数组，默认按照Unicode编码进行排序
即使对于纯数字的数组，使用sort()排序时，也会按照Unicode编码排序，所以对数字排序时，可能会得到错误的结果
我们可以自己来指定排序的规则，可以在sort()中添加一个回调函数，来指定排序规则
回调函数需要定义两个形参，浏览器将会分别使用数组中的元素作为实参去调用回调函数，使用哪个元素调用不确定，但是肯定的是数组中a一定在b前面
浏览器会根据回调函数的返回值来决定元素的顺序
如果返回一个大于0的值，则元素会交换位置
如果返回小于0的值，则元素位置不变
如果返回0，则认为两个元素相等，也不交换位置

如果需要升序排序，则返回a-b
如果需要降序排序，则返回b-a

var arr = ["b","d","e","a","c"];
arr.sort();
console.log(arr);    //输出"a,b,c,d,e"
arr = [5,4,8,3,7,1,6,2];
arr.sort(function(a,b){
     return a-b;
}
console.log(arr);   //输出1，2，3，4，5，6，7，8

数组的遍历就是将数组中的所有元素都取出来

var arr = ["孙悟空","猪八戒","沙和尚"];
for(var i=0;i<arr.length;i++){
    console.log(arr[i]);
    }

练习

    function Person(){
       var name=this.name;
       var age=this.age; 
    }

    Person.prototype.toString() {
        console.log("name="+name+",age="+age);
    }
    
    var per = new Person("孙悟空",18);
    var per2 = new Person("猪八戒",28);
    var per3 = new Person("红孩儿",8);
    var per4 = new Person("蜘蛛精",16);
    var per5 = new Person("沙和尚",38);

    console.log(per);

出现的一些问题
1、构造函数未写形参
2、构造函数中赋值错误
3、添加toString方法错误，Person.prototype.toString()是调用toString()方法，应该是Person.prototype.toString=function(){}，且toString没有()

    <script type="text/javascript">
    function Person(name,age){
       this.name=name;
       this.age=age; 
    }

    Person.prototype.toString =function() {
        console.log("name="+name+",age="+age);
    }

    var per = new Person("孙悟空",18);
    var per2 = new Person("猪八戒",28);
    var per3 = new Person("红孩儿",8);
    var per4 = new Person("蜘蛛精",16);
    var per5 = new Person("沙和尚",38);

    //将这些person对象放入一个数组中
    var perArr = [per,per2,per3,per4,per5];
    console.log(perArr);
    
    var adult =[];
    function getAdult(){
        for(var i=0;i<perArr.length;i++){
            if(perArr[i].age>=18){
                //adult[adult.length]=perArr[i];
                adult.push(perArr[i]);
            }
        }
    }
    getAdult();
    console.log(adult);

如果想调用别的类中的成年人，此函数就不可使用。所以应该有个形参

    function getAdult(arr){
        var adult =[];
        for(var i=0;i<arr.length;i++){
            if(arr[i].age>=18){
                //adult[adult.length]=arr[i];
                adult.push(arr[i]);
            }
        }
        return adult;
    }
    var result=getAdult(perArr);
    console.log(result);

forEach()
一般我们都是使用for循环去遍历数组，JS中还为我们提供了一个方法用来遍历数组
这个方法对于IE只支持IE8以上的浏览器，IE8及以下的浏览器不支持该方法，所以如果需要兼容IE8，不要使用forEach()方法
forEach()方法需要一个函数作为参数，像这种由我们创建但是不由我们调用的，我们称为回调函数
数组中有几个元素，函数就会执行几次，每次执行时，浏览器会将遍历到的元素以实参的形式传递进来，我们可以定义形参，来读取这些内容
浏览器会在回调函数中传递三个参数：
第一个参数，就是当前正在遍历的元素（value）
第二个参数，就是当前正在遍历的元素的索引（index）
第三个参数，就是正在遍历的数组（obj）

var arr = ["孙悟空","猪八戒","沙和尚","唐僧"];

arr.forEach(function(value,index,obj){
console.log(value);  
console.log(index);
console.log(obj);
});

练习

    function Person (name,age){
        this.name=name;
        this.age=age;
    }

    Person.prototype.toString = function() {
        console.log("name:"+name+",age:"+age);
    };

    var per = new Person("孙悟空",18);
    console.log(per);    //第一题
    var per2 = new Person("猪八戒",28);
    var per3 = new Person("沙和尚",38);

    var arr = [per,per2,per3];
    console.log(arr);    //第二题

    arr.forEach(function (value) {   
        console.log(value);    //第三题
      })    

第四题：
push()向数组最后添加元素
pop()删除数组最后一个元素
unshift()向数组最前添加元素
shift()删除数组最前一个元素

    var arr =[1,2,3,3,4,5,2,2,2,6,7];
    for(var i=0;i<arr.length;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]==arr[j]){
                arr.splice(j,1);
                j--;
            }         
        }
    }
    console.log(arr);   //第五题

函数的方法
call()和apply()
这两个方法都是函数对象的方法，需要通过函数对象来调用
对函数调用call()和apply()都会调用函数执行
在调用call()和apply()可以将一个对象指定为第一个参数，此时这个对象将会成为函数执行时的this
区别：
call()方法可以将实参在对象指定为第一个参数
apply()方法需要将实参封装到一个数组中统一传递

this的情况：
1、以函数形式调用时，this永远都是window
2、以方法的形式调用时，this是调用方法的对象
3、以构造函数的形式调用时，this是新创建的那个对象
4、使用apply和call调用时，this是指定的那个对象

    function fun(){
        alert("我是fun函数");
    }
    //第一种情况
    fun.call();    //立即弹出alert
    fun.apply();   //立即弹出alert
    fun();    //三个效果相同

function fun(){
alert(this);
}
var obj={};
fun.call(obj);   //弹出object，this为obj
fun.apply(obj);   //弹出object
fun（obj）;    //弹出window

var obj={name:"obj",sayName:function(){alert(this.name);}};
var obj2={name:"obj2"};
obj.sayName();     //弹出obj
obj.sayName.apply(obj2);   //弹出obj2

function fun(a,b){
console.log(a);
console.log(b);
}
var obj={};
fun.call(obj);    //输出undefined，undefined
fun.call(obj,2,3);   //输出2，3
fun.apply(obj,2,3);  //报错
fun.apply(obj,[2,3]);  //输出2，3

arguments
在调用函数时，浏览器每次都会传递两个隐含的参数：
1、函数的上下文对象 this
2、封装实参的对象arguments
arguments是一个类数组对象，它也可以通过索引来操作数据，也可以获取长度
在调用函数时，我们所传递的实参都会在arguments中保存
arguments.length可以用来获取实参的长度
即使不定义形参，也可以通过arguments来使用实参，只不过比较麻烦
arguments [ 0 ] 表示第一个实参
arguments [ 1 ] 表示第二个实参…

它有一个属性叫做callee，这个属性对应一个函数对象，就是当前正在指向的函数对象

function fun(){
console.log(arguments);    //输出[object Arguments]
console.log(argument instanceof Array);  //输出false
console.log(Array.isArray(arguments));   //输出false
console.log(arguments.length);   //输出0
}
fun();   
fun(hello);

function fun(){
console.log(arguments.length);   //输出1
console.log(arguments[0]);   //输出hello
console.log(arguments.callee);  //输出此函数
console.log(arguments.callee==fun);   //输出true 
}
fun(hello);

Array.isArray(arguments)

Date对象
在JS使用Date对象表示一个时间
如果直接使用构造函数创建一个Date对象，则会封装为当前代码执行的时间
创建一个指定的时间对象，需要在构造函数中传递一个表示时间的字符串作为参数
日期的格式： 月份/日/年 时：分：秒

getDate() 获取当前日期对象是几日（1~31）
getDay() 获取当前日期对象是周几（0~6）0表示周日
getMonth() 获取当前时间对象的月份（0~11）0表示1月，1表示2月，11表示12月
getFullYear() 获取当前日期的年份
getHours() 获取Date对象的小时（0~23）
getMinutes() 获取Date对象的分钟（0~59）
getSeconds() 获取Date对象的秒数（0~59）
getMilliseconds() 获取对象的毫秒（0~999）

getTime() 获取当前日期对象的时间戳
时间戳值得是格林威治标准时间（1970年1月1日，0时0分0秒）到当前日期所花费的毫秒数（1秒=1000毫秒）
计算机底层在保存时间时使用的都是时间戳
var 变量 = Date.now();获取当前的时间戳，变量的值就是执行此行代码的时间戳
可以利用时间戳来测试代码的执行性能，分别在代码前后获取时间戳，做减法

var d = new Date();
var d2 = new Date("03/28/2020 21:48:20");
console.log(d);   //输出时间
console.log(d2);   //输出指定时间
var date = d2.getDate();    //28
var day = d2.getDay();    //6
var month = d2.getMonth();  //2
var year = d2.getFullYear();  //2020
。。
var d3 = new Date("1/1/1970 0:0:0");
time = d3.getTime();
console.log(time);   //输出-28800000 这里设置的1970年是北京时间，与标准时间有时间差

Math
Math和其他对象不同，它不是一个构造函数，它属于一个工具类，不用创建对象，它里面封装了数学运算相关的属性和方法，如：Math.PI 表示圆周率

Math.abs() 可以用来计算一个数的绝对值
Math.ceil() 可以对一个数进行向上取整，小数位只要有值就自动进1
Math.floor() 可以对一个数进行向下取整，小数部分会被舍掉
Math.round() 可以对一个数进行四舍五入取整
Math.random() 可以生成一个0~1之间的随机数，不包含0，1
生成一个0~10的随机数
Math.round ( Math.random() * 10 )
生成一个0~x间的随机数
Math.round ( Math.random() * x )
生成一个 [ 1~10 ) 的随机数
Math.round ( Math.random() *9 +1)
生成一个x~y之间的随机数
Math.round (Math.random() *( y-x ) + x )

Math.max() 可以获取多个数中的最大值
Math.min() 可以获取多个数中的最小值

Math.pow ( x , y ) 返回x的y次幂
Math.sqrt() 求值的平方根

console.log(Date);   //输出本地函数
console.log(Math);   //输出 [object Math]
console.log(Math.abs(-2));  //输出2

var max=Math.max(10,45,66);
console.log(max);   //输出66

console.log(Math.pow ( 2 , 3 ));   //输出8

第83~90课（2020-3-29）

包装类
基本数据类型 Srting Number Boolean Null Undefined
引用数据类型 Object
在JS中为我们提供了三个包装类，通过这三个包装类可以将基本数据类型转换为对象
String() 可以将基本数据类型字符串转换为String对象
Number() 可以将基本数据类型数字转换为Number对象
Boolean() 可以将基本数据类型字符串转换为Boolean对象
但是注意，我们在实际应用中不会使用基本数据类型的对象，如果上基本数据类型的对象，在做一些比较时可能会带来一些不可预期的结果

方法和属性只能添加给对象，不能添加给基本数据类型
当我们对一些基本数据类型的值去调用属性和方法时，浏览器会临时使用包装类将其转换为对象，然后再调用对象的属性和方法，调用完以后再将其转换为基本数据类型

var num = new Number(3);
console.log(num);      //输出3
console.log(typeof num);   //输出object
num.hello="moring";
console.log(num.hello);   //输出moring，num为一个对象，所以可以添加属性

var bool = new Boolean(true);
var bool2 = true;
console.log(bool \== bool2);    //输出true，自动转换类型
console.log(bool \=== bool2);  //输出false
。。
var b = new Boolean(false); 
if(b){     //对象转为布尔值都为true
alert("我运行了");    //弹出我运行了
}
。。
var s = 123 ;
s.hello = "你好" ;
console.log(s.hello);   //输出undefined。s在添加hello属性时被临时转换为对象，添加完hello属性后该对象就被销毁，s类型回到数字。此处调用s.hello时，重新将s临时转换为对象，这个对象与添加属性的对象并不是同一个，所以它没有hello属性，故输出undefined

字符串的相关方法
咋底层字符串是以字符数组的形式保存的 [ “H” , “e” , " l " … ] （空格也算一个元素）
length属性 可以获取字符串的长度
charAt() 可以返回字符串中指定位置的字符，根据索引获取指定的字符
charCodeAt() 获取指定位置字符的字符编码（Unicode编码）
String . fromCharCode() 可以根据字符编码去获取字符 (与变量无关）输入的字符编码默认是10进制，如果输入的是16进制，需要添加0x

concat() 可以连接两个或多个字符串，作用和+一样
indexOf() 可以检索一个字符串中是否含有指定内容，如果字符串中含有该内容，则会返回其第一次出现的索引。如果没有找到指定的内容，则返回 - 1。可以指定一个第二个参数，指定开始查找的位置
lastIndexOf() 该方法与indexOf一样，也可以指定开始查找的位置，不同的是indexOf是从前往后找，而lastIndexOf是从后往前找。

var str = "Hello World" ;

console.log(str[1]);   //输出 e
console.log(str.length);   //输出 11（空格也算一个元素）
var result = str.charaAt(1);   //输出 e，可用str[1]代替
result = str.charCodeAt(1);     //输出 101
result = String.fromCharCode(101);   //输出 e

result = str.concat("你好","再见");    //输出 Hello World你好再见
result = str.indexOf("o");    //输出4
result = str.indexOf("o",5);   //输出 7 
result = str.lastIndexOf("o",5);   //输出4

slice() 可以从字符串中截取指定的内容，不会影响原字符串，而是将截取到的内容返回
参数：1、开始截取位置的索引（包括开始位置）2、结束位置的索引（不包括结束位置）
如果省略第二个参数，则会截取到后面所有的
也可以传递一个负数作为参数，负数的话将从后面计算
substring() 可以用来截取一个字符串，和slice()类似
参数：1、开始截取位置的索引（包括开始位置）2、结束位置的索引（不包括结束位置）
不同的是不能接收负值作为参数，如果传递了一个负值，则默认0。而且会自动调整参数的位置，如果第二个参数小于第一个，则自动交换
substr() 用来截取字符串（ES没有对该方法进行标准化，所以不要使用）
参数：1、开始截取位置的索引 2、截取的长度

str = "abcdefjhijk";
var result = str.slice(0,2);  //输出ab
result = str.slice(1,-1);  //输出bcdefjhij
result = str.substring(2,-1);   //即（2，0），即（0，2），输出ab
result = str.substr(3,2);    //输出de

split() 可以将一个字符串拆分为一个数组
参数：需要一个字符串作为参数，将会根据该字符串去拆分数组
如果传递一个空串作为参数，则会将每个字符都拆分为数组中的一个元素
toUpperCase() 将一个字符串转换为大写并返回
toLowerCase() 将一个字符串转换为小写并返回

var str = "abc,bcd,efg,hij";
var result = str.split(",");    //输出[ "abc" ,"bcd","efg","hij" ]。typrof为object
console.log(Array.isArray(result));   //输出true

正则表达式 RegularExpression又称规则表达式，用于定义一些字符串的规则，计算机可以根据正则表达式检查一个字符串是否符合规则，或者将字符串中符合规则的内容提取出来
语法：var 变量 = new RegExp ( “正则表达式” , “匹配模式” );
使用typeof检查正则表达式，会返回object（对象除了函数检查为function，其他均为object）
var reg = new RegExp(“a”); //这个正则表达式可以用来检查一个字符串中是否含有a

使用字面量创建正则表达式，这种方法更加简单，但是使用构造函数创建更加灵活
语法：var 变量 = / 正则表达式 / 匹配模式
var reg = /a/i;

在构造函数中可以传递一个匹配模式作为第二个参数，可以是：i 忽略大小写、g 全局匹配模式
可以为一个正则表达式设置多个匹配模式，且顺序无所谓
正则表达式的方法
test() 使用这个方法可以用来检查一个字符串是否符合正则表达式的规则，如果符合则返回true，否则返回false

var reg = new RegExp("a");  //这个正则表达式可以用来检查一个字符串中是否含有a
console.log(reg);    //输出/a/，typeof为object
var str = "a";
var result = reg.test(str);   //输出true

使用 | 表示或者的意思
中括号 [ ] 里的内容也是或的关系
[ ab ] == a | b
[ a - z ] 任意小写字母
[ A - Z ] 任意大写字母
[ A - z ] 任意字母
[ 0 - 9 ] 任意数字
[^ ] 任何不在中括号里的

var reg = /a|b|c/;  //检查字符串中是否含有a或b或c
reg =/a[bcd]a/;   //检查字符串中是否含有aba，aca，ada
reg =/[^ab]/;    //除了ab
console.log(reg.test("abc"));   //输出true
console.log(reg.test("a"));   //输出false

量词通过量词可以设置一个内容出现的次数
量词只对它前面的一个内容起作用，可添加（）
{ n } 正好出现n次
{ m, n } 出现m~n次
{ m, } 出现m次以上
+ 至少一个，相当于{ 1，}
* 0个或多个，相当于{ 0，}
? 0个或1个，相当于{ 0,1 }

var reg = /a{3} /;     //检查一个字符串是否含有aaa
var reg = /(ab){ 3}/;   //检查是否含有ababab
var reg =/ab{ 3 }c/;    //检查是否含有abbbc
var reg =/ab{1,3}c/;    //检查是否含有abc，abbc，abbbc
var reg =/ab+c/;     
var reg =/ab*c/;
var reg =/ab?c/;

检查是否以a开头
^ 表示开头
$ 表示结尾
如果在正则表达式中同时使用^ $，则要求字符串必须完全符合正则表达式

var reg =/^a/;    //开头的a
var reg =/a$/;    //结尾的a
var reg =/^a$/;   //a开头的同时也是结尾，所以只有"a" 才是true
var reg =/^a|a$/;   //以a开头或者以a结尾

练习

// ^1   [3-9]   [0-9]{9}$
var phoneStr ="13854976584";
var phoneReg =/^1[3-9][0-9]{9}$/; 
console.log(phoneReg.test(phoneStr));  

检查一个字符串中是否含有 .
. 表示任意字符
\\ 表示 \
在正则表达式中使用\作为转义字符

使用构造函数时，由于它的参数是一个字符串，而\是字符串中的转义字符，如果要使用 \ ，则需要使用 \\ 来代替

var reg =/\./;   //检查.
var reg =/\\/;   //检查\

reg =new RegExp("\.");    //需要两个\\,才会输出\.
console.log(reg.test("$#%@"));   //输出true
console.log(reg);    //输出/./

\w 任意字母，数字、_ （相当于 [ A-z0-9_ ] ）
\W 除了任意字母，数字、_ （相当于 [ ^A-z0-9_ ] ）
\d 任意数字 （相当于 [ 0-9 ] ）
\D 除了数字 （相当于 [ ^0-9 ] ）
\s 空格
\S 除了空格
\b 单词边界
\B 除了单词边界

reg = /child/;
console.log(reg.test("Hello Children");  //输出true
reg = /\bchild\b/;
console.log(reg.test("Hello Children");  //输出false

//去掉字符串中的空格，就是使用""来替换空格
var str ="     he   llo    ";
str =str.replace(/\s/g,"");   //这种方法也会去掉中间的空格
console.log(str);   //输出hello
//去掉开头的空格
str =str.replace(/^\s*/,"");
console.log(str);   //输出"he   llo          "
//去掉结尾的空格
str =str.replace(/\s*$/,"");
//合并
str = str.replace(/^\s*|\s*$/g,"");

字符串和正则相关的方法
split() 可以将一个字符串拆分为一个数组
方法中可以传递一个正则表达式作为参数，这样方法将会根据正则表达式去拆分字符串
这个方法即使不指定全局匹配，也会全部拆分

match() 可以根据正则表达式，从一个字符串中将符合条件的内容提取出来
默认情况下，match只会找到第一个符合要求的内容，找到以后就停止检索。我们可以设置正则表达式为全局匹配模式，这样就会匹配到所有的内容
match() 会将匹配到的内容封装到一个数组中返回，即使只查询到一个结果

var str = "1a2b3c4d5e6f7";
//根据任意字母将字符串拆分
var result = str.split(/[A-z]/);     //输出1，2，3，4，5，6，7

result = str.match(/[A-z]/);    //输出 a
result = str.match(/[A-z]/g);    //输出 a，b,c,d,e,f
var str2 ="1a2b3c4d5e6f7A8B9C";
result = str2.math(/[a-z]/gi);   //输出a，b,c,d,e,f,A,B,C。ig既忽略大小写，又全局匹配模式

search() 可以搜索字符串中是否含有指定内容
如果搜索到指定内容，则会返回第一次出现的索引，如果没有搜索到返回-1
它可以接收一个正则表达式作为参数，然后根据正则表达式去检索字符串
只会查找第一个，即使设置了全局匹配也没用

replace() 可以将字符串中指定内容替换为新的内容
参数：
1、被替换的内容 ，可以接受一个正则表达式作为参数
2、新的内容
默认只会替换第一个

var str = "hello abc hello aec afc";
//搜索字符串中是否含有abc，或aec，或afc
result = str.search（/a[bef]c/);    //输出 6

var str2 = "1a2b3c4d5e6f7a";
result = str.replace("a","@@");  //输出1@@2b3c4d5e6f7a
result = str.replace(/a/g,"@@");  //输出1@@2b3c4d5e6f7@@

练习

//   \w{3,}    (\.\w+)*    @    [A-z0-9]+    (\.[A-z]{2,5}){1,2}
var emailReg=/\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}/;
console.log(emailReg.test("[email protected]"));    //输出true
//应该加上 邮箱的开头和结尾
var emailReg=/^\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}$/;