袁磊老师的课，ES6（三）

• 一、对象
  对象是类的一个具体实例

const Person = {
	name :'张三',
	//等同于birth：birth
	birth,
	//等同于hello：function（）...
	hello(){
	console.log('我的名字是:' , this.name);
}

}

• 二、动态属性

let lastWord = 'last word';
const a = {
	'first word' : 'hello',
	[lastWord]:'world'
}

• 三、class
  面向对象
  类的本质还是个方法

class Point{
	constructor(x,y){
	//构造函数，当创建一个对象实例的时候，要最先执行的函数，在类的内部，调用函数的属性的时候，要用this。
		this.x = x;
		this.y = y;
	}
	toString(){
		return '(' + this.x +',' + this.y +')';
}
}

构造函数的prototype属性，在ES6的“类”上面继续存在。事实上，类的所有方法都定义在类的prototype属性上面。

• 四、class的onstructor方法

class Point{ 
}
//等同于
class Point{
	constructor(){}
}

-五、class的继承
其实class并不能继承，还要用原型链的方式

class Point{    }

class ColorPoint extends Point{    }

语法演示

//super表示父类的构造函数
class Point{
	constructor(x,y){
		this.x = x;
		this.y  = y;
}
toString(){
	return'(' +  this.x + ',' + this.y +  ')'
}
}

- 练习1

 <script>
        class rect {
            constructor(w, h) {
                this.w = w;
                this.h = h;
                //在使用属性的时候，如果没this就不是属于这个实例的属性
                this.cname = "长方形";
            }
            zc() {
                console.log("zc: " + 2 * (this.w + this.h))
                // console.log("zc: "+ 2*(w+h))   这样写，不对！不加this就不事这个实例的
            }
            mj() {
                console.log("mj: " + this.w * this.h);
            }
        }

        let r1 = new rect(35, 78);
        let r2 = new rect(88, 10);
        r1.mj();
        r2.zc();
        console.log(rect.prototype == r1.__proto__);
        //定义一个类来继承
        class square extends rect {
            // 在ES6中的extends没有任何的深入效果，只不过是为了看的更清楚
            constructor(w) {
                super(w, w); //用super来调用父类的原型
                // this一定要在super之后调用
                this.cname = "正方形";
            }
        }
        // 定义两个正方形的实例
        let s1 = new square(66);
        let s2 = new square(30);
        s1.zc();
        s2.mj();
        // 进行一个扩展
        rect.prototype.say = function () {
            console.log(this.cname);
        }
        r1.say();
        s1.say();
        // 上面的运行结果表示可以被继承
        console.log(s1.__proto__ == square.prototype);
        // ES6里面不要写__proto__
        console.log(square.prototype.__proto__ == rect.prototype);
        // 介绍一种ES6独有的属性
        console.log(r1.hasOwnProperty("w"));
        // 有没有w这个自己的属性
        console.log(s1.hasOwnProperty("w"));
        console.log(s1.hasOwnProperty("h"));
        // s1也有父类的属性，h等于w而已。
        console.log(s1.h);
        console.log(s1.hasOwnProperty("mj"));//s1没有mj这个属性，因为mj是个方法

        


    </script>

• 六、Symbol
  相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就成为静态方法。

独一无二的值。它是JavaScript语言的第七种类型，只要是Symbol生成的值，就 不可能重复。
由于每个Symbol的值都是不相等的，经常作为标识符，用于对象的属性名，就能保证不会出现同名的属性。

class Foo{
	static classMethod(){
	return 'hello';
    }

}

如果想获得同一个Symbol
使用Symbol.for
练习2

   <script>
        let s1 = Symbol(); //定义一个Symbol
        let s2 = Symbol();
        // s1和s2永远不可能相同，你就别管为啥了
        console.log(s1);
        console.log(typeof (s1));
        //你会发现，打印出来的Symbol你是看不到的，你只需要知道，这个值是不同的就阔以了！
        console.log(s1 == s2);

        let obj = {
            [s1]: "yuanlei",
            sx: "shuxingzhi"
        }
        console.log(obj[s1]);

        // 有时候我们需要获得同一个Symbol的
        var f1 = Symbol.for("foo");
        var f2 = Symbol.for("foo");
        console.log(f1 == f2);
        //用相同的键值生成的Symbol可以获取到相同的Symbol
        console.log(Symbol.keyFor); //我们来获得一个Symbol的key是什么，如果能够将这次的key进行保存，那么下次就可以用相同的Symbol了。
        
    </script>

Okay今天的笔记就到这里了，拜拜