1、數(shù)字對象（Number）

1.1 、屬性

屬性	描述
Number.MAX_VALUE	JavaScript 中所能表示的最大值
Number.MIN_VALUE	JavaScript 中所能表示的最小值
Number.NaN	非數(shù)字
Number.NEGATIVE_INFINITY	負無窮，在溢出時返回
Number.POSITIVE_INFINITY	正無窮，在溢出時返回
Number.EPSILON	表示 1 與 Number 所能表示的大于 1 的最小浮點數(shù)之間的差
Number.MIN_SAFE_INTEGER	最小安全整數(shù)，即 -9007199254740991
Number.MAX_SAFE_INTEGER	最大安全整數(shù)，即 9007199254740991

console.log(Number.MAX_VALUE);//1.7976931348623157e+308
console.log(Number.MIN_VALUE);//5e-324
console.log(Number.NaN);//NaN
console.log(Number.NEGATIVE_INFINITY);//-Infinity
console.log(Number.POSITIVE_INFINITY);//Infinity
console.log(Number.EPSILON);//2.220446049250313e-16
console.log(Number.MAX_SAFE_INTEGER);//9007199254740991
console.log(Number.MIN_SAFE_INTEGER);//-9007199254740991

1.2、方法

方法	描述
Number.parseFloat()	將字符串轉(zhuǎn)換成浮點數(shù)，和全局方法 parseFloat() 作用相同
Number.parseInt()	將字符串轉(zhuǎn)換成整型數(shù)字，和全局方法 parseInt() 作用相同
Number.isFinite()	判斷 Number 對象是否為有窮數(shù)
Number.isInteger()	判斷 Number 對象是否為整數(shù)
Number.isNaN()	判斷 Number 對象是否為 NaN 類型
Number.isSafeInteger()	判斷 Number 對象是否為安全整數(shù)，即范圍為 -(2?3 - 1)到 2?3 - 1 之間的整數(shù)
Number.toString()	把 Number 對象轉(zhuǎn)換為字符串，使用指定的基數(shù)
Number.toLocaleString()	把 Number 對象轉(zhuǎn)換為字符串，使用本地數(shù)字格式順序
Number.toFixed()	把 Number 對象轉(zhuǎn)換為字符串，結(jié)果的小數(shù)點后有指定位數(shù)的數(shù)字
Number.toExponential()	把 Number 對象的值轉(zhuǎn)換為指數(shù)計數(shù)法
Number.toPrecision()	把 Number 對象格式化為指定的長度
Number.valueOf()	返回一個 Number 對象的基本數(shù)字值

var a=new Number(125.246);
console.log(Number.parseFloat(a));// 125.246
console.log(Number.parseInt(a));//520
console.log(Number.isFinite(a));// false
console.log(Number.isInteger(a));//false
console.log(Number.isNaN(a));//false
console.log(Number.isSafeInteger(a));//false
console.log(Number.toString(a));//
console.log(Number.toLocaleString(a));
console.log(Number.valueOf(a));

2、數(shù)組對象

2.1、概述

數(shù)組也是對象的一種，數(shù)組是一種用于表達有順序關系的值的集合的語言結(jié)構(gòu)，也就是同類數(shù)據(jù)元素的有序集合。

數(shù)組的存儲性能比普通對象要好，在開發(fā)中我們經(jīng)常使用數(shù)組來存儲一些數(shù)據(jù)。但是在JavaScript中是支持數(shù)組可以是不同的元素，這跟JavaScript的弱類型有關，此處不用糾結(jié)，我們大多數(shù)時候都是相同類型元素的集合。數(shù)組內(nèi)的各個值被稱作元素，每一個元素都可以通過索引（下標）來快速讀取，索引是從零開始的整數(shù)。

使用typeof檢查一個數(shù)組對象時，會返回object。

2.2、創(chuàng)建數(shù)組

2.2.1、使用對象創(chuàng)建

//同類型有序數(shù)組創(chuàng)建
var array1 = new Array();
array1[0] = 1;
array1[1] = 2;
array1[2] = 3;
array1[3] = 4;
array1[4] = 5;
console.log(array1);
//不同類型有序數(shù)組創(chuàng)建
var array2 = new Array();
array2[0] = 1;
array2[1] = "2";
array2[2] = 3;
array2[3] = "4";
array2[4] = 5;
console.log(array2);

2.2.2、使用字面量創(chuàng)建

//同類型有序數(shù)組創(chuàng)建
var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
console.log(arr1);
//不同類型有序數(shù)組創(chuàng)建
var arr2 = [1, "2", 3, "4", 5, "6", 7, "8", 9, "0"];
console.log(arr2);

2.3、遍歷數(shù)組

for (i = 0; i < arr1.length; i++) {console.log(arr1[i]);
}
//使用for of遍歷數(shù)組
for (var i of arr1) {console.log(i+":"+i);
}

2.4、數(shù)組屬性

constructor屬性演示：返回創(chuàng)建數(shù)組對象的原型函數(shù)

var arr = [1,2,3,4];
console.log(arr.constructor);

length屬性演示：設置或返回數(shù)組元素的個數(shù)

var arr = [1,2,3,4];
console.log(arr.length);//4

2.5、數(shù)組方法

push()方法：該方法可以向數(shù)組的末尾添加一個或多個元素，并返回數(shù)組的新的長度

var arr=[1,2,3,4,5];
var num=arr.push(6,7);
console.log(arr);// [1,2,3,4,5,6,7]
console.log(num);// 7

pop()方法：該方法可以刪除數(shù)組的最后一個元素，并將被刪除的元素作為返回值返回

var arr=[1,2,3,4,5];
var num=arr.pop();
console.log(arr);// [1,2,3,4]
console.log(num);// 5

unshift()方法：該方法向數(shù)組開頭添加一個或多個元素，并返回新的數(shù)組長度

var arr=[1,2,3,4,5];
var num=arr.unshift("a","b",true);
console.log(arr);// [ 'a', 'b', true, 1, 2, 3, 4, 5 ]
console.log(num);// 8

shift()方法：該方法可以刪除數(shù)組的第一個元素，并將被刪除的元素作為返回值返回

var arr=[1,2,3,4,5];
var num=arr.shift();
console.log(arr);// [2,3,4,5]
console.log(num);// 1

forEach()方法：該方法可以用來遍歷數(shù)組

forEach()方法需要一個函數(shù)作為參數(shù)，像這種函數(shù)，由我們創(chuàng)建但是不由我們調(diào)用的，我們稱為回調(diào)函數(shù)。數(shù)組中有幾個元素函數(shù)就會執(zhí)行幾次，每次執(zhí)行時，瀏覽器會將遍歷到的元素，以實參的形式傳遞進來，我們可以來定義形參，來讀取這些內(nèi)容，瀏覽器會在回調(diào)函數(shù)中傳遞三個參數(shù)：

第一個參數(shù)：就是當前正在遍歷的元素
第二個參數(shù)：就是當前正在遍歷的元素的索引
第三個參數(shù)：就是正在遍歷的數(shù)組

var arr = [1, 2, 3, 4, 5];
arr.forEach(function (value, index, obj) {console.log(value + " #### " + index + " #### " + obj);
})

slice()方法：該方法可以用來從數(shù)組提取指定元素，該方法不會改變元素數(shù)組，而是將截取到的元素封裝到一個新數(shù)組中返回

參數(shù)：

第一個參數(shù)：截取開始的位置的索引，包含開始索引
第二個參數(shù)：截取結(jié)束的位置的索引，不包含結(jié)束索引，第二個參數(shù)可以省略不寫，此時會截取從開始索引往后的所有元素
注意：索引可以傳遞一個負值，如果傳遞一個負值，則從后往前計算，-1代表倒數(shù)第一個，-2代表倒數(shù)第二個。

        var arr = [1, 2, 3, 4, 5];console.log(arr.slice(0,2));console.log(arr.slice(2));console.log(arr.slice(-5,4));

splice()方法：該方法可以用于刪除數(shù)組中的指定元素，該方法會影響到原數(shù)組，會將指定元素從原數(shù)組中刪除，并將被刪除的元素作為返回值返回

參數(shù)：

第一個參數(shù)：表示開始位置的索引
第二個參數(shù)：表示要刪除的元素數(shù)量
第三個參數(shù)及以后參數(shù)：可以傳遞一些新的元素，這些元素將會自動插入到開始位置索引前邊

        var arr = [1, 2, 3, 4, 5];var result1=arr.splice(2,2,"A");console.log(arr);console.log(result1);

concat()方法：該方法可以連接兩個或多個數(shù)組，并將新的數(shù)組返回，該方法不會對原數(shù)組產(chǎn)生影響

        var arr1 = [1, 2, 3, 4, 5];var arr2=["A","B","C"];var arr3=["一","二"];console.log(arr1.concat(arr2,arr3,"壹","貳"));

join()方法：該方法可以將數(shù)組轉(zhuǎn)換為一個字符串，該方法不會對原數(shù)組產(chǎn)生影響，而是將轉(zhuǎn)換后的字符串作為結(jié)果返回，在join()中可以指定一個字符串作為參數(shù)，這個字符串將會成為數(shù)組中元素的連接符，如果不指定連接符，則默認使用，作為連接符

        var arr1 = [1, 2, 3, 4, 5];var arr2=["A","B","C"];var arr3=["一","二"];console.log(arr1.join("##"));

reverse()方法：該方法用來反轉(zhuǎn)數(shù)組（前邊的去后邊，后邊的去前邊），該方法會直接修改原數(shù)組

        var arr1 = [1, 2, 3, 4, 5];arr1.reverse();console.log(arr1);

sort()方法：該方法可以用來對數(shù)組中的元素進行排序，也會影響原數(shù)組，默認會按照Unicode編碼進行排序

        var arr1 = [1, 7, 3, 5, 4];arr1.sort();console.log(arr1);

注意：即使對于純數(shù)字的數(shù)組，使用sort()排序時，也會按照Unicode編碼來排序，所以對數(shù)字進排序時，可能會得到錯誤的結(jié)果。

        var arr1 = [1, 7, 3, 15, 4];arr1.sort();console.log(arr1);

我們可以自己來指定排序的規(guī)則，我們可以在sort()添加一個回調(diào)函數(shù)，來指定排序規(guī)則，回調(diào)函數(shù)中需要定義兩個形參，瀏覽器將會分別使用數(shù)組中的元素作為實參去調(diào)用回調(diào)函數(shù)，使用哪個元素調(diào)用不確定，但是肯定的是在數(shù)組中a一定在b前邊，瀏覽器會根據(jù)回調(diào)函數(shù)的返回值來決定元素的順序，如下：

如果返回一個大于0的值，則元素會交換位置
如果返回一個小于0的值，則元素位置不變
如果返回一個等于0的值，則認為兩個元素相等，也不交換位置
經(jīng)過上邊的規(guī)則，我們可以總結(jié)下：

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

        var arr1 = [1, 7, 3, 15, 4];arr1.sort(function(a,b){return a-b;});console.log(arr1);

3、函數(shù)對象

3.1、call()和apply()

call()和apply()這兩個方法都是函數(shù)對象的方法，需要通過函數(shù)對象來調(diào)用，當對函數(shù)調(diào)用call()和apply()都會調(diào)用函數(shù)執(zhí)行，在調(diào)用call()和apply()可以將一個對象指定為第一個參數(shù)，此時這個對象將會成為函數(shù)執(zhí)行時的this，call()方法可以將實參在對象之后依次傳遞，apply()方法需要將實參封裝到一個數(shù)組中統(tǒng)一傳遞

call()方法

var name="外部";
function fun(a, b) {console.log("a = " + a);console.log("b = " + b);console.log("fun = " + this.name);
}
var obj={name:"obj",sayName:function(){console.log(this.name);}
}
fun(6,8);
fun.call(obj,7,4);

apply()方法

var name="外部";
function fun(a, b) {console.log("a = " + a);console.log("b = " + b);console.log("fun = " + this.name);
}
var obj={name:"obj",sayName:function(){console.log(this.name);}
}
fun(6,8);
fun.apply(obj,[2,3]);

3.2、this指向

• 以函數(shù)形式調(diào)用時，this永遠都是window
• 以方法的形式調(diào)用時，this是調(diào)用方法的對象
• 以構(gòu)造函數(shù)的形式調(diào)用時，this是新創(chuàng)建的那個對象
• 使用call和apply調(diào)用時，this是傳入的那個指定對象

3.3、arguments參數(shù)

在調(diào)用函數(shù)時，瀏覽器每次都會傳遞進兩個隱含的參數(shù)：

1. 函數(shù)的上下文對象： this
2. 封裝實參的對象： arguments

arguments是一個類數(shù)組對象，它也可以通過索引來操作數(shù)據(jù)，也可以獲取長度，在調(diào)用函數(shù)時，我們所傳遞的實參都會在arguments中保存，比如：arguments.length 可以用來獲取實參的長度，我們即使不定義形參，也可以通過arguments來使用實參，只不過比較麻煩，例如：

arguments[0]：表示第一個實參
arguments[1]：表示第二個實參
…
它里邊有一個屬性叫做callee，這個屬性對應一個函數(shù)對象，就是當前正在指向的函數(shù)的對象。

var fun=function(a,b){console.log(arguments[0]);console.log(arguments[1]);console.log(arguments.length);console.log(arguments.callee);console.log(arguments.callee==fun);
}
fun(1,2);

4、Date對象

在JavaScript中使用Date對象來表示一個時間，如果直接使用構(gòu)造函數(shù)創(chuàng)建一個Date對象，則會封裝為當前代碼執(zhí)行的時間。

var time1 = new Date();
var time2 = new Date(1517356800000);
var time3 = new Date("2018/12/25 12:13:14");
var time4 = new Date(2020, 9, 12, 15, 16, 17);
document.write(time1 + "<br>");     // 輸出：Fri Jul 23 2021 13:41:39 GMT+0800 (中國標準時間)
document.write(time2 + "<br>");     // 輸出：Wed Jan 31 2018 08:00:00 GMT+0800 (中國標準時間)
document.write(time3 + "<br>");     // 輸出：Tue Dec 25 2018 12:13:14 GMT+0800 (中國標準時間)
document.write(time4 + "<br>");     // 輸出：Mon Oct 12 2020 15:16:17 GMT+0800 (中國標準時間)console.log(time1);
console.log(time1.getFullYear());//獲取當前日期對象的年份(四位數(shù)字年份)
console.log(time1.getMonth()+1);//獲取當前日期對象的月份(0 ~ 11)
console.log(time1.getDate());//獲取當前日期對象的日數(shù)(1 ~ 31)
console.log("星期"+time1.getDay());//獲取當前日期對象的日數(shù)(星期幾)
console.log(time1.getHours());//獲取當前日期對象的小時(0 ~ 23)
console.log(time1.getMinutes());//獲取當前日期對象的分鐘(0 ~ 59)
console.log(time1.getSeconds());//獲取當前日期對象的秒鐘(0 ~ 59)
console.log(time1.getMilliseconds());//獲取當前日期對象的毫秒(0 ~ 999)

5、Math對象

Math和其它的對象不同，它不是一個構(gòu)造函數(shù)，它屬于一個工具類不用創(chuàng)建對象，它里邊封裝了數(shù)學運算相關的屬性和方法。

/*固定值*/
console.log("PI = " + Math.PI);
console.log("E  = " + Math.E);
console.log("===============");
/*正數(shù)*/
console.log(Math.abs(1));        //可以用來計算一個數(shù)的絕對值
console.log(Math.ceil(1.1));     //可以對一個數(shù)進行向上取整，小數(shù)位只有有值就自動進1
console.log(Math.floor(1.99));   //可以對一個數(shù)進行向下取整，小數(shù)部分會被舍掉
console.log(Math.round(1.4));    //可以對一個數(shù)進行四舍五入取整
console.log("===============");
/*負數(shù)*/
console.log(Math.abs(-1));       //可以用來計算一個數(shù)的絕對值
console.log(Math.ceil(-1.1));    //可以對一個數(shù)進行向上取整，小數(shù)部分會被舍掉
console.log(Math.floor(-1.99));  //可以對一個數(shù)進行向下取整，小數(shù)位只有有值就自動進1
console.log(Math.round(-1.4));   //可以對一個數(shù)進行四舍五入取整
console.log("===============");
/*隨機數(shù)*/
//Math.random()：可以用來生成一個0-1之間的隨機數(shù)
//生成一個0-x之間的隨機數(shù)：Math.round(Math.random()*x)
//生成一個x-y之間的隨機數(shù)：Math.round(Math.random()*(y-x)+x)
console.log(Math.round(Math.random() * 10));            //生成一個0-10之間的隨機數(shù)
console.log(Math.round(Math.random() * (10 - 1) + 1));  //生成一個1-10之間的隨機數(shù)
console.log("===============");
/*數(shù)學運算*/
console.log(Math.pow(12, 3));   //Math.pow(x,y)：返回x的y次冪
console.log(Math.sqrt(4));      //Math.sqrt(x) ：返回x的平方根

6、String對象

6.1、概述

在JS中為我們提供了三個包裝類，通過這三個包裝類可以將基本數(shù)據(jù)類型的數(shù)據(jù)轉(zhuǎn)換為對象

String()：可以將基本數(shù)據(jù)類型字符串轉(zhuǎn)換為String對象
Number()：可以將基本數(shù)據(jù)類型的數(shù)字轉(zhuǎn)換為Number對象
Boolean()：可以將基本數(shù)據(jù)類型的布爾值轉(zhuǎn)換為Boolean對象
但是注意：我們在實際應用中不會使用基本數(shù)據(jù)類型的對象，如果使用基本數(shù)據(jù)類型的對象，在做一些比較時可能會帶來一些不可預期的結(jié)果。

6.2、字符串屬性

constructor屬性：返回創(chuàng)建字符串對象的原型函數(shù)

var str = "木已成舟";
console.log(str.constructor);

length屬性：可以用來獲取字符串的長度

var str = "木已成舟";
console.log(str.length);

3.5.3、字符串方法
charAt()方法：該方法可以根據(jù)索引獲取指定位置的字符

var str = "青青子衿，悠悠我心";
console.log(str.charAt(2));

charCodeAt()方法：該方法獲取指定位置字符的字符編碼（Unicode編碼）

var str = "青青子衿，悠悠我心";
console.log(str.charCodeAt(3));

concat()方法：該方法可以用來連接兩個或多個字符串

var str = "青青子衿，悠悠我心";
console.log(str.concat("  譬如朝露，去日苦多"));

indexof()方法：該方法可以檢索一個字符串中是否含有指定內(nèi)容，如果字符串中含有該內(nèi)容，則會返回其第一次出現(xiàn)的索引，如果沒有找到指定的內(nèi)容，則返回-1，可以指定一個第二個參數(shù)，指定開始查找的位置

var str = "青青子衿，悠悠我心";
console.log(str.indexOf("子"));
console.log(str.indexOf("火"));

lastIndexOf()方法：該方法的用法和indexOf()一樣，不同的是indexOf是從前往后找，而lastIndexOf是從后往前找，也可以指定開始查找的位置

var str = "青青子衿，悠悠我心";
console.log(str.lastIndexOf("子"));
console.log(str.lastIndexOf("火"));
console.log(str.lastIndexOf("子",1));

slice()方法：可以從字符串中截取指定的內(nèi)容，不會影響原字符串，而是將截取到內(nèi)容返回

參數(shù)：

第一個參數(shù)：開始位置的索引（包括開始位置）
第二個參數(shù)：結(jié)束位置的索引（不包括結(jié)束位置），如果省略第二個參數(shù)，則會截取到后邊所有的
注意：也可以傳遞一個負數(shù)作為參數(shù)，負數(shù)的話將會從后邊計算

var str = "青青子衿，悠悠我心";
console.log(str.slice(0,2));

substring()方法：可以用來截取一個字符串，它和slice()類似

參數(shù)：

第一個參數(shù)：開始截取位置的索引（包括開始位置）
第二個參數(shù)：結(jié)束位置的索引（不包括結(jié)束位置），如果省略第二個參數(shù)，則會截取到后邊所有的
注意：不同的是這個方法不能接受負值作為參數(shù)，如果傳遞了一個負值，則默認使用0，而且它還自動調(diào)整參數(shù)的位置，如果第二個參數(shù)小于第一個，則自動交換

var str = "青青子衿，悠悠我心";
console.log(str.substring(0,2));

substr()方法：該方法用來截取字符串

參數(shù)：

第一個參數(shù)：截取開始位置的索引
第二個參數(shù)：截取的長度

var str = "青青子衿，悠悠我心";
console.log(str.substr(0,2));

split()方法：該方法可以將一個字符串拆分為一個數(shù)組，需要一個字符串作為參數(shù)，將會根據(jù)該字符串去拆分數(shù)組

var str = "青青子衿，悠悠我心";
console.log(str.split("，"));

toUpperCase()方法：將一個字符串轉(zhuǎn)換為大寫并返回

var str = "GoodLuck";
console.log(str.toUpperCase());

toLowerCase()方法：將一個字符串轉(zhuǎn)換為小寫并返回

var str = "GoodLuck";
console.log(str.toLowerCase());

7、RegExp對象

7.1、概述

正則表達式用于定義一些字符串的規(guī)則，計算機可以根據(jù)正則表達式，來檢查一個字符串是否符合規(guī)則，獲取將字符串中符合規(guī)則的內(nèi)容提取出來。

使用typeof檢查正則對象，會返回object。

7.2、創(chuàng)建正則對象

7.2.1、使用對象創(chuàng)建

匹配模式：

• i：忽略大小寫
• g：全局匹配模式
• ig：忽略大小寫且全局匹配模式

// 這個正則表達式可以來檢查一個字符串中是否含有a
var reg = new RegExp("a", "i");
var str = "Abced";
var result = reg.test(str);
console.log(result);

7.2.2、使用字面量創(chuàng)建

匹配模式：

• i：忽略大小寫
• g：全局匹配模式
• m：執(zhí)行多行匹配

注意：可以為一個正則表達式設置多個匹配模式，且順序無所謂

// 這個正則表達式可以來檢查一個字符串中是否含有a
var reg = /a/i;
var str = "Abced";
var result = reg.test(str);
console.log(result);

7.3、正則進階

//創(chuàng)建一個正則表達式，檢查一個字符串中是否a或z或v
var reg = /a|z|v/i;
var str="Abced";
var result=reg.test(str);
console.log(result);
//創(chuàng)建一個正則表達式，檢查一個字符串中是否有字母
//[a-z]：任意小寫字母
//[A-Z]：任意大寫字母
//[A-z]：任意字母
//[0-9]：任意數(shù)字
var reg = /[A-z]/i;
var str="Abced1123";
var result=reg.test(str);
console.log(result);
//創(chuàng)建一個正則表達式，檢查一個字符串中是否含有 abc 或 adc 或 acc
var reg = /a[bdc]c/i;
var str="Abced1123";
var result=reg.test(str);
console.log(result);
//[^a-z]：除了任意小寫字母
//[^A-Z]：除了任意大寫字母
//[^A-z]：除了任意字母
//[^0-9]：除了任意數(shù)字
//創(chuàng)建一個正則表達式，檢查一個字符串中是否除了數(shù)字還有其它字母
var reg = /[^0-9]/i;
var str="Abced1123";
var result=reg.test(str);
console.log(result);

7.4、正則方法

split()方法：該方法可以將一個字符串拆分為一個數(shù)組，方法中可以傳遞一個正則表達式作為參數(shù)，這樣方法將會根據(jù)正則表達式去拆分字符串，這個方法即使不指定全局匹配，也會全都插分

var str="1A2b4c2e3d1123";
var result=str.split(/[A-z]/);
console.log(result);

search()方法：該方法可以搜索字符串中是否含有指定內(nèi)容，如果搜索到指定內(nèi)容，則會返回第一次出現(xiàn)的索引，如果沒有搜索到返回-1，它可以接受一個正則表達式作為參數(shù)，然后會根據(jù)正則表達式去檢索字符串，serach()只會查找第一個，即使設置全局匹配也沒用

var str="11A2b4c2e3d1123";
var result=str.search(/[A-z]/);
console.log(result);

match()方法：該方法可以根據(jù)正則表達式，從一個字符串中將符合條件的內(nèi)容提取出來，默認情況下我們的match()只會找到第一個符合要求的內(nèi)容，找到以后就停止檢索，我們可以設置正則表達式為全局匹配模式，這樣就會匹配到所有的內(nèi)容，可以為一個正則表達式設置多個匹配模式，且順序無所謂，match()會將匹配到的內(nèi)容封裝到一個數(shù)組中返回，即使只查詢到一個結(jié)果

var str="11A2b4c2e3d1123";
var result=str.match(/[A-z]/ig);
console.log(result);

replace()方法：該方法可以將字符串中指定內(nèi)容替換為新的內(nèi)容，默認只會替換第一個，但是可以設置全局匹配替換全部

參數(shù)：

第一個參數(shù)：被替換的內(nèi)容，可以接受一個正則表達式作為參數(shù)
第二個參數(shù)：新的內(nèi)容

var str="11A2b4c2e3d1123";
var result=str.replace(/[A-z]/ig,"@");
console.log(result);

7.5、正則量詞

通過量詞可以設置一個內(nèi)容出現(xiàn)的次數(shù)，量詞只對它前邊的一個內(nèi)容起作用，如果有多個內(nèi)容可以使用 () 括起來，常見量詞如下：

{n} ：正好出現(xiàn)n次
{m,} ：出現(xiàn)m次及以上
{m,n} ：出現(xiàn)m-n次

+：至少一個，相當于{1,}

*：0個或多個，相當于{0,}
?：0個或1個，相當于{0,1}

var str = "abbc";reg = /(ab){3}/;
console.log(reg.test(str));
console.log("===============");
reg = /b{3}/;
console.log(reg.test(str));
console.log("===============");
reg = /ab{1,3}c/;
console.log(reg.test(str));
console.log("===============");
reg = /ab{3,}c/;
console.log(reg.test(str));
console.log("===============");
reg = /ab+c/;
console.log(reg.test(str));
console.log("===============");
reg = /ab*c/;
console.log(reg.test(str));
console.log("===============");
reg = /ab?c/;
console.log(reg.test(str));
console.log("===============");

7.6、正則高階

如果我們要檢查或者說判斷是否以某個字符或者字符序列開頭或者結(jié)尾就會使用^和$。

• ^ ：表示開頭，注意它在[^字符序列]表達的意思不一樣
• $ ：表示結(jié)尾

var reg=/^a/;
console.log(reg.test(str));
//檢查一個字符串中是否以a結(jié)尾
var str = "abbca";
var reg=/a$/;
console.log(reg.test(str));

檢查一個字符串中是否含有.和\就會使用轉(zhuǎn)義字符

• \. ：表示.
• \\ ：表示\

注意：使用構(gòu)造函數(shù)時，由于它的參數(shù)是一個字符串，而\是字符串中轉(zhuǎn)義字符，如果要使用\則需要使用\\來代替

var str = "a.bbca"+"\\";
var reg=/\\/;
console.log(reg.test(str));
var reg1 = /\./;
var reg2 = /\\/;
var reg3 = new RegExp("\\.");
var reg4 = new RegExp("\\\\");

• \w ：任意字母、數(shù)字、，相當于[A-z0-9]
• \W ：除了字母、數(shù)字、，相當于[^A-z0-9]
• \d ：任意的數(shù)字，相當于[0-9]
• \D ：除了任意的數(shù)字，相當于[^0-9]
• \s ：空格
• \S ：除了空格
• \b ：單詞邊界
• \B ：除了單詞邊界

7.7、正則案例

7.7.1、檢查手機號

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

7.7.2、檢查郵箱號

var emailStr = "abc.def@163.com";
var emailReg = /^\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}$/;
console.log(emailReg.test(emailStr));