极客时间-轻松学习，高效学习-极客邦

yshAnswer

2019-07-18

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

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

纠正为：
“类的成员属性”都是实例属性，而不是原型属性，“类的成员方法”都是“原型”方法。



 22
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 相当于做了这个赋值。



 5
温宏杰

2019-07-21

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

作者回复: 类中如果有太多的方法，首先就要考虑这个设计是否合理。有几点建议：
1）按功能拆分成多个类
2）通过继承基类，减少子类的方法
3）看方法中是否存在能够拆分出来的独立逻辑，每个函数的职责尽量要单一

装饰器适用的场景是动态地为类添加新的能力，用在一个基础工具类中不是一个好的模式。



 4
怀念胜似相见

2019-07-18

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



 3
阿鑫

2019-07-22

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

展开

 1

 2
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
大可可

2020-02-08

super 是代表父类的实例还是代表父类的构造函数

作者回复: 父类的实例




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

后续的课程什么时候更新

编辑回复: 每周四更新



