课件及源代码地址

精选留言(16)

• 
  yshAnswer

  2019-07-18

  “类成员的属性都是实例方法，不是原型属性，而类成员的方法都是实例方法”
  这里是不是口误讲错了，类成员的方法明明就在原型上

  作者回复: 是句口误，原话：
  “类成员的属性”都是实例属性，而不是原型属性；“类成员的方法”都是“实例”方法。
  
  纠正为：
  “类的成员属性”都是实例属性，而不是原型属性，“类的成员方法”都是“原型”方法。

  

   19
• 
  Hurry

  2019-07-24

  在 Typescript Playground，发现很奇怪的现象，下面的代码
  
  class Husky extends Dog {
    constructor(name: string, public type: string) {
      super(name)
      this.type = type
    }
  }
  
  转换后
  class Husky extends Dog {
      constructor(name, type) {
          super(name);
          this.type = type;
          this.type = type;
      }
  }
  
  this.type = type 出现了两遍

  展开

  作者回复: Husky 中的 this.color=color 可以删掉，参数加上public 相当于做了这个赋值。

  

   4
• 
  温宏杰

  2019-07-21

  我想要写一个有很多方法的工具类, 单独地写在一个文件中代码会很长不利于维护,我应该如何去写呢.之前想用装饰器的模式但是绕不过函数签名未实现的检查.

  作者回复: 类中如果有太多的方法，首先就要考虑这个设计是否合理。有几点建议：
  1）按功能拆分成多个类
  2）通过继承基类，减少子类的方法
  3）看方法中是否存在能够拆分出来的独立逻辑，每个函数的职责尽量要单一
  
  装饰器适用的场景是动态地为类添加新的能力，用在一个基础工具类中不是一个好的模式。

  

   4
• 
  怀念胜似相见

  2019-07-18

  和java好像呀，学习成本不高真是太好了，哈哈哈

  

   3
• 
  WL

  2019-07-21

  我的js基础不太好, 请问一下老师怎样理解原型属性和原型方法,跟实例属性和实例方法有啥区别?

  作者回复: JS 的继承方式是原型式继承，原型上的属性和方法是所有实例共享的，不需要共享的就放在构造函数中（也就是实例自己的属性和方法）。当调用实例的属性或方法时，先看实例自身有没有，如果没有就会沿着原型链查找。

  

   2
• 
  极客时间

  2019-07-28

  private比protected更加严格，
  被protected修饰的属性，虽然不能被实例直接访问，但是可以通过方法访问到，但是private就比较严格了，用private修饰的属性通过方法也访问不到：
  代码演示如下：
  private 修饰属性，然后用方法将其属性暴露，代码会报错
  ```
  type App=()=>{}
  class Dog{
      constructor(name:string){
          this.name=name;
          this.age =19
          this.eat = ():any=>{console.log(this.age)}
      }
      name:string;
      eat:App;
      private age:number
  }
  class Asd extends Dog{
      constructor(name:string){
          super(name)
          console.log(this.age)
      }
      pp(){
          console.log(this.age)
      }
  }
  
  let asd = new Asd("ppp")
  asd.pp()
  asd.eat()
  ```
  procted 修饰属性，然后用方法将其属性暴露，代码会正常运行：
  
  ```
  type App=()=>{}
  class Dog{
      constructor(name:string){
          this.name=name;
          this.age =19
          this.eat = ():any=>{console.log(this.age)}
      }
      name:string;
      eat:App;
      protected age:number
  }
  
  
  class Asd extends Dog{
      constructor(name:string){
          super(name)
          console.log(this.age)
      }
      pp(){
          console.log(this.age)
      }
  }
  
  let asd = new Asd("ppp")
  asd.pp()
  asd.eat()
  ```
  
  类的构造函数如果被protected修饰后，不能实例化，只能被继承，俗称基类，
  而类的构造函数被private修饰的话，既不能实例化，也不能被继承。
  
  在未学习ts执行，实现类的私有属性的时候，就是在构造函数中定义一个私有变量，但是通常会在实例上暴露一些方法，而方法又能访问到私有变量，这点和保护属性又有点类似，所有没有一个清晰的理解边界。学了ts后，了解到ts将这两种代码方式做了规范，一种将private一种叫protected
  
  还有我学习这个视频用了大概一个小时，是不是效率有点低呢？

  展开

  作者回复: 全部消化理解，一个小时并不多。赞笔记～

   2

   1
• 
  麦晓杰alwaysu

  2019-07-23

  1. 无论在es还是在ts中，类成员的属性都是实例属性，而不是原型属性，而类成员的方法都是实例方法
  2. 与es中不同的是：实例的属性必须具有初始值，或者在构造函数中被初始化。
  
  类的修饰符：
  public 对所有都是可见的
  protected 只能在类本身或者子类中访问，不能在实例中访问
  protected constructor 类只能被继承，不能被实例化，相当于基类
  private 只能在类本身调用，不能被实例或者子类调用
  private constructor 类不能被继承，也不能被实例化
  readonly 必须要初始化，不能被修改
  static 只能通过类名来调用，不能用实例来访问，可以被子类继承

  展开

  作者回复: 请看我对yshAnswer的回复

   1

   1
• 
  阿鑫

  2019-07-22

  类修饰符
  1. public: 所有人可见（默认）。
  2. private: 只能被类本身调用，不能被类的实例调用，也不能被子类调用。
  3. protected: 只能在类或类的子类中调用。
  4. readonly: 只读。
  5. static: 静态属性，可以被类或类的子类调用，不能被实例调用。

  展开

  

   1
• 
  coder

  2019-11-09

  9:30 左右，有一个口误：“然后我们再通过子类来访问一下”，屏幕上的代码输出了 `dog.food`。这个应该是通过“实例”来访问一下。

  

  
• 
  皮皮大神

  2019-09-27

  老师，我把这个Dog类，module.exports = Dog ,然后在index.ts引入后，实力话引入的对象居然能调用pri方法。let dc = new dogClass(); console.log(dc); dc.pri(); 如果只在class.ts中调用，会出现错误提示，这是什么情况啊

  作者回复: 你是怎么导入的呢？建议用es6方式导出导入

  

  
• 
  是方旭啊

  2019-08-25

  关于派生类必须调用super，调用super之后才能使用this，这个大家都是这么说和用的，但是归根到底是因为什么呢？有说法是Class的继承跟之前js的原型继承不一样，现在Class继承后的子类没有this，需要用父类的this。但还是不太清楚，能解答一下或者分享一个比较权威且详尽的文章么？感谢。

  作者回复: 举个例子来说明：
  传统 JavaScript 的继承：
  function Animal(name) {
      this.name = name;
  }
  function Dog(name) {
      Animal.call(this, name);
  }
  
  ES6的继承：
  class Animal {
      constructor(name) {
          this.name = name;
      }
  }
  class Dog extends Animal {
      constructor(name) {
          super(name);
      }
  }
  这里 super 的作用是调用父类 Animal 的构造函数来初始化子类 Dog，等价于 Animal.call(this, ...)。也就是说，只有相关的实例属性被绑定到 this 上后，才能调用 this.xxx。

  

  
• 
  lmran

  2019-08-19

  在typescript中， 接口可以继承类， 而类是需要需要实现类的，总觉得这两者有什么冲突（比如：一个类A实现了自己的方法，这是一个接口继承了这个类， 同时又有一个类B继承了这个接口， 那么这个类B需要再次实现类A中已经实现的方法吗？），
  而在java中， 就没有接口可以继承类的概念，能解释其中的原因吗？

  作者回复: 你的意思是类B“实现”了这个接口吧？看下面的例子：
  class A {
      method() {}
  }
  interface I extends A {}
  
  // B必须实现method
  class B implements I {
      method() {}
  }
  
  // C是A的子类，就不用实现method
  class C extends A implements I {}
  
  接口可以继承类，是为了从已知的类中直接抽离出成员结构，用作它用，比如去约束其他的变量。

  

  
• 
  Geek_737ef6

  2019-08-05

  我注意到这么一个现象：
  因为 JS 是基于原型的面向对象语言，所以
  class Animal {}
  class Dog extends Animal {}
  相当于是把 Animal.prototype 设为 Dog.prototype 的原型，也就是
  Animal.prototype.isPrototypeOf(Dog.prototype) // true
  但同时我也发现
  Animal.isPrototypeOf(Dog) // true
  这好像是 ES6 class 语法的特有行为，因为 Dog 本质上是一个函数，它的原型应该是 Function.prototype 才对，请问老师这样设计的目的是什么呢？

  展开

  作者回复:
  你要分清两条原型链：
  
  1）构造函数的原型链：Dog -> Anima -> Function
  Dog.__proto__ === Animal // true
  Animal.__proto__ === Function.prototype // true
  Animal.isPrototypeOf(Dog) // true，表示 Dog 在 Animal 的原型链上
  
  2）原型的原型链：Dog.prototype -> Animal.prototype -> Object.prototype
  Dog.prototype.__proto__ === Animal.prototype // true
  Animal.prototype.__proto__ === Object.prototype // true
  Animal.prototype.isPrototypeOf(Dog.prototype) // true， 表示 Dog.prototype 在 Animal.prototype 的原型链上

  

  
• 
  fy

  2019-07-24

  Typescript这就是静态语言的特点。不仅仅变量的类型需要声明.

  

  
• 
  limmy

  2019-07-23

  已经学完10节课了，什么时候更新下一节课程呢？

  编辑回复: 每周四固定更新。

  

  
• 
  Geek_6a0ee9

  2019-07-20

  后续的课程什么时候更新

  编辑回复: 每周四更新

  

  