js组装知识(待续……)（一）

let obj1 = {
  get a() {
    return 'aaa'
  }
}
let obj2 = {
  set a(val) {
    console.log(val)
  }
}
console.log(obj1.a) //'aaa'
// 对象引用
let obj1 = {};
let obj2 = { a:{} }
Object.assign(obj1, obj2)
console.log( obj1.a===obj2.a ) //true
// 错误处理
let obj1 = {}
let obj2 = {
  a: 1,
  get b() {
    throw new Error();
  },
  c: 3
}
try {
  Object.assign(obj1, obj2)
} catch (e) {
}
console.log(obj1)  //{a:1}
// 因此在抛出错误之前,目标对象上已经完成的修改会继续存在

console.log(+0 === -0) //true
console.log(+0 === 0) //true
console.log(-0 === 0) //true
// 判断NaN
console.log(NaN === NaN)//false
console.log(isNaN(NaN))//true
// 用object.is()轻松解决
console.log(Object.is(NaN, NaN))//true
console.log(Object.is(+0, -0))//false
// 要检查超过两个值,利用递归即可
function deep(x, ...rest) {
  // 传入的值为 1,[1,1,4];  1,[1,4] ;  1,[4]
  return Object.is(x, rest[0]) && (rest.length < 2 || deep(...rest))
}
let a = deep(1, 1, 1, 4)
console.log(a) //false

//1, 属性名简写
let a = 1;
let obj = {a};
console.log(obj) //{a:1}
// 代码压缩程序会在不同的作用域间保留属性名,以防找不到引用   ------这句话还不理解
//2,可计算属性
// 有了计算属性,就可以在对象字面量中完成动态属性赋值.中括号运算符包围
//的对象属性键告诉运行时将其作为JavaScript表达式而不是字符串来求职
// 例
const a = 'name';
const b = 'sex';
const c = 'age';
let obj = { [a]: '小红', [b]: '女', [c]: 10 }
console.log(obj)  //{name:'小红',sex:'女'，age:10}
// 当然[]里也可以是一个复杂的函数
// 3，简写方法名
let obj = {
  // 旧的写法
  oldName: function (a) {
    console.log(a)
  },
  //新的写法
  newName(a) {
    console.log(a)
  }
}

// 解构在内部使用ToObject()把源数据结构转换为对象。这也意味着
//在对象结构的上下文中，原始值会被当成对象，这也意味着
// （根据ToObject()的定义）,null和undefined不能被结构，否则会抛出错误。
// 例
let { length } = 'foobar';
let { constructor } = 'foobar'
// // 这里一定要切记 源对象转为对象就能看懂了
console.log(length, constructor) //6,ƒ String() { [native code] }
console.log(constructor === String) //true

//嵌套结构
//解构可以使用嵌套结构，以匹配嵌套的属性：
let obj = {
  name: '小明',
  age: 11,
  job: {
    title: 'web前端'
  }
}
let { job: { title } } = obj
console.log(title) // web前端

// 参数解构---对参数进行解构不会影响arguments对象
let data = {
  b: 2, c: 3
}
function aaa(a, { b, c }, d) {
  console.log(arguments)  // 1,[2,3],4
  console.log(b, c)       // 2,3
}
aaa(1, data, 2)

try {
  ({ name: p, work: c, job: b } = obj)
} catch (e) {
}
console.log(p, c, b)

function createPerson(name, age, sex) {
  let o = new Object();
  o.name = name;
  o.age = age;
  o.sex = sex;
  o.say = function () {
    console.log(`大家好，我的名字叫---${name}`)
  }
  return o
}
let p1 = createPerson('小明', 11, '男')
p1.say()
let p2 = createPerson('小红', 10, '女')

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
  this.job = 'web';
  this.say = function () {
    console.log(`大家好，我的名字叫---${name}`)
  }
}
const p3 = new Person('小刚', 11, '男');
 // 不传参的情况下，可以不加括号,只要有new操作符，就可以调用对应的构造函数

console.log(Person.prototype)
Person.prototype.say = function () {
  console.log(`我是原型上的方法${this.name}`)
}
console.log(p4)

function aaa(a){
  return function bbb(b){
    return function ccc(c){
      return a+b+c
    }
  }
}
d=aaa(1)(2)(3)
console.log(d)