ES5总结

摘要：对象只能在一行，不能多行模板字符串可以多行将字符串转换成对象反序列化将对象转换成字符串序列化会删除一个字符串两端的空白字符。并不影响原字符串本身，它返回的是一个新的字符串。

let ass="[{"name":"ss","age":"3"},{"name":"aa","age":"1"},{"name":"qq","age":"4"},{"name":"zz","age":"3"},{"name":"xx","age":"5"},{"name":"cc","age":"7"}]"

将JSON字符串转换成JSON对象(JSON反序列化)
let aa=JSON.parse(ass);
console.log(aa[2].age);//4

将JSON对象转换成JSON字符串(JSON序列化)
let arr=[
    {"name":"ss","age":"3"},
    {"name":"aa","age":"1"},
    {"name":"qq","age":"4"},
    {"name":"zz","age":"3"},
    {"name":"xx","age":"5"},
    {"name":"cc","age":"7"}
]
let bb=JSON.stringify(arr);
console.log(bb);//[{"name":"ss","age":"3"},{"name":"aa","age":"1"},{"name":"qq","age":"4"},{"name":"zz","age":"3"},{"name":"xx","age":"5"},{"name":"cc","age":"7"}]

会删除一个字符串两端的空白字符。并不影响原字符串本身，它返回的是一个新的字符串。
let str22="     fff    ";
console.log("+"+str22+"+");//+     fff    +
console.log("+"+str22.trim()+"+")//+fff+

//1970.7.1到现在，1秒=1000毫秒这个概率算
console.log(Date.now());//1500799156134
//toJSON()格林时间(德国) 与我们的时间正好相反
console.log(new Date().toJSON())//2017-07-23T08:42:13.050Z
console.log(new Date().toJSON().slice(0,10))//2017-07-23

小数后取位数，数字代表取到第几位，四舍五入返回小数
let a=new Number(1.234);
console.log(a.toFixed(1));//1.2
let v=new Number(4.645372);
console.log(v.toFixed(2));//4.56
console.log(Math.round(13.89));//14 四舍五入返回整数

以指定的精度返回该数值对象的字符串表示。 precision 是 1 ~ 21 之间
let d=100000000000000000000;
console.log(d.toPrecision(7));1.000000e+20
console.log(d.toPrecision(3));1.00e+20

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

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

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

let arr3=arr.some(function(value){
    return value>2;
});
console.log(arr3);//true

let arr4=arr.every(function(value){
    return value>3;
});
console.log(arr4);//false

返回整数索引值，如果没有匹配（严格匹配），返回-1. 匹配到返回 1。

var aa = [2, 5, 7, 3, 5];

console.log(aa.indexOf(5, "x")); // 1 ("x"被忽略)
console.log(aa.indexOf(5, "3")); // 4 (从3号位开始搜索)
console.log(aa.indexOf(4)); // -1 (未找到)
console.log(aa.indexOf("5")); // -1 (未找到，因为5 !== "5")

console.log(aa.lastIndexOf(5)); // 4
//console.log(aa.lastIndexOf(5, 3)); // 1 (从后往前，索引值小于3的开始搜索)

//console.log(aa.lastIndexOf(4)); // -1 (未找到)

let ar3=[1,2,3,4,5];
let gh=ar3.reduce(function(last,now){
    return last*now;
},1)
console.log(gh);//120

相当于reduce，只是reduceRight从右边开始计算

let ar33=[1,2,3,4,5];
let gh22=ar33.reduceRight(function(last,now){
    return last*now;
},1)
console.log(gh22);//120

判断一个变量是否为数组,是返回true，不是返回false

let ss=22;
console.log(Array.isArray(ss));//false
console.log(Array.isArray(ar33));//true

ps：不兼容IE8.

let obj={
    x:1,
    y:2
}

let obj2=Object.create(obj,{z:{value:3}});
console.log(obj2);//Object {z: 3}
console.log(obj2.x);//1
//es6
let obj3={
    __proto__:obj,
    z:3
};
console.log(obj3);//Object {z: 3}

let objj={
    x:1,
    y:2
};
objj.k=4;
Object.defineProperty(objj,"j",{
    value:5,
    writable:false,//可写
    enumerable:false,//可便利
     configurable: true//可配置
});
objj.j=50;
objj.k=50;
console.log(objj);//Object {x: 1, y: 2, k: 50, j: 5}

let objj={
    x:1,
    y:2
};
Object.defineProperties(objj,{
    "m":{
        value:"mm",
    },
    "u":{
        value:"ll",
    }
})
console.log(objj);//Object {x: 1, y: 2, m: "mm", u: "ll"}

let sdf=Object.getOwnPropertyDescriptor(objj,"x");
console.log(sdf);//Object {value: 1, writable: true, enumerable: true, configurable: true}

console.log(Object.keys(obj));// ["x", "y"]

console.log(Object.getOwnPropertyNames(obj));

/*let aa={
    x:1,
    y:2
};
Object.preventExtensions(aa);
aa.fn=function(){

}
console.log(aa);//Object {x: 1, y: 2}*/

let aa={
    x:1,
    y:2
};
Object.seal(aa);
aa.fn=function(){

}
console.log(aa);//Object {x: 1, y: 4}

let aa={
    x:1,
    y:2
};
Object.freeze(aa);
aa.y=4;
console.log(aa);//Object {x: 1, y: 2}

console.log(Object.isExtensible(aa));//false 

console.log(Object.isSealed(aa));//true

console.log(Object.isFrozen(aa));//true

ps 以上方法均不兼容ie8

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

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

何使用"eval"的操作都会被禁止

val作用域

ith被禁用

aller/callee 被禁用

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

除系统内置的属性会报错

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

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

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

对象有重名的属性将报错

函数有重名的参数将报错

八进制表示法被禁用

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

函数必须声明在顶层

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

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

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

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