陣列

建立

var arr1 = new Array();
arr1[0] = "hi";
arr1[1] = 1;
arr1[2] = 0.95;
console.log(arr1);

var arr2 = ["hi", 1, 0.95];
console.log(arr2);

普通for迴圈，for in迴圈

var arr1 = ["hi", 1, 0.95];
for (let i = 0; i < arr1.length; i++) {
    console.log(arr1[i]);
}

for (x in arr1) {
    console.log(arr1[x]);
}
 

高階函式foreach遍歷

arr1.forEach(function (value, index, array) {
    console.log(value);
})

其中，value表示值，inde表示下表，array表示陣列物件

迭代器遍歷

let arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let ent = arr1.entries();
for (let e of ent) {
    console.log("key="+e[0]+"   value="+e[1]);
}

新增元素到陣列的末尾push

let arr1 = ["hi", 1, 0.95];
arr1.push("hehe");
arr1.forEach(function (value) {
    console.log(value)// "hi"   1   0.95  "hehe"  
});
 

新增元素到陣列的頭部unshift

let arr1 = ["hi", 1, 0.95];
arr1.unshift("hehe");
arr1.forEach(function (value) {
    console.log(value)//"hehe"   "hi"   1   0.95
});

刪除陣列最前面（頭部）的元素shift

let arr1 = ["hi", 1, 0.95];
arr1.shift();
arr1.forEach(function (value) {
    console.log(value)//1   0.95
});
});

刪除陣列末尾的元素pop

let arr1 = ["hi", 1, 0.95];
arr1.pop();
arr1.forEach(function (value) {
    console.log(value)//"hi" 1
});
 

找出某個元素在陣列中的索引indexof

let arr1 = ["hi", 1, 0.95];
console.log(arr1.indexOf(1));//1   -1表示不存在這樣的元素

從一個索引位置刪除多個元素（index，count）

let arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let arr2=arr1.splice(1, 4);
console.log(arr1);//1 6 7 8 9
console.log(arr2);//2 3 4 5

index表示開始刪除的位置，count表示刪除的個數，返回結果是刪除的元素組成的陣列

複製一個數組slice

let arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let arr2=arr1.slice();
console.log(arr1);//1, 2, 3, 4, 5, 6, 7, 8, 9
console.log(arr2);//1, 2, 3, 4, 5, 6, 7, 8, 9

連線所有陣列元素組成一個字串join

let arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let arr2=arr1.join(",")
console.log(arr1);//1, 2, 3, 4, 5, 6, 7, 8, 9
console.log(arr2);//"1,2,3,4,5,6,7,8,9"

日期Date

Date普通函式

Date本身也是一個函式，返回的是當前時間，可以傳引數，但是返回結果也是當前時間
時間戳
Date.now();

console.log(Date());
console.log(Date(2000, 1, 1));
//output
Fri Nov 09 2018 11:14:19 GMT+0800 (中國標準時間)
Fri Nov 09 2018 11:14:19 GMT+0800 (中國標準時間)

Date建構函式

let d1=new Date();
console.log(d1);//Fri Nov 09 2018 11:18:03 GMT+0800 (中國標準時間)當前時間

// 年：使用四位數年份，比如2000。如果寫成兩位數或個位數，
// 則加上1900，即10代表1910年。如果是負數，表示公元前。
// 月：0表示一月，依次類推，11表示12月。
// 日：1到31。
// 小時：0到23。
// 分鐘：0到59。
// 秒：0到59
// 毫秒：0到999。
let d2=new Data(年，月，日，消失，分鐘，秒，毫秒);

不傳引數，返回當前時間，傳引數，可以隨意從開頭計算傳，舉例：

new Date(2013)
// Thu Jan 01 1970 08:00:02 GMT+0800 (CST)
上面程式碼中，2013被解釋為毫秒數，而不是年份。

new Date(2013, 0)
// Tue Jan 01 2013 00:00:00 GMT+0800 (CST)
new Date(2013, 0, 1)
// Tue Jan 01 2013 00:00:00 GMT+0800 (CST)
new Date(2013, 0, 1, 0)
// Tue Jan 01 2013 00:00:00 GMT+0800 (CST)
new Date(2013, 0, 1, 0, 0, 0, 0)
// Tue Jan 01 2013 00:00:00 GMT+0800 (CST)
上面程式碼中，不管有幾個引數，返回的都是2013年1月1日零點。

Date建構函式，合法字串

new Date('2013-2-15')
new Date('2013/2/15')
new Date('02/15/2013')
new Date('2013-FEB-15')
new Date('FEB, 15, 2013')
new Date('FEB 15, 2013')
new Date('Feberuary, 15, 2013')
new Date('Feberuary 15, 2013')
new Date('15 Feb 2013')
new Date('15, Feberuary, 2013')
// Fri Feb 15 2013 00:00:00 GMT+0800 (CST)
只要是能被Date.parse()方法解析的字串，都可以當作引數。

引數數值不合法，正負，超過規定值

new Date(2013, -1)
// Sat Dec 01 2012 00:00:00 GMT+0800 (CST)
new Date(2013, 0, -1)
// Sun Dec 30 2012 00:00:00 GMT+0800 (CST)
引數使用負數，表示扣去的時間。

new Date(2013, 15)
// Tue Apr 01 2014 00:00:00 GMT+0800 (CST)
new Date(2013, 0, 0)
// Mon Dec 31 2012 00:00:00 GMT+0800 (CST)
引數如果超出了正常範圍，會被自動折算。比如，如果月設為15，就折算為下一年的4月。

get 類方法

getTime()：返回例項距離1970年1月1日00:00:00的毫秒數，等同於valueOf方法。
getDate()：返回例項物件對應每個月的幾號（從1開始）。
getDay()：返回星期幾，星期日為0，星期一為1，以此類推。
getYear()：返回距離1900的年數。
getFullYear()：返回四位的年份。
getMonth()：返回月份（0表示1月，11表示12月）。
getHours()：返回小時（0-23）。
getMilliseconds()：返回毫秒（0-999）。
getMinutes()：返回分鐘（0-59）。
getSeconds()：返回秒（0-59）。
getTimezoneOffset()：返回當前時間與 UTC 的時區差異，以分鐘表示，返回結果考慮到了夏令時因素。

所有這些get*方法返回的都是整數，不同方法返回值的範圍不一樣。

分鐘和秒：0 到 59
小時：0 到 23
星期：0（星期天）到 6（星期六）
日期：1 到 31
月份：0（一月）到 11（十二月）
年份：距離1900年的年數

Date.parse()，返回毫秒數

Date.parse('Aug 9, 1995')
Date.parse('January 26, 2011 13:51:50')
Date.parse('Mon, 25 Dec 1995 13:30:00 GMT')
Date.parse('Mon, 25 Dec 1995 13:30:00 +0430')
Date.parse('2011-10-10')
Date.parse('2011-10-10T14:48:00')

時間戳轉各種時間格式

專案中，這種需求是最多，下面給出轉換程式碼：
js 時間戳轉為日期格式

/**
 * 時間戳格式化函式
 * @param  {string} format    格式
 * @param  {int}    timestamp 要格式化的時間 預設為當前時間
 * @return {string}           格式化的時間字串
 */
function date(format, timestamp){
    var a, jsdate=((timestamp) ? new Date(timestamp*1000) : new Date());
    var pad = function(n, c){
        if((n = n + "").length < c){
            return new Array(++c - n.length).join("0") + n;
        } else {
            return n;
        }
    };
    var txt_weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
    var txt_ordin = {1:"st", 2:"nd", 3:"rd", 21:"st", 22:"nd", 23:"rd", 31:"st"};
    var txt_months = ["", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
    var f = {
        // Day 
        d: function(){return pad(f.j(), 2)},
        D: function(){return f.l().substr(0,3)},
        j: function(){return jsdate.getDate()},
        l: function(){return txt_weekdays[f.w()]},
        N: function(){return f.w() + 1},
        S: function(){return txt_ordin[f.j()] ? txt_ordin[f.j()] : 'th'},
        w: function(){return jsdate.getDay()},
        z: function(){return (jsdate - new Date(jsdate.getFullYear() + "/1/1")) / 864e5 >> 0},

        // Week 
        W: function(){
            var a = f.z(), b = 364 + f.L() - a;
            var nd2, nd = (new Date(jsdate.getFullYear() + "/1/1").getDay() || 7) - 1;
            if(b <= 2 && ((jsdate.getDay() || 7) - 1) <= 2 - b){
                return 1;
            } else{
                if(a <= 2 && nd >= 4 && a >= (6 - nd)){
                    nd2 = new Date(jsdate.getFullYear() - 1 + "/12/31");
                    return date("W", Math.round(nd2.getTime()/1000));
                } else{
                    return (1 + (nd <= 3 ? ((a + nd) / 7) : (a - (7 - nd)) / 7) >> 0);
                }
            }
        },

        // Month 
        F: function(){return txt_months[f.n()]},
        m: function(){return pad(f.n(), 2)},
        M: function(){return f.F().substr(0,3)},
        n: function(){return jsdate.getMonth() + 1},
        t: function(){
            var n;
            if( (n = jsdate.getMonth() + 1) == 2 ){
                return 28 + f.L();
            } else{
                if( n & 1 && n < 8 || !(n & 1) && n > 7 ){
                    return 31;
                } else{
                    return 30;
                }
            }
        },

        // Year 
        L: function(){var y = f.Y();return (!(y & 3) && (y % 1e2 || !(y % 4e2))) ? 1 : 0},
        //o not supported yet 
        Y: function(){return jsdate.getFullYear()},
        y: function(){return (jsdate.getFullYear() + "").slice(2)},

        // Time 
        a: function(){return jsdate.getHours() > 11 ? "pm" : "am"},
        A: function(){return f.a().toUpperCase()},
        B: function(){
            // peter paul koch: 
            var off = (jsdate.getTimezoneOffset() + 60)*60;
            var theSeconds = (jsdate.getHours() * 3600) + (jsdate.getMinutes() * 60) + jsdate.getSeconds() + off;
            var beat = Math.floor(theSeconds/86.4);
            if (beat > 1000) beat -= 1000;
            if (beat < 0) beat += 1000;
            if ((String(beat)).length == 1) beat = "00"+beat;
            if ((String(beat)).length == 2) beat = "0"+beat;
            return beat;
        },
        g: function(){return jsdate.getHours() % 12 || 12},
        G: function(){return jsdate.getHours()},
        h: function(){return pad(f.g(), 2)},
        H: function(){return pad(jsdate.getHours(), 2)},
        i: function(){return pad(jsdate.getMinutes(), 2)},
        s: function(){return pad(jsdate.getSeconds(), 2)},
        //u not supported yet 

        // Timezone 
        //e not supported yet 
        //I not supported yet 
        O: function(){
            var t = pad(Math.abs(jsdate.getTimezoneOffset()/60*100), 4);
            if (jsdate.getTimezoneOffset() > 0) t = "-" + t; else t = "+" + t;
            return t;
        },
        P: function(){var O = f.O();return (O.substr(0, 3) + ":" + O.substr(3, 2))},
        //T not supported yet 
        //Z not supported yet 

        // Full Date/Time 
        c: function(){return f.Y() + "-" + f.m() + "-" + f.d() + "T" + f.h() + ":" + f.i() + ":" + f.s() + f.P()},
        //r not supported yet 
        U: function(){return Math.round(jsdate.getTime()/1000)}
    };

    return format.replace(/[\]?([a-zA-Z])/g, function(t, s){
        if( t!=s ){
            // escaped 
            ret = s;
        } else if( f[s] ){
            // a date function exists 
            ret = f[s]();
        } else{
            // nothing special 
            ret = s;
        }
        return ret;
    });
}

Math

屬性

Math.E//返回算術常量 e，即自然對數的底數（約等於2.718）。
Math.LN2;//返回 2 的自然對數（約等於0.693）。
Math.LN10;//返回 10 的自然對數（約等於2.302）。
Math.LOG2E;//返回以 2 為底的 e 的對數（約等於 1.414）。
Math.LOG10E;//返回以 10 為底的 e 的對數（約等於0.434）。
Math.PI;//返回圓周率（約等於3.14159）。
Math.SQRT1_2;//返回返回 2 的平方根的倒數（約等於 0.707）。
Math.SQRT2;//返回 2 的平方根（約等於 1.414）。

方法

Math.abs(x);//返回數的絕對值。
Math.acos(x);//返回數的反餘弦值。
Math.asin(x);//返回數的反正弦值。
Math.atan(x);//以介於 -PI/2 與 PI/2 弧度之間的數值來返回 x 的反正切值。
Math.atan2(y,x);//返回從 x 軸到點 (x,y) 的角度（介於 -PI/2 與 PI/2 弧度之間）。
Math.ceil(x);//對數進行上舍入。
Math.cos(x);//返回數的餘弦。
Math.exp(x);//返回 e 的指數。
Math.floor(x);//對數進行下舍入。
Math.log(x);//返回數的自然對數（底為e）。
Math.max(x,y);//返回 x 和 y 中的最高值。
Math.min(x,y);//返回 x 和 y 中的最低值。
Math.pow(x,y);//返回 x 的 y 次冪。
Math.random();//返回 0 ~ 1 之間的隨機數。
Math.round(x);//把數四捨五入為最接近的整數。
Math.sin(x);//	返回數的正弦。
Math.sqrt(x);//	返回數的平方根。
Math.tan(x);//返回角的正切。
Math.valueOf();//返回 Math 物件的原始值。

正則

建立一個正則表示式

//字面量
/*
   /pattern/flags
*/
let regex = /ab+c/;
let regex = /^[a-zA-Z]+[0-9]*\W?_$/gi;

//new出來
/*
    new RegExp(pattern [, flags])
*/
let regex = new RegExp("ab+c");
let regex = new RegExp(/^[a-zA-Z]+[0-9]*\W?_$/, "gi");
let regex = new RegExp("^[a-zA-Z]+[0-9]*\\W?_$", "gi");

字面量和new出正則，二者等價，由pattern+flgs組成。

常用方法

1.test()：在字串中查詢符合正則的內容，查詢到返回true，反之返回false
用法：正則.test(字串);

var str = '12345678';
var reg = /\D/; 
if(reg.test(str)){
    alert('不全是數字');
}else{
    alert('全是數字');
}

2.search():在字串中搜索符合正則的內容，搜尋到就返回出現的位置（從0開始，若搜尋到的不只是一個字母，則返回第一個字母的位置），反之返回-1
用法：字串.search(正則)

var str = 'webrty';
var reg = /B/i;     //i表示不區分大小寫
console.log(str.search(reg));   //返回2

3.match():在字串中搜索符合正則的內容，匹配成功就返回內容，格式為陣列，失敗則返回null
用法：字串.match(正則);

var str = 'as123msd8xx29shdkdk220nm';
var reg = /\d+/g;   //匹配至少一個數字, g表示全域性匹配
console.log(str.match(reg));    // ["123", "8", "29", "220"]

4.replace()：查詢符合正則的字串，替換成對應的字串，返回替換後的內容
用法：字串.replace(正則，新的字串/回撥函式); （在回撥函式中，第一個引數是指匹配到的第一個字元）

var str = '吃葡萄不吐葡萄皮';
var reg = /葡萄|皮/g;  //匹配葡萄或皮 , 全域性匹配
var str2 = str.replace(reg,'*');
console.log(str2);    //吃*不吐**

Pattern

pattern由各個字元組成，各個字元的意義為：
^：匹配字串的開始位置

$：匹配字串的結束位置

*：匹配前面子表示式任意次數

+：匹配前面子表示式一次或多次

？：匹配前面子表示式0次或多次

. ：匹配任何單個字元

{n}：n為非負整數，匹配確定的n次。例如：“o{2}”不能匹配‘bod’中的‘o’ ,但能匹配‘food’中的‘o’

{n,}：至少匹配n次

{n,m}：最少匹配n次，最多匹配m次

x|y：匹配x或y

[xyz]：字元集合。匹配任意一個字元。例如‘[abc]’ 匹配 ‘plain’ 中的 ‘a’

[^{xyz]：匹配未包含的任意字元。例如‘[}abc]’ 匹配 ‘plain’ 中的 ‘plin’

\b：匹配單詞邊界。例如‘er\b’ 可以匹配‘nerver’ 中的‘er’ ,但不能匹配 ‘verb’中的‘er’

\B：匹配非單詞邊界

\d：匹配一個數字字元，同[0-9]

\D：匹配一個非數字字元，同[^0-9]

\n：匹配一個換行符

\r：匹配一個回車符

\s：匹配任何不可見字元，如空格

\S：匹配任何可見字元

\w：匹配任何包括下劃線的單詞字元

\W：匹配任何非單詞字元

flags

g: 全域性匹配
i: 忽略大小寫
m: 多行搜尋
可以寫在一起