JavaScript 重要知识点

重点

//赋值
var i = (1,2,3) // i = 3 逗号计算，返回最右
var obj = {x:1,x:2} // obj.x -> 2 ,可以重复命名但返回最后一个

//try catch finally
try{
  console.error('error1')
}catch(err){
  console.log(err)
}
finally{
  console.log('finally')
}
//顺序 抛出错误-> 捕捉错误error1 ->finally

try{
  try{
    console.error("error2")
  }catch(err){
    console.log(err)
  }finally{
    console.log('finally2')
  }
}
catch(err){
  console.log("outer",err)
}finally{
  console.log('finally3')
}
//顺序 抛出错误error2 -> 捕捉错误error2 -> finally2 -> outer（接收不到err 已经在上个catch捕捉） -> finally3 

//删除对象
var person = {age:23,name:"perter"}
delete person.age // true
delete person['name'] //true
person.age // undefined
delete person.age //true  ！依然返回true但是并不执行

var descriptor = Object.getOwnPropertyDescriptor(Object,'prototype');
descriptor // 获取当前对象的描述属性 -> 读写、配置、枚举

//var 、 function 定义的属性不能被删除
var age = 23
delete age //false

function test(){}
delete test //false

(function test(){
  var local = 1;
  return delete local //false
})

(function(){
  function test(){}
  return delete test //false
})

//隐式变量定义
oh = 1 
delete oh //true
//隐式创建类似于在window对象上添加属性
window.oh //1 
delete oh == delete window.oh

eval('var i = 1');
delete i //true

//属性检测
var cat = new Object();
cat.legs = 4;
cat.name ='kitty'

'legs' in cat // true
'name' in cat //true
'toString' in cat // in 往上找，一直找到Object.prototype -> null 
cat.hasOwnProperty('legs') //true
cat.hasOwnProperty('toString') //false 因为只是继承原型链上的方法，并不是其对象内部的方法

//用当前存在的对象创建新变量
var existObj = {x:1,y:2,z:3}
var newObj = Object.create(existObj);
newObj.x //1 如果仅仅想枚举当前对象上的属性
var key
for(key in newObj){
  if(newObj.hasOwnProperty(key)){
    console.log(key) //屏蔽继承原型链上的属性，仅枚举当前对象上的属性。
  }
}

//可/不可枚举
var cat = new Object();
Object.defineProperty(cat,'legs',{enumerable:false,value:4});
cat.x = 1;cat.y=2;cat.z=3;
var key;
for(key in cat){
  console.log(key) //x,y,z 不包含legs 因为legs不能被枚举 
}

Object.defineProperty(cat,'legs',{enumerable:true})
for(var key in cat){
  console.log(key) //legs x , y ,z 可以进行枚举
}

//get/set方法
var man = {
  name:'chenyu',
  get age(){
    return new Date().getFullYear() - 1995
  },
  set age(val){ 
    console.log("can't set age" + val)
  }
}

GET/SET 与原型链

obj.z //向上查找原型链上的z，在构造函数foo上寻找到z 
obj.z = 10 //原型链上有get/set方法，赋值时会调用，并不在对象内部创建属性，所以该赋值操作不能被执行，因为无法操作原型链上的方法。
//如何在实例对象上定义z属性？
Object.defineProperty(obj,'z',{value:1,configurable:true})
obj.z //返回1 在实例对象中查找到z为1
delete obj.z ;
obj.z //10

创建对象o 定义o的属性x 为1，默认定义为不可写,

创建实例对象 var obj = Object.create(o) 继承o的原型链

实例对象上还是无法修改x 对象，因为x在原型链上为不可写状态

在当前实例对象上再次定义x，并且writable为true，当前obj.x 可都可写

Object.keys(obj) //获取obj的所有键 返回为数组
Object.values(obj) //获取obj的所有数值 返回为数组

//定义多个属性
var o = {}
var obj = Object.create(o)
Object.defineProperties(obj,{
  name:{value:'chen',enmuerable:true},
  age:{value:24,enmuerable:true},
  salary:{value:7000,enmuerable:true,writable:true},
  luck:{
    get:function(){
      return Math.random() > 0.5 ? "good" : "bad"
    }
  },
  promote:{
    set:function(level){
      this.salary *= 1 + level * 0.1
    }
  }

})

obj.salary // 7000
obj.promote = 1 
obj.salary // 7700

//对象是否可扩展
Object.isExtensible(obj) //判断obj是否是可扩展属性
Object.preventExtensions(obj) //让obj变得不可扩展

Object.seal(obj) //让obj属性变得不可扩展 并且configurable为false
Object.isSealed(obj) //判断obj是否密封

Object.freeze(obj) //冻结obj 不可扩展 configurable和writable为false
Object.isFrozen(obj) //判断是否被冻结

以上不能改变原型链中的属性

//序列化
JSON.stringify(obj) //转换为字符串
JSON.parse(obj) // 将字符串转换为JavaScript对象

注意以下几点会异常序列化

• val: undefined //当值为undefined的时候，不进行序列化转换
• a: NaN //值为NaN的时候，直接转换为null

//自定义o序列化的过程
var obj = {
  o:{
    o1 : 1,
    o2 : 2,
    toJSON:function(){  //toJSON函数名称固定，当序列化的时候执行这个函数，返回一个值
      return this.o1 + this.o2
    }
  }
}
JSON.stringify(obj.o) // o:3

//对象的toString方法
对象的toString方法可以自己定义返回的字符串

当与字符串拼接时，自动转换为字符串类型
当做运算的时，转换为数字。