Object对象的静态方法：
1.Object.keys方法和Object.getOwnPropertyNames方法都用来遍历对象的属性。
Object.keys方法的参数是一个对象，返回一个数组，该数组的成员都是该对象自身的（而不是继承的）所有属性名。
var obj = {
a: 111,
b: 222
}
const objArr1 = Object.keys(obj); // objArr1= ['a','b'];
const objArr2 = Object.getOwnPropertyNames(obj) // objArr2 = ["a", "b"];Object.keys()和Object.getOwnPropertyNames()返回的结果是一样的。只有涉及不可枚举属性时，才会有不一样的结果。
Object.keys方法只返回可枚举的属性，Object.getOwnPropertyNames方法还返回不可枚举的属性名。
如果对象为数组的话，则会返回不可枚举的属性。
var a = ['Hello', 'World']; Object.keys(a); // ["0", "1"] Object.getOwnPropertyNames(a); // ["0", "1", "length"]
数组的length属性是不可枚举的属性
toString()：判断数据类型
Object.prototype.toString方法返回对象的类型字符串，因此可以用来判断一个值的类型。
var obj = {};
obj.toString() // "[object Object]"
其中第二个Object表示该值的构造函数。这是一个十分有用的判断数据类型的方法。
通过函数的call方法，可以在任意值上调用这个方法，帮助我们判断这个值的类型。
Object.prototype.toString.call(value);
eg:
Object.prototype.toString.call(1); // [object Number]
Object.prototype.toString.call('abc'); // [object String]
toString() 和 toLocaleString()
1、var a=1234 a.toString() // "1234" a.toLocaleString() // "1,234"
2、var date = new Date();
date.toString() // "Tue Jan 01 2018 12:01:33 GMT+0800 (CST)"
date.toLocaleString() // "1/01/2018, 12:01:33 PM"1.当数字是四位数及以上时，有区别，区别看以上代码
2.当目标是标准时间格式时，用以上两种方法是有区别的，区别看以上
Object.prototype.hasOwnProperty()：
接受一个字符串作为参数，返回一个布尔值，表示该实例对象自身是否具有该属性。
var obj = {
p: 123
};
obj.hasOwnProperty('p') // true
obj.hasOwnProperty('toString') // false
自身属性返回true，继承属性返回false
Object.getOwnPropertyDescriptor()：方法可以获取属性描述对象。它的第一个参数是目标对象，第二个参数是一个字符串，对应目标对象的某个属性名
var obj = { p: 'a' };
Object.getOwnPropertyDescriptor(obj, 'p')
// Object { value: "a",
// writable: true,
// enumerable: true,
// configurable: true
// }
Array对象：
实例方法：
valueOf，toString, push, pop, shift, unshift, join, concat, reverse, slice, splice, sort, map, forEach, filter, some, every, reduce, reduceRight, indexOf, lastIndexOf,
1. valueOf方法是一个所有对象都拥有的方法，表示对该对象求值。
var arr = [1, 2, 3]; arr.valueOf() // [1, 2, 3]toString方法是数组的toString方法返回数组的字符串形式。 var arr = [1, 2, 3]; arr.toString() // "1,2,3" var arr = [1, 2, 3, [4, 5, 6]]; arr.toString() // "1,2,3,4,5,6"
2. push()、pop()：
push方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。
pop方法用于删除数组的最后一个元素，并返回该元素。注意，该方法会改变原数组。
var arr = ['a', 'b', 'c']; arr.pop() // 'c' arr // ['a', 'b']
3. shift()方法用于删除数组的第一个元素，并返回该元素。注意，该方法会改变原数组。
var a = ['a', 'b', 'c']; a.shift() // 'a' a // ['b', 'c']
unshift()方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。
var a = ['a', 'b', 'c'];
a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']4. join()方法以指定参数作为分隔符，将所有数组成员连接为一个字符串返回。如果不提供参数，默认用逗号分隔。
var a = [1, 2, 3, 4];
a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
5. concat方法用于多个数组的合并。它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变。
['hello'].concat(['world']) // ["hello", "world"] ['hello'].concat(['world'], ['!']) // ["hello", "world", "!"]
[].concat({a: 1}, {b: 2})
// [{ a: 1 }, { b: 2 }]6. reverse方法用于颠倒排列数组元素，返回改变后的数组。注意，该方法将改变原数组。
var a = ['a', 'b', 'c']; a.reverse() // ["c", "b", "a"] a // ["c", "b", "a"]
7. slice()方法用于提取目标数组的一部分，返回一个新数组，原数组不变。
arr.slice(start, end);
截取字段，左开右闭。 如果省略第二个参数，则一直返回到原数组的最后一个成员。
var a = ['a', 'b', 'c'];
a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice(2, 6) // ["c"]
a.slice() // ["a", "b", "c"] 如果slice()方法的参数是负数，则表示倒数计算的位置。
var a = ['a', 'b', 'c'];
a.slice(-2) // ["b", "c"]
a.slice(-2, -1) // ["b"]slice()方法的一个重要应用，是将类似数组的对象转为真正的数组。
Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 })
// ['a', 'b']
Array.prototype.slice.call(document.querySelectorAll("div"));
Array.prototype.slice.call(arguments);
8. splice()方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。
arr.splice(start, count, addElement1, addElement2, ...); start: 截取的位置 count: 截取的个数 addElement1, addElement2...: 被插入数组的新元素 删除数组元素： var a = ['a', 'b', 'c', 'd', 'e', 'f']; a.splice(4, 2) // ["e", "f"] a // ["a", "b", "c", "d"] 替换数组元素 var a = ['a', 'b', 'c', 'd', 'e', 'f']; a.splice(4, 2, 1, 2) // ["e", "f"] a // ["a", "b", "c", "d", 1, 2] 起始位置如果是负数，就表示从倒数位置开始删除。 var a = ['a', 'b', 'c', 'd', 'e', 'f']; a.splice(-4, 2) // ["c", "d"] 如果只是单纯地插入元素，splice方法的第二个参数可以设为0。 var a = [1, 1, 1]; a.splice(1, 0, 2) // [] a // [1, 2, 1, 1] 如果只提供第一个参数，等同于将原数组在指定位置拆分成两个数组。 var a = [1, 2, 3, 4]; a.splice(2) // [3, 4] a // [1, 2]
9. sort方法对数组成员进行排序，默认是按照字典顺序排序。排序后，原数组将被改变。
['d', 'c', 'b', 'a'].sort() // ['a', 'b', 'c', 'd']
sort()方法不是按照大小排序，而是按照字典顺序。也就是说，数值会被先转成字符串，再按照字典顺序进行比较
[11, 101].sort() // [101, 11] [10111, 1101, 111].sort() // [10111, 1101, 111]
如果想让sort方法按照自定义方式排序，可以传入一个函数作为参数。
[10111, 1101, 111].sort(function (a, b) {
return a - b;
})
// [111, 1101, 10111]
10. map方法将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回。不修改原数组
var numbers = [1, 2, 3];
numbers.map(function (n) {
return n + 1;
});
// [2, 3, 4]
numbers
// [1, 2, 3]
map方法接受一个函数作为参数。该函数调用时，map方法向它传入三个参数：当前成员、当前位置和数组本身。
[1, 2, 3].map(function(elem, index, arr) {
return elem * index;
});
// [0, 2, 6]
map方法还可以接受第二个参数，用来绑定回调函数内部的this变量，指向绑定后的arr数组。
var arr = ['a', 'b', 'c'];
[1, 2].map(function (e) {
return this[e];
}, arr)
// ['b', 'c']
11. forEach方法与map方法很相似，也是对数组的所有成员依次执行参数函数。但是，forEach方法不返回值，只用来操作数据。
如果数组遍历的目的是为了得到返回值，那么使用map方法，否则使用forEach方法。
注意，forEach方法无法中断执行，总是会将所有成员遍历完。如果希望符合某种条件时，就中断遍历，要使用for循环。
var arr = [1, 2, 3];
for (var i = 0; i < arr.length; i++) {
if (arr[i] === 2) break;
console.log(arr[i]);
}
// 1
12. filter方法用于过滤数组成员，满足条件的成员组成一个新数组返回。该方法不会改变原数组。
[1, 2, 3, 4, 5].filter(function (elem) {
return (elem > 3);
})
// [4, 5]
filter方法的参数函数可以接受三个参数：当前成员，当前位置和整个数组。
[1, 2, 3, 4, 5].filter(function (elem, index, arr) {
return index % 2 === 0;
});
// [1, 3, 5]
filter方法还可以接受第二个参数，用来绑定参数函数内部的this变量。
var obj = { MAX: 3 };
var myFilter = function (item) {
if (item > this.MAX) return true;
};
var arr = [2, 8, 3, 4, 1, 3, 2, 9];
arr.filter(myFilter, obj) // [8, 4, 9]
13. some， every 返回一个布尔值，表示判断数组成员是否符合某种条件。
它们接受一个函数作为参数，所有数组成员依次执行该函数。该函数接受三个参数：当前成员、当前位置和整个数组，然后返回一个布尔值。
some方法是只要一个成员的返回值是true，则整个some方法的返回值就是true，否则返回false。
var arr = [1, 2, 3, 4, 5];
arr.some(function (elem, index, arr) {
return elem >= 3;
});
// true
every方法是所有成员的返回值都是true，整个every方法才返回true，否则返回false。
var arr = [1, 2, 3, 4, 5];
arr.every(function (elem, index, arr) {
return elem >= 3;
});
// false
some和every方法还可以接受第二个参数，用来绑定参数函数内部的this变量。
14. reduce方法和reduceRight方法依次处理数组的每个成员，最终累计为一个值。
[1, 2, 3, 4, 5].reduce(function (a, b) {
console.log(a, b);
return a + b;
})
第一次：a = 1, b = 2; => 3
第二次：a = 3, b = 3; => 6
第三次：a = 6, b = 4; => 10
第四次：a = 10, b = 5; => 15
reduce方法和reduceRight方法的第一个参数都是一个函数。该函数接受以下四个参数。
1.累积变量，默认为数组的第一个成员 必填 2.当前变量，默认为数组的第二个成员 必填 3.当前位置（从0开始） 选填 4.原数组 选填
如果要对累积变量指定初值，可以把它放在reduce方法和reduceRight方法的第二个参数。
[1, 2, 3, 4, 5].reduce(function (a, b) {
return a + b;
}, 10);
// 25
15. indexOf方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。
var a = ['a', 'b', 'c'];
a.indexOf('b') // 1
a.indexOf('y') // -1
indexOf方法还可以接受第二个参数，表示搜索的开始位置。
['a', 'b', 'c'].indexOf('a', 1) // -1
lastIndexOf方法返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1。
var a = [2, 5, 9, 2]; a.lastIndexOf(2) // 3 a.lastIndexOf(7) // -1
match方法用于确定原字符串是否匹配某个子字符串，返回一个数组，成员为匹配的第一个字符串。如果没有找到匹配，则返回null。
'cat, bat, sat, fat'.match('at') // ["at"]
'cat, bat, sat, fat'.match('xt') // null
split方法还可以接受第二个参数，限定返回数组的最大成员数
'a|b|c'.split('|', 0) // []
'a|b|c'.split('|', 1) // ["a"]
'a|b|c'.split('|', 2) // ["a", "b"]
'a|b|c'.split('|', 3) // ["a", "b", "c"]
'a|b|c'.split('|', 4) // ["a", "b", "c"]
localeCompare方法用于比较两个字符串。它返回一个整数，如果小于0，表示第一个字符串小于第二个字符串；如果等于0，表示两者相等；如果大于0，表示第一个字符串大于第二个字符串。
'apple'.localeCompare('banana') // -1
'apple'.localeCompare('apple') // 0
Math方法：
Math对象提供以下一些静态方法。
Math.abs()：绝对值Math.ceil()：向上取整Math.floor()：向下取整Math.max()：最大值Math.min()：最小值Math.pow()：幂运算Math.sqrt()：平方根Math.log()：自然对数Math.exp()：e的指数Math.round()：四舍五入Math.random()：随机数
Math.round方法用于四舍五入。
Math.round(0.1) // 0 Math.round(0.5) // 1 Math.round(0.6) // 1 // 等同于 Math.floor(x + 0.5) 注意，它对负数的处理（主要是对0.5的处理）。 Math.round(-1.1) // -1 Math.round(-1.5) // -1 Math.round(-1.6) // -2
Math.pow方法返回以第一个参数为底数、第二个参数为指数的幂运算值。
// 等同于 2 ** 2 Math.pow(2, 2) // 4 // 等同于 2 ** 3 Math.pow(2, 3) // 8
下面是计算圆面积的方法。
var radius = 20; var area = Math.PI * Math.pow(radius, 2);
Math.sqrt方法返回参数值的平方根。如果参数是一个负值，则返回NaN。
Math.sqrt(4) // 2 Math.sqrt(-4) // NaN
Math.log方法返回以e为底的自然对数值。
Math.log(Math.E) // 1 Math.log(10) // 2.302585092994046
如果要计算以10为底的对数，可以先用Math.log求出自然对数，然后除以Math.LN10；求以2为底的对数，可以除以Math.LN2。
Math.log(100)/Math.LN10 // 2 Math.log(8)/Math.LN2 // 3
Math.random()返回0到1之间的一个伪随机数，可能等于0，但是一定小于1。
Math.random() // 0.7151307314634323
任意范围的随机数生成函数如下。
function getRandomArbitrary(min, max) {
return Math.random() * (max - min) + min;
}
getRandomArbitrary(1.5, 6.5)
任意范围的随机整数生成函数如下。
function getRandomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
getRandomInt(1, 6) // 5
Date()对象中valueOf方法返回实例对象距离时间零点（1970年1月1日00:00:00 UTC）对应的毫秒数，该方法等同于getTime方法。
var d = new Date(); d.valueOf() // 1362790014817 d.getTime() // 1362790014817
想要获取2个时间的时间差，可以直接相减获取。时间会自动调用valueOf()方法
var start = new Date(); // ... var end = new Date(); var elapsed = end - start;
Date对象提供了一系列get*方法，用来获取实例对象某个方面的值。
getTime()：返回实例距离1970年1月1日00:00:00的毫秒数，等同于valueOf方法。 getDate()：返回实例对象对应每个月的几号（从1开始）。 getDay()：返回星期几，星期日为0，星期一为1，以此类推。 getFullYear()：返回四位的年份。 getMonth()：返回月份（0表示1月，11表示12月）。 getHours()：返回小时（0-23）。 getMilliseconds()：返回毫秒（0-999）。 getMinutes()：返回分钟（0-59）。 getSeconds()：返回秒（0-59）。 getTimezoneOffset()：返回当前时间与 UTC 的时区差异，以分钟表示，返回结果考虑到了夏令时因素。
正则匹配：
正则实例对象的test方法返回一个布尔值，表示当前模式是否能匹配参数字符串。
/cat/.test('cats and dogs') // true
如果正则表达式带有g修饰符，则每一次test方法都从上一次结束的位置开始向后匹配。
var r = /x/g; var s = '_x_x'; r.lastIndex // 0 r.test(s) // true r.lastIndex // 2 r.test(s) // true r.lastIndex // 4 r.test(s) // false
注意，带有g修饰符时，正则表达式内部会记住上一次的lastIndex属性，这时不应该更换所要匹配的字符串，否则会有一些难以察觉的错误。
正则实例对象的exec()方法，用来返回匹配结果。如果发现匹配，就返回一个数组，成员是匹配成功的子字符串，否则返回null。
var s = '_x_x'; var r = /_(x)/; r.exec(s) // ["_x", "x"]
上面代码的exec()方法，返回一个数组。第一个成员是整个匹配的结果，第二个成员是圆括号匹配的结果。
字符串实例对象的match方法对字符串进行正则匹配，返回匹配结果。
var s = '_x_x'; var r1 = /x/; var r2 = /y/; s.match(r1) // ["x"] s.match(r2) // null
如果正则表达式带有g修饰符，则该方法与正则对象的exec方法行为不同，会一次性返回所有匹配成功的结果。
var s = 'abba';
var r = /a/g;
s.match(r) // ["a", "a"]
r.exec(s) // ["a"]字符串对象的replace方法可以替换匹配的值。它接受两个参数，第一个是正则表达式，表示搜索模式，第二个是替换的内容。
str.replace(search, replacement)
正则表达式如果不加g修饰符，就替换第一个匹配成功的值，否则替换所有匹配成功的值。 'aaa'.replace('a', 'b') // "baa" 'aaa'.replace(/a/, 'b') // "baa" 'aaa'.replace(/a/g, 'b') // "bbb"
JSON:
JSON对象是 JavaScript 的原生对象，用来处理 JSON 格式数据。它有两个静态方法：JSON.stringify()和JSON.parse()。
JSON.stringify()方法用于将一个值转为 JSON 字符串。该字符串符合 JSON 格式，并且可以被JSON.parse()方法还原。
JSON.stringify()方法还可以接受一个数组，作为第二个参数，指定参数对象的哪些属性需要转成字符串。
这个类似白名单的数组，只对对象的属性有效，对数组无效。
var obj = {
'prop1': 'value1',
'prop2': 'value2',
'prop3': 'value3'
};
var selectedProperties = ['prop1', 'prop2'];
JSON.stringify(obj, selectedProperties)
// "{"prop1":"value1","prop2":"value2"}"
第二个参数还可以是一个函数，用来更改JSON.stringify()的返回值。
function f(key, value) {
if (typeof value === "number") {
value = 2 * value;
}
return value;
}
JSON.stringify({ a: 1, b: 2 }, f)
// '{"a": 2,"b": 4}'
toJSON()
如果参数对象有自定义的toJSON()方法，那么JSON.stringify()会使用这个方法的返回值作为参数，而忽略原对象的其他属性。
JSON.parse()方法用于将 JSON 字符串转换成对应的值。