1 function Point(x, y) {
 2   this.x = x;
 3   this.y = y;
 4 }
 5
 6 Point.prototype.toString = function () {
 7   return '(' + this.x + ', ' + this.y + ')';
 8 };
 9
10 var p = new Point(1, 2);

 1 //定义类
 2 class Point {
 3   constructor(x, y) {
 4     this.x = x;
 5     this.y = y;
 6   }
 7
 8   toString() {
 9     return '(' + this.x + ', ' + this.y + ')';
10   }
11 }
12 typeof Point // "function"
13 Point === Point.prototype.constructor // true
14 //ES6 的类，完全可以看作构造函数的另一种写法。

class Point {constructor() {// ...
  }toString() {// ...
  }toValue() {// ...
  }
}// 等同于

Point.prototype = {constructor() {},toString() {},toValue() {},
};

 1 Object.assign(Point.prototype, {
 2   toString(){},
 3   toValue(){}
 4 }); 5// 类的内部所有定义的方法，都是不可枚举的
 6
 7 Object.keys(Point.prototype)
 8 // []   es5 : ["toString"]
 9 Object.getOwnPropertyNames(Point.prototype)
10 // ["constructor","toString"]

let methodName = 'getArea';class Square {constructor(length) {// ...
  }[methodName]() {// ...
  }
}

 1 class Point {
 2 }
 3
 4 // 等同于
 5 class Point {
 6   constructor() {} //JavaScript 引擎会自动为它添加一个空的constructor方法。
 7 }
 8 // 等同于
 9 new Point (){
10
11 }
12 constructor方法默认返回实例对象（即this），完全可以指定返回另外一个对象。
13
14 class Foo {
15   constructor() {
16     return Object.create(null);
17   }
18 }
19
20 new Foo() instanceof Foo
21 // false

 1 const MyClass = class Me {
 2   getClassName() {
 3     return Me.name;
 4     //这个类的名字是MyClass而不是Me，Me只在 Class 的内部代码可用，指代当前类。
 5   }
 6 };
 7 //内部没用到Me的话可以省略Me
 8 const YouClass = class {
 9 //...
10 };
11 采用 Class 表达式，可以写出立即执行的 Class。
12
13 let person = new class {
14   constructor(name) {
15     this.name = name;
16   }
17
18   sayName() {
19     console.log(this.name);
20   }
21 }('张三');
22
23 person.sayName(); // "张三"

//第一种
class Widget {// 公有方法
  foo (baz) {this._bar(baz);}// 私有方法
  _bar(baz) {return this.snaf = baz;}// _bar方法前面的下划线，表示这是一个只限于内部使用的私有方法 但是，在类的外部，还是可以调用到这个方法。
}//第二种
class Widget {foo (baz) {bar.call(this, baz);}// 内部调用了bar.call(this, baz)，成为了当前模块的私有方法
}
//私有方法移出模块
function bar(baz) {return this.snaf = baz;
}//第三种
const bar = Symbol('bar');
const snaf = Symbol('snaf');export default class myClass{// 公有方法
  foo(baz) {this[bar](baz);}// 私有方法
  [bar](baz) {return this[snaf] = baz;}// 利用Symbol值的唯一性，将私有方法的名字命名为一个Symbol值。
};

class Point {#x=0;// 私有属性可以指定初始值，在构造函数执行时进行初始化。
constructor(x = 0) {#x = +x; // 写成 this.#x 亦可
  }get #x() { return #x }set #x(value) { #x = +value }#sum() { return #a + #b; }  //私有方法//  #x是一个私有属性，它的读写都通过get #x()和set #x()来完成。 #x和x是两个不同的属性
}
//JavaScript 是一门动态语言，没有类型声明，使用独立的符号似乎是唯一的比较方便可靠的方法，能够准确地区分一种属性是否为私有属性。"@" 已经留给了 Decorator。

class Foo {#privateValue = 42;static getPrivateValue(foo) {return foo.#privateValue;}
}Foo.getPrivateValue(new Foo()); // 42
console.log(Foo.#privateValue) // 报错

//class 的取值函数（getter）和存值函数（setter）

class MyClass {constructor() {// ...
  }get prop() {return 'getter';}set prop(value) {console.log('setter: '+value);}
}let inst = new MyClass();inst.prop = 123;
// setter: 123

inst.prop
// 'getter'