es5的JSON,String、Date、Number、Function,数组，对象

es5的JSON,String、Date、Number、Function,数组，对象

序列化(JSON.stringify)和反序列化(JSON.parse)

let str = '[{"name":"姜姜","age":23},{"name":"吴建","age":24}]';
let arr = [
        {"name":"姜姜","age":23},
        {"name":"吴建","age":24}
          ];
//用来将json字符串转成json对象(json的反序列化)
let jsonObj = JSON.parse(str);
console.log(jsonObj);//打印出[Object, Object] 

//用来将json对象转成json字符串(json的序列化)
let jsonStr = JSON.stringify(arr);
console.log(jsonStr);//打印出[{"name":"姜姜","age":23},{"name":"吴建","age":24}]

String对象

//String trim
let str5 = '       abc';
console.log("|"+str5+"|");//打印出|       abc|
console.log("|"+str5.trim()+"|");//打印出|abc|

//正则
let reg = /^(\s+)|(\s+)$/g;
console.log("|"+str5.replace(reg,'')+"|");//打印出|abc|

Date对象

添加了Date.now()、Date.prototype.toJSON(),toISOString()方法。

//Date
console.log(Date.now());//打印出1500706861909

console.log(new Date().toJSON());//打印出2017-07-22T07:01:01.909Z
console.log(new Date().toISOString().slice(0,10));//打印出2017-07-22

Number对象

//Number

let a = new Number(1.326);
let b = new Number(1.324);
console.log(a.toFixed(2));//打印出1.33
console.log(b.toFixed(2));//打印出1.32
let c = 10000000000000;
console.log(c.toPrecision(4));//打印出1.000e+13
console.log(Math.round(12.34));//打印出12

Function对象

//function  call apply

var x = 1;
let obj5 = {
    x:2
}
function fn1(a,b){
    console.log(this.x);
}
fn1();

let fn2 = fn1.bind(obj5);
fn2();

Array对象

//Array

//迭代方法
//forEach
let arr = [1,4,2,3,4,5];
arr.forEach(function(value,index){
    console.log(index);
    console.log(value);
})
//打印0 1 1 4 2 2 3 3 4 4 5 5 

//map
let arr1 = arr.map(function(value){
    return value*2+1;
})
console.log(arr1);//打印[3, 9, 5, 7, 9, 11]；

//filter
let arr2 = arr.filter(function(value){
    return value>2;
})
console.log(arr2);//打印： [4, 3, 4, 5]；

//some
let arr3 = arr.some(function(value){
    return value>5;
})
console.log(arr3);//打印false
//只要有一个条件满足就返回true；

//every
let arr4 = arr.every(function(value){
    return value>0;
})
console.log(arr4);//打印true；
//必须所有条件都满足才返回true，其它情况都返回false；


//索引方法：
console.log(arr.indexOf(4));//打印1；
console.log(arr.indexOf(5)>-1);//打印true；
//indexOf:从前往后找，找第一个；

console.log(arr.lastIndexOf(4));//打印4；

//lastindexOf：从后边往前找，找最后一个；

//缩小方法：
//reduce,reduceRight
let arr5 = arr.reduce(function(last,now){
    return last+now;
},0);
console.log(arr5);//打印19；
let arr6 = arr.reduceRight(function(last,now){
    return last+now;
},0);
console.log(arr6);//打印19；
//reduce：从左往右算，reduceRight：从右往左算，它俩结果是一样的；

//判断方法：

let x = 2;
console.log(Array.isArray());//打印false；
//Array.isArray：判断一个变量是否是数组；

Object

//Object

//creat（指定propto，）
let obj = {
    x:1,
    y:2
};
//es5
let obj2 = Object.create(obj,{
    z:{
        value:3
    }
});
//es6
let obj3={
    __proto__:obj,
    z:3
}
console.log(obj2);//打印Object {z: 3}；
console.log(obj3);//打印Object {z: 3}；
console.log(obj2.x);//打印1；

//Object.defineProperty() 用来给对象定义属性的
let obj = {
    x:1,
    y:2
}
obj.k=3;
Object.defineProperty(obj,"j",{
        value:4,
        writable:true,  //可写
        enumerable:true,  //可遍历
        configurable:true  //可配置
});

//Object.defineProperties() 给对象指定对个属性
Object.defineProperties(obj,{
    "m":{
        value:"m1"
    },
    "l":{
        value:"l1"
    }
})
obj.j=50;
obj.k=50;
console.log(obj);//打印Object {x: 1, y: 2, k: 50, j: 50, m: "m1"，l："l1"}；

for(var key in obj){
    console.log(key);//打印x y k j；
};

//getOwnPropertyDescriptor()用来获取属性的描述
console.log(Object.getOwnPropertyDescriptor(obj,"x"));//打印Object {value: 1, writable: true, enumerable: true, configurable: true}；


//Object.keys()用来返回对象的key值
console.log(Object.keys(obj));//打印["x", "y", "k", "j"]；

//Object.getOwnPropertyNames()获取所有属性名
console.log(Object.getOwnPropertyNames(obj));//打印["x", "y", "k", "j", "m", "l"]；

//Object.preventExtensions()
Object.preventExtensions(obj);
//让一个对象不可扩展，该对象无法再添加新的属性，但是可以删除现有属性;

//Object.seal() 
Object.seal(obj);
//对一个对象密封，该方法会阻止对象扩展，并将该对象的所有属性设置为不可配置;

//Object.freeze() 
Object.freeze(obj);
//对一个对象进行冻结，实现常量的需求，该方法会阻止对象扩展，并冻结对象，将其所有属性设置为只读和不可配置;

//Object.isExtensible()
Object.isExtensible(obj);
//判断对象是否扩展；

//Object.isSealed()
Object.isSealed(obj);
//判断对象是否密封；

//Object.isFrozen()
Object.isFrozen(obj);
//判断对象是否冻结；
//writable：false不可改，true可改;
//enumerable:false不可遍历，true可遍历；
//configurable：false不可配置，true可配置；

严格模式'use strict'

严格模式，严格模式，重要其实就是es5中弃用了很多以前版本的语法，你再用就提示错误。

下面就是严格模式总结:

1. 使用var声明变量严格模式中将不通过

2. 何使用'eval'的操作都会被禁止

3. val作用域

4. ith被禁用

5. aller/callee 被禁用

6. 禁止扩展的对象添加新属性会报错

7. 除系统内置的属性会报错

8. delete使用var声明的变量或挂在window上的变量报错

9. delete不可删除属性(isSealed或isFrozen)的对象时报错

10. 对一个对象的只读属性进行赋值将报错

11. 对象有重名的属性将报错

12. 函数有重名的参数将报错

13. 八进制表示法被禁用

14. arguments严格定义为参数，不再与形参绑定

15. 函数必须声明在顶层

16. ES5里新增的关键字不能当做变量标示符使用，如implements, interface, let, package, private, protected, pulic, static, yield

17. call/apply的第一个参数直接传入不包装为对象

18. call/apply的第一个参数为null/undefined时，this为null/undefined

19. bind的第一个参数为null/undefined时，this为null/undefined