[TOC]

对象的方法补充

对象的方法补充

◼ hasOwnProperty

  • 对象是否有某一个属于自己的属性（不是在原型上的属性）

◼ in/for in 操作符

  • 判断某个属性是否在某个对象或者对象的原型上

◼ instanceof

  • 用于检测构造函数（Person、Student类）的pototype，是否出现在某个实例对象的原型链上

◼ isPrototypeOf

  • 用于检测某个对象，是否出现在某个实例对象的原型链上

image.png

原型继承关系图

image.png
image.png

class方式定义类

认识class定义类

◼ 我们会发现，按照前面的构造函数形式创建 类，不仅仅和编写普通的函数过于相似，而且代码并不容易理解。

  • 在ES6（ECMAScript2015）新的标准中使用了class关键字来直接定义类；
  • 但是类本质上依然是前面所讲的构造函数、原型链的语法糖而已；
  • 所以学好了前面的构造函数、原型链更有利于我们理解类的概念和继承关系；

◼ 那么，如何使用class来定义一个类呢？

  • 可以使用两种方式来声明类：类声明和类表达式；

image.png

类和构造函数的异同

◼ 我们来研究一下类的一些特性：

  • 你会发现它和我们的构造函数的特性其实是一致的；

image.png

类的构造函数

◼ 如果我们希望在创建对象的时候给类传递一些参数，这个时候应该如何做呢？

  • 每个类都可以有一个自己的构造函数（方法），这个方法的名称是固定的constructor；
  • 当我们通过new操作符，操作一个类的时候会调用这个类的构造函数constructor；
  • 每个类只能有一个构造函数，如果包含多个构造函数，那么会抛出异常；

◼ 当我们通过new关键字操作类的时候，会调用这个constructor函数，并且执行如下操作：

  1. 在内存中创建一个新的对象（空对象）；
  2. 这个对象内部的[[prototype]]属性会被赋值为该类的prototype属性；
  3. 构造函数内部的this，会指向创建出来的新对象；
  4. 执行构造函数的内部代码（函数体代码）；
  5. 如果构造函数没有返回非空对象，则返回创建出来的新对象；

类的实例方法

◼ 在上面我们定义的属性都是直接放到了this上，也就意味着它是放到了创建出来的新对象中：

  • 在前面我们说过对于实例的方法，我们是希望放到原型上的，这样可以被多个实例来共享；
  • 这个时候我们可以直接在类中定义；

image.png

类的访问器方法

◼ 我们之前讲对象的属性描述符时有讲过对象可以添加setter和getter函数的，那么类也是可以的
image.png

类的静态方法

◼ 静态方法通常用于定义直接使用类来执行的方法，不需要有类的实例，使用static关键字来定义：
image.png

extends实现继承

◼ 前面我们花了很大的篇幅讨论了在ES5中实现继承的方案，虽然最终实现了相对满意的继承机制，但是过程却依然是非常繁琐的。

  • 在ES6中新增了使用extends关键字，可以方便的帮助我们实现继承

image.png

super关键字

◼ 我们会发现在上面的代码中我使用了一个super关键字，这个super关键字有不同的使用方式：

  • 注意：在子（派生）类的构造函数中使用this或者返回默认对象之前，必须先通过super调用父类的构造函数！
  • super的使用位置有三个：子类的构造函数、实例方法、静态方法；

image.png

继承内置类

◼ 我们也可以让我们的类继承自内置类，比如Array;
image.png

类的混入mixin

◼ JavaScript的类只支持单继承：也就是只能有一个父类

  • 那么在开发中我们我们需要在一个类中添加更多相似的功能时，应该如何来做呢
  • 这个时候我们可以使用混入（mixin）

image.png
image.png

多态概念的理解

◼ 面向对象的三大特性：封装、继承、多态。

  • 前面两个我们都已经详细解析过了，接下来我们讨论一下JavaScript的多态。

◼ JavaScript有多态吗？

  • 维基百科对多态的定义：多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口，或使用一个单一的符号
  • 来表示多个不同的类型。
  • 非常的抽象，个人的总结：不同的数据类型进行同一个操作，表现出不同的行为，就是多态的体现。

◼ 那么从上面的定义来看，JavaScript是一定存在多态的。
image.png

ES6对象的增强知识

字面量的增强

◼ ES6中对 对象字面量 进行了增强，称之为 Enhanced object literals（增强对象字面量）。
◼ 字面量的增强主要包括下面几部分：

  • 属性的简写：Property Shorthand
  • 方法的简写：Method Shorthand
  • 计算属性名：Computed Property Names

解构Destructuring

◼ ES6中新增了一个从数组或对象中方便获取数据的方法，称之为解构Destructuring。

  • 解构赋值 是一种特殊的语法，它使我们可以将数组或对象“拆包”至一系列变量中。

◼ 我们可以划分为：数组的解构和对象的解构。
◼ 数组的解构：

  • 基本解构过程
  • 顺序解构
  • 解构出数组：…语法
  • 默认值

◼ 对象的解构：

  • 基本解构过程
  • 任意顺序
  • 重命名
  • 默认值

image.png
image.png

解构的应用场景

◼ 解构目前在开发中使用是非常多的：

  • 比如在开发中拿到一个变量时，自动对其进行解构使用；
  • 比如对函数的参数进行解构

image.png
image.png

Day06 作业布置

一. 完成课堂所有的代码

01-定义类结构

02- 类的构造函数

03-class和function的区别

04-对象访问器方法的编写

05-类的访问器方法的编写

06-类的静态方法
class Person {
constructor(age) {
this.age = age;
}
static createPerson() {
// return new Person(Math.floor(Math.random() 100));
return new this(Math.floor(Math.random() 100));
}
}
var p1 = new Person();
var createPerson = Person.createPerson();
console.log(createPerson);
07-继承

08-super用法

09-继承内置类

10-类的混入

二. 继承关系图中的各个关系

  • Function、Object、函数对象Foo的关系
  • 普通对象、Foo创建出来的对象之间的关系
  • 上面所有内容之间的关系
  • Function.proto === Function.prototype
    • 当 Function看做一个对象时
  • Object.proto == Function.prototype
    • 把Object 当成 new Function 创建出来的对象
  • Foo.prototype.proto === Object.prototype
    • Foo.prototype是个对象,所以有隐式原型
  • Function.prototype.proto === Object.prototype
    • Function.prototype 是个对象

  • Foo.proto === Function.prototype

    • Foo 看成new Function创建出来的对象

      三. 编写ES6的类并且实现继承


      Student 继承于Person

      四. 使用babel进行ES6转ES5操作，并且阅读源码

  • _classCallCheck(instance, Constructor) ，当你是person()调用，那 instance instanceof Constructor 表示Constructor的原型对象prototype在instance的原型链上即 Person的原型对象在window的原型链上 ，即false ,然后抛出异常

  • 为什么用 /#PURE/？#PURE/ 纯函数，说明这个函数没有副作用，当webpack压缩时,tree-shaking发现这个标记是个纯函数（说明没有副作用），那代码中没有用掉他，就可以删除这段代码
  • _defineProperties(target, props) 在原型上添加实例方法 或者在构造函数上添加类方法

    五. 说说你对面向对象多态的理解

    不同的数据类型进行同一个操作，表现出不同的行为，就是多态的体现

    六. 自己写出案例进行字面量增强、解构练习

    1.数组的解构
    var arr = [“张三”, “李四”, “王五”] // 数组的解构，按顺序 var [item1, item2, item3] = arr console.log(item1); // 解构后面的元素 var [, , item] = arr console.log(item); // 默认值,原本是undefined var [a, b, d, c = “eee”] = arr console.log(c); // 解构出一个元素，后面的元素放在一个新数组里 var [e, …newArr] = arr console.log(newArr);
    2.对象的解构
    var obj = { name: “张三”, age: 12, address: “上海” } // 对象的解构，没有顺序 // var { name, address, age } = obj // console.log(name, age, address); // 只解构一个元素 var { age } = obj console.log(age); //重命名 var { name: newName } = obj console.log(newName); // name没有被定义，报错 // console.log(name); // 默认值 var { height = 89 } = obj console.log(height); console.log(obj); // 重命名＋默认值 var { sex: newSex = “女” } = obj // sex没有被定义，报错 // console.log(sex); console.log(newSex); // 之前不用对象的解构 function foo(info) { console.log(info.name, info.age); } foo(obj) // 用对象的解构 function bar({ name, age, address }) { console.log(name, age, address); } bar(obj) // 常见的用法 function foo(info) { console.log(info.name, info.age); }
    3.字面量增强
    var message = “hello”; var age = 90; var obj = { // 属性的简写 message, age, // 方法的简写 eating() { console.log(“eat”); }, running: () => { console.log(this); }, //计算属性名 [message + “abc”]: “helloword”, }; console.log(obj);

作业与总结

一. 完成课堂所有的代码

01-定义类结构

<script>
      // 用两种方式定义类
      // 1.类声明
      class Person {}
      //2. 类表达式
      var Student = class {};
      //定义函数的两种方式
      // 1.函数声明
      function foo() {}
      //2.函数表达式
      var bar = function () {};
</script>

02- 类的构造函数

<script>
      class Person {
        // 类中的构造函数,通过new调用Person类是,默认调用class中的构造方法
        constructor(name, age) {
          this.name = name;
          this.age = age;
        }
        // 实例方法,放在Person.prototype
        running() {
          console.log(this.name + "在跑步");
        }
        singing() {
          console.log(this.name + "在唱歌");
        }
      }
      var p1 = new Person("张三", 88);
      p1.running();
      console.log(p1.name, p1.age);
      console.log(p1.__proto__ === Person.prototype);
      console.log(p1);
</script>

03-class和function的区别

<script>
      class Person {
        constructor(name, age) {
          this.name = name;
          this.age = age;
        }
        eating() {
          console.log(this.name + "eating");
        }
      }
      function Person2(name, age) {
        this.name = name;
        this.age = age;
      }
      var p1 = new Person("张三", 22);
      var p2 = new Person2("lili", 22);
      console.log(p1.__proto__ === Person.prototype);
      console.log(p2.__proto__ === Person2.prototype);
      console.log(Person.prototype.constructor);
      console.log(Person2.prototype.constructor);
      console.log(typeof Person);
      console.log(typeof Person2);
      //class定义的类,不能作为普通函数去调用
      // Person();
      // 构造函数可以作为普通函数去调用
      Person2();
</script>

04-对象访问器方法的编写

<script>
      // 对象的访问器方法的编写
      // 方式一
      var obj = {
        name: "张三",
        _age: 19,
      };
      Object.defineProperty(obj, "age", {
        configurable: false,
        enumerable: false,
        get: function () {
          return this._age;
        },
        set: function (val) {
          this._age = val;
        },
      });
      console.log(obj.age);
      obj.age = 33;
      console.log(obj.age);
      // 方式二
      var obj2 = {
        _address: "北京",
        set address(val) {
          this._address = val;
        },
        get address() {
          return this._address;
        },
      };
      console.log(obj2.address);
      obj2.address = "山东";
      console.log(obj2.address);
</script>

05-类的访问器方法的编写

<script>
      class Person {
        constructor(name) {
          this._name = name;
        }
        // 类的访问器方法
        get name() {
          console.log("调用了getter");
          return this._name;
        }
        set name(val) {
          console.log("调用了setter");
          this._name = val;
        }
      }
      var p1 = new Person("丽丽");
      console.log(p1.name);
      p1.name = "宝强";
// 坐标,长宽
      class Rectangle {
        constructor(x, y, width, height) {
          this.x = x;
          this.y = y;
          this.width = width;
          this.height = height;
        }
        get size() {
          return this.width * this.height;
        }
        get position() {
          return { x: this.x, y: this.y };
        }
      }
      var rec1 = new Rectangle(1, 2, 3, 4);
      console.log(rec1.size);
      console.log(rec1.position);
</script>

06-类的静态方法

class Person {
        constructor(age) {
          this.age = age;
        }
        static createPerson() {
          // return new Person(Math.floor(Math.random() * 100));
          return new this(Math.floor(Math.random() * 100));
        }
      }
      var p1 = new Person();
      var createPerson = Person.createPerson();
      console.log(createPerson);

07-继承

<script>
      class Person {
        constructor(name, age, address) {
          this.name = name;
          this.age = age;
          this._address = address;
        }
        // 实例方法
        running() {
          console.log(this.name + "在跑步");
        }
        // 访问器方法
        get address() {
          console.log("调用了getter");
          return this._address;
        }
        set address(val) {
          console.log("调用了setter");
          this._address = val;
        }
      }
      class Student extends Person {
        constructor(name, age, height, address) {
          super(name, age, address);
          this.height = height;
        }
      }
      var stu = new Student("张三", 23, 188, "北京");
      console.log(stu);
      stu.running();
      console.log(stu.address);
      stu.address = "黑龙江";
      var stu1 = new Student("李四", 77, 199);
      console.log(stu1);
</script>

08-super用法

<script>
      class Person {
        constructor(name, age, address) {
          this.name = name;
          this.age = age;
          this.address = address;
        }
        // 实例方法
        running() {
          console.log(this.name + "在跑步");
        }
        static createPerson() {
          // return new Person(Math.floor(Math.random() * 100));
          return new this(Math.floor(Math.random() * 100));
        }
      }
      class Student extends Person {
        // 调用父类的构造函数
        constructor(name, age, height, address) {
          super(name, age, address);
          this.height = height;
        }
        // 重写running方法
        running() {
          console.log("我是student里的");
          super.running();
        }
        static createStudent() {
          // return new Person(Math.floor(Math.random() * 100));
          // console.log("我是student里的静态方法");
          super.createPerson();
        }
      }
      var stu = new Student("张三", 23, 190, "北京");
      stu.running();
      var createPerson1 = Student.createPerson();
      console.log(createPerson1);
</script>

09-继承内置类

<script>
      class HyArray extends Array {
        // 最后一个元素
        get lastItem() {
          return this[this.length - 1];
        }
        // 第一个元素
        get firstItem() {
          return this[0];
        }
      }
      var arr = new HyArray(22, 33, 44, 55);
      console.log(arr.lastItem);
      console.log(arr.firstItem);
      // 在Array上进行扩展
      Array.prototype.lastItem = function () {
        console.log(this[this.length - 1]);
      };
      var arr1 = new Array(1, 2, 3, 4, 5);
      arr1.lastItem();
</script>

10-类的混入

<script>
      // JS只支持单继承
      function mixinStudent(baseClass) {
        return class extends baseClass {
          eating() {
            console.log("eating");
          }
        };
      }
      function mixinTeacher(baseClass) {
        return class extends baseClass {
          teaching() {
            console.log(this.name + "在教书");
          }
        };
      }
      class Person {
        constructor(name) {
          this.name = name;
        }
        running() {
          console.log(this.name + "在跑步");
        }
      }
      class Kid extends mixinStudent(mixinTeacher(Person)) {
        cry() {
          console.log("我只会哭");
        }
      }
      var kid = new Kid("李四");
      kid.running();
      kid.cry();
      kid.teaching();
      kid.eating();
</script>

二. 继承关系图中的各个关系

  • Function、Object、函数对象Foo的关系
  • 普通对象、Foo创建出来的对象之间的关系
  • 上面所有内容之间的关系
  • Function.proto === Function.prototype
    • 当 Function看做一个对象时
  • Object.proto == Function.prototype
    • 把Object 当成 new Function 创建出来的对象
  • Foo.prototype.proto === Object.prototype
    • Foo.prototype是个对象,所以有隐式原型
  • Function.prototype.proto === Object.prototype
    • Function.prototype 是个对象
  • Foo.proto === Function.prototype
    • Foo 看成new Function创建出来的对象

三. 编写ES6的类并且实现继承

<script>
      class Person {
        constructor(name, age, address) {
          this.name = name;
          this.age = age;
          this.address = address;
        }
        // 实例方法
        running() {
          console.log(this.name + "在跑步");
        }
        static createPerson() {
          // return new Person(Math.floor(Math.random() * 100));
          return new this(Math.floor(Math.random() * 100));
        }
      }
      class Student extends Person {
        // 调用父类的构造函数
        constructor(name, age, height, address) {
          super(name, age, address);
          this.height = height;
        }
        // 重写running方法
        running() {
          console.log("我是student里的");
          super.running();
        }
        static createStudent() {
          // return new Person(Math.floor(Math.random() * 100));
          // console.log("我是student里的静态方法");
          super.createPerson();
        }
      }
      var stu = new Student("张三", 23, 190, "北京");
      stu.running();
      var createPerson1 = Student.createPerson();
      console.log(createPerson1);
</script>

Student 继承于Person

四. 使用babel进行ES6转ES5操作，并且阅读源码

  • _classCallCheck(instance, Constructor) ，当你是person()调用，那 instance instanceof Constructor 表示Constructor的原型对象prototype在instance的原型链上
    即 Person的原型对象在window的原型链上 ，即false ,然后抛出异常
  • 为什么用 /#PURE/？
    #PURE/ 纯函数，说明这个函数没有副作用，当webpack压缩时,tree-shaking发现这个标记是个纯函数（说明没有副作用），那代码中没有用掉他，就可以删除这段代码
  • _defineProperties(target, props) 在原型上添加实例方法 或者在构造函数上添加类方法

五. 说说你对面向对象多态的理解

不同的数据类型进行同一个操作，表现出不同的行为，就是多态的体现

六. 自己写出案例进行字面量增强、解构练习

1.数组的解构

var arr = ["张三", "李四", "王五"]
// 数组的解构，按顺序
var [item1, item2, item3] = arr
console.log(item1);
// 解构后面的元素
var [, , item] = arr
console.log(item);
// 默认值,原本是undefined
var [a, b, d, c = "eee"] = arr
console.log(c);
// 解构出一个元素，后面的元素放在一个新数组里
var [e, ...newArr] = arr
console.log(newArr);

2.对象的解构

var obj = {
  name: "张三",
  age: 12,
  address: "上海"
}
// 对象的解构，没有顺序
// var { name, address, age } = obj
// console.log(name, age, address);
// 只解构一个元素
var { age } = obj
console.log(age);
//重命名
var { name: newName } = obj
console.log(newName);
// name没有被定义，报错
// console.log(name);
// 默认值
var { height = 89 } = obj
console.log(height);
console.log(obj);
// 重命名＋默认值
var { sex: newSex = "女" } = obj
// sex没有被定义，报错
// console.log(sex);
console.log(newSex);
// 之前不用对象的解构
function foo(info) {
  console.log(info.name, info.age);
}
foo(obj)
// 用对象的解构
function bar({ name, age, address }) {
  console.log(name, age, address);
}
bar(obj)
// 常见的用法
function foo(info) {
  console.log(info.name, info.age);
}

3.字面量增强

var message = "hello";
var age = 90;
var obj = {
  // 属性的简写
  message,
  age,
  // 方法的简写
  eating() {
    console.log("eat");
  },
  running: () => {
    console.log(this);
  },
  //计算属性名
  [message + "abc"]: "helloword",
};
console.log(obj);