javascript 类的理解

1. 每个对象的每个属性都有以下3个"property attribute"

   
   

2. // Create a user-defined object.

3. var obj = {};

4. // Add a data property to the object.

5. Object.defineProperty(obj, "newDataProperty", {
       value: 101,
       writable: true,
       enumerable: true,
       configurable: true});

6. Object.defineProperty(obj, "newAccessorProperty", {
       set: function (x) {
           document.write("in property set accessor" + newLine);        this.newaccpropvalue = x;
       },
       get: function () {
           document.write("in property get accessor" + newLine);        return this.newaccpropvalue;
       },
       enumerable: true,
       configurable: true});

2.每个对象，除了属性外，还有以下3个"object attribute"

prototype:指向另一个对象，原型对象

class：

extensible flag:是否可在该对象中添加新属性

3.创建对象：

 直接量

var obj = {};

 关键字new,Person函数叫构造函数constructor

var obj = new Person();

 Object.create()；

 所有通过对象直接量创建的对象都具有同一个原型对象，可以通过Object.prototype获得对原型对象的引用。

 通过new和构造函数调用创建的对象的原型就是构造函数的属性prototype的值。即用该构造函数创造的所有对象实例都继承自同一个原型。继承同一个原型即为同一类的实例！(r instanceof Range//如果r继承自Range.prototype，则返回true）

 construnctor

 Box.prototype为一个对象，如Box.prototype={a:123,getName:function(){}},单一般不这么用。任何javascript函数都可以用作构造函数，并且调用构造函数是需要用到一个prototype属性的。因此，每个javascript函数都自动拥有一个prototype属性。这个属性的值是一个对象，这个对象包含为一一个不可枚举属性constructor。constructor属性的值是一个函数对象。即

var F = function(){};//这是一个函数对象
var p = F.prototype;//这是F相关联的原型对象
var c = p.constructor;
c == F //true

构造函数的原型中存在预先定义好的constructor属性，这意味着对象通常继承的constructor均指代他们的构造函数。由于构造函数是类的“公共标识”，因此这个constructor属性为对象提供了类。

var o = new F();
o.constructor === F//true

            function Box(name){
                this.name = name;
                this.run = function () {
                    console.log(this.name)
                }
            }
            
            Box.prototype.run2 = function () {};
            var box = new Box("by");
             
            console.log(box.__proto__);//Box {run2: function}
            //__proto__实例指向原型对象的一个指针
            console.log(box.prototype);//undefined
            console.log(Box.prototype);//Box {run2: function}
            console.log(Box.prototype.isPrototypeOf(box));//true
            console.log(Box === box.constructor);//true
            Box.prototype = {};//这个新对象重写了预先定义的对象，所以没了constructor属性
            var box2 = new Box("s");
            console.log(Box === box2.constructor);//false

 所以要么 Box.prototype ={
             construnctor:Box,
             name:"by"
          };
  要么   Box.name = "by";

字面量方式为什么 constructor 会指向 Object？因为 Box.prototype={};这种写法其实就是创建了一个新对象。而每创建一个函数，就会同时创建它 prototype，这个对象也会自动获取 constructor 属性。所以，新对象的 constructor 重写了 Box 原来的 constructor，因此会指向新对象，那个新对象没有指定构造函数，那么就默认为 Object。原型的声明是有先后顺序的，所以，重写的原型会切断之前的原型。

            var box3 = {
                name:"b",
                height:"123"
            };
            console.log(box3.constructor);//function Object(){}