JS数组，日期，Math，正则

数组

创建

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构造函数

参考文章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: 多行搜索
可以写在一起