JS红宝书 第八章 对象、类与面向对象编程

 

8.1理解对象

8.1.1属性的特性

属性特性包括：

1. configurable(可配置的):表示属性是否可以删除、和重新定义

2. enumerable(可枚举可遍历的):表示属性是否可以通过for-in循环返回

3. writable(可写的):表示属性的值是否可以被修改

4. 对象上定义的属性以上特性都为true

Object.defineProperty修改属性的默认特性：

let book = {
    year:2020,
    edition:1
};
Object.defineProperty(book,"year",{//1）要修改的对象 2）要修改的属性 3）描述符对象
    configurable:false,//默认false
    enumerable:false,//默认false
    writable:false//默认false
})

8.1.2定义多个属性和读取属性特性

• Object.defineProperties( )，定义多个属性，所有的属性的特性默认都为false

• Object.getOwnPropertyDescriptors( ),读取属性特性

    let books = {};
     Object.defineProperties(books, {
         year_: {
             value: 2020
         },
         edition: {
             value: 1
         },
         //get  set是访问器
         year: {
             get: function() {
                 return this.year_;
             },
             set: function(newValue) {
                 if (newValue > 2017) {
                     this.year_ = newValue;
                     this.edition += newValue - 2017;
                 }
             }
         }
     })
   		//读取属性特性
     console.log(Object.getOwnPropertyDescriptors(books));
//{year_: {…}, edition: {…}, year: {…}}
//edition: {value: 1, writable: false, enumerable: false, configurable: false}
//year: {enumerable: false, configurable: false, get: ƒ, set: ƒ}
//year_: {value: 2020, writable: false, enumerable: false, configurable: false}
//__proto__: Object

 

8.1.3合并对象Object.assign( )

• Object.assign()方法把可枚举的和对象自有的属性复制到目标对象中

• 1）目标对象， 2）.... 多个源对象.....可以放很多源对象

• assign属于浅复制，嵌套对象的话复制的是引用地址

• 如果有相同的属性，则会覆盖，最终以最后一个为准

 let o1 = {
          c: function() {
              return 'c';
          },
          d: 'b'
      };
      let o2 = {
          a: 'a',
          b: 'b'
      };
      let result = Object.assign(o2, o1, { e: 'e'});
      console.log(result);
//{a: "a", b: "b", d: "b", e: "e", c: ƒ}
//a: "a"
//b: "b"
//c: ƒ ()
//d: "b"
//e: "e"

 

8.1.4对象标识 Object.is

Object.is比 全等符还要严谨些

console.log(Object.is(+1,-0))//false
console.log(Object.is(+0,0))//false
console.log(Object.is(-0,-0))//false
//这些放到全等符 都为true

 

8.1.5增强的对象语法

• 属性值简写：

  • 如果属性名和属性值一致，可以只写属性名

• 可计算属性

  • 如果想使用变量的值作为属性，那么必须先声明对象，然后使用 [ ] 语法来添加属性

  • 	const nameKey = 'name';
           const ageKey = 'age';
           let obj = {};
           obj[nameKey] = 'zhangsan';
           obj[ageKey] = 18;
           console.log(obj);//{name: "zhangsan", age: 18}

     

  • 可以在对象字面量中完成动态属性赋值，[ ]包围的对象属性键告诉运行时将其作为JS表达式而不是字符串来求值

  • 	const nameKey = 'name';
           const ageKey = 'age';
     		let obj = {
               [nameKey]:'zhang',
               [ageKey]:18
           }

     

  • 因为被当作JS表达式，所以可计算属性本身可以是复杂的表达式

•     const nameKey = 'name';
      const ageKey = 'age';
      let unique = 0;
      function getUniqueKey(key) {
          return `${key}_${unique++}`;
      }
      let obj = {
          [getUniqueKey(nameKey)]: 'zhang',
          [getUniqueKey(ageKey)]: 18
      }
      console.log(obj);//{name_0: "zhang", age_1: 18}

  8.1.6对象解构

• 如果让变量直接使用属性名，可以用对象结构，变量的名字必须和属性名一致，否则返回undefined

let o2 = {
         a: 'a',
         b: 'b',
         c: 'c'
     };
let{a,b,job} = o2;
    console.log(a);//'a'
    console.log(b);//'b'
    console.log(job);//undefined

 

8.2创建对象

• 工厂模式.

• 问题没有解决对象标识的问题，即新创建的对象是什么类型

•     function creatPerson(name, age) {
          let o = new Object();
          o.name = name;
          o.age = age;
          o.sayName = function() {
              console.log(this.name);
          };
          //返回对象
          return o;
      }
      let preson1 = creatPerson('zhangsan', 18);
      let preson2 = creatPerson('lisi', 20);
      console.log(preson1);//{name: "zhangsan", age: 18, sayName: ƒ}
      console.log(preson2);//{name: "lisi", age: 20, sayName: ƒ}