27-第二十七章 面向对象OOP ECMAscrtipt5(三)

一、 ECMAScript 对象类型

在 ECMAScript 中，所有对象并非同等创建的。
一般来说，可以创建并使用的对象有三种：本地对象、内置对象 和 宿主对象 、自定义对象。

本地对象包括：

Object
Function
Array
String
Boolean
Number
Date
RegExp
Error
EvalError
RangeError
ReferenceError
SyntaxError
TypeError
URIError

内置对象：

ECMA-262 只定义了两个内置对象，即 Global（window） 和 Math
（它们也是本地对象，根据定义，每个内置对象都是本地对象）。

宿主对象:

1、所有非本地对象都是宿主对象（host object），即由 ECMAScript实现的宿主环境提供的对象。
2、所有 BOM和 DOM对象都是宿主对象。

二、 对象中函数改写及this指向

对象中函数改写

        var obj = {
            index: 888,
            get: function () {
                console.log('this is  get');
            },
            set: function () {
                console.log('this is set');
            }
        }
        obj.get(); // this is set

可以改写成如下

        var obj = {
            index: 888,
            get: function () {
                console.log('this is  get');

            },
            set: function () {
                console.log('this is set');

            }
        }
        obj.get(); // this is set    

对象中this指向，谁调用指向谁

        var obj = {
            show: function () {
                console.log(this); // 指向obj
            },
            name: {
                getname: function () {
                    console.log(this); // 指向name
                }
            }
        }
        obj.show();//指向obj
        obj.name.getname();// 指向name    

三 、ECMAScript5 对象的属性方法

一、对象属性

1、constructor

对创建对象的函数的引用（指针）。对于 Object 对象，该指针指向原始的 Object()函数。

二、对象方法

1、hasOwnProperty(property)

如何判断一个属性是否是原型上的
判断一个属性是否在原型上，不管在哪一层原型上
obj.hasOwnProperty(name)来判断一个属性是否是自有属性，自身属性还是继承原型属性。
必须用字符串指定该属性。

私有属性返回 true

公有属性返回 false

        function fn(index) {
            this.index = index;
        }
        fn.prototype.name = '二狗';
        var obj = new fn(88);
        console.log(obj.hasOwnProperty('index')); // true
        console.log(obj.hasOwnProperty('name')); // false

2、isPrototypeOf(object)

obj.isPrototypeOf( obj.prototype ) 判断该对象的原型是否为 xxxxx。 返回 true 或 false

        Obj.constructor.prototype.isPrototypeOf(Obj)  // true

3、propertyIsEnumerable()

obj.propertyIsEnumerable(‘name’) 判断对象给定的属性是否可枚举，即是否可用 for...in 语句遍历到,返回 true 或 false

        obj.propertyIsEnumerable('name')

4、getter/setter 函数

getter,setter:返回 property 的值得方法，值：function(){} 或 undefined 默认是 undefined

        var obj = {
            _name: 'hello',
            get name() {
                console.log('get');
                return this._name;
            },
            set name(val) {
                console.log('set');
                this._name = val;
                // return val;
            }
        };
        console.log(obj.name); // 'get'  'hello' // 获取值会触发get 函数
        console.log(obj.name = '二狗'); // 'set'  '二狗' // 设置值会触发set函数    

5.__defineGetter__(),__defineSetter__() 定义 setter getter 函数

在对象定义后给对象添加getter或setter方法要通过两个特殊的方法__defineGetter__和__defineSetter__。
这两个函数要求第一个是 getter 或 setter 的名称，以 string 给出，第二个参数是作为 getter 或 setter 的函数。

    var obj = {
        _name: '二狗',
    };
    obj.__defineGetter__('name', function () { return this._name }); // 定义 get name
    obj.__defineSetter__('name', function (val) { this._name = val }); // set name
    console.log(obj.name); // '二狗'
    console.log(obj.name = '小黑'); // '小黑'    

6.__lookupGetter__,__lookupSetter__返回 getter setter 所定义的函数

语法：

        obj.lookupGetter(sprop)
        var obj = {
            _name: '二狗',
            get name() { return this._name; },
            set name(val) { return this._name = val; }
        }
        console.log(obj.__lookupGetter__('name'));
        //function get name(){return this._name;}
        console.log(obj.__lookupSetter__('name')); //'小黑'
          // function set name(val){ return this._name=val; }

六、ECMAScript5 Object的新属性方法

1、Object.defineProperty(O,Prop,descriptor) Object.defineProperties(O,descriptors)

定义对象属性
O ——————————–为已有对象
Prop —————————为属性
descriptor—————–为属性描述符
descriptors —————-多个属性描述符？

在之前的 JavaScript中 对象字段是对象属性，是一个键值对，而在 ECMAScript5 中引入property ，property 有几个特征

Object.defineProperty 及 Object.defineProperties 定义默认为:

value：值，默认是undefined

writable：是否可写，默认是false,

enumerable：是否可以被枚举(for in)，默认false

configurable：是否可以被删除，默认false
普遍定义的为

下面利用defineProperty为o对象定义age属性，并且添加描述符
1.var o ={}
2.Object.defineProperty(o,'age', {

3.   value: 24,
   

4.   writable: true,
   

5.   enumerable: true,
   

6.   configurable: true
   

7. });
8. alert(o.age);//24
   下面defineProperties为o对象添加 多个描述符
9. var o ={}
10. Object.defineProperties(o,{

11.  age:{
    

12.       value: 24,
    

13.          writable: true,
    

14.           enumerable: true,
    

15.           configurable: true
    

16.   },
    

17.   name:{
    

18.        value: 'hello',
    

19.        writable: true,
    

20.        enumerable: true,
    

21.        configurable: true
    

22.   }
    

23. });
24. var val = o.age;//''get'
25. alert(val);//24
    下面defineProperties中特殊的get set
    1.function fn(name){
26. this._name = name;
27. }
29. var obj = new fn('二狗');
31. Object.defineProperties(obj,{

32. index:{value:1},
    

33. _age:{value:123,writable:true},
    

34. age:{
    

35.     //此处不能写value了
    

36.     get:function(){
    

37.         console.log('get');
    

38.         return this._age;
    

39.     },
    

40.     set:function(val){
    

41.         console.log('set');
    

42.         this._age = val;//_age 属性必须是writable:true，否则为set函数失效
    

44.     }
    

45.     /*此处get set 可以写成如下方式
    

46.     get(){
    

47.         console.log('get');
    

48.         return this._age;
    

49.     },
    

50.     set(val){
    

51.         console.log('set');
    

52.         this._age = val;//_age 属性必须是writable:true，否则为set函数失效
    

54.     }
    

55.     */
    

60. }
    

62. });
63. console.log( obj.age );// get 123
64. obj.age = 888;//set
65. console.log( obj.age );// get 888

2、Object.getOwnPropertyDescriptor(O,property)
获取对象的自有的指定的属性描述符

1.var Des = Object.getOwnPropertyDescriptor(obj,'hello');
2.alert(Des);//{value: undefined, writable: true, enumerable: true, configurable: true}
3、Object.keys(O,property)
获取所有的可枚举的属性名，非继承,返回数组

1.console.log(Object.kes( obj ); //["hello"]
4、Object.getOwnPropertyNames(O)
获取所有自有的属性名，非继承

1.console.log(Object.getOwnPropertyNames(obj)); //["hello", "index"]
5、Object.create(O, descriptors )
Object.create(O,descriptors)这个方法用于创建一个对象，并把其prototype属性赋值为第一个参数，同时可以设置多个descriptors ，第二个参数为可选，

以第一个参数为原型创建一个对象，即让新对象继承O

1. var obj =Object.create({

2. name:'小黑'，
   

3. age:20
   

4.});
以第一个参数为原型创建一个对象,并且多个属性描述符
1.var obj = Object.create({

2. name: '小黑',
3. age:20
5. },
6. {

7.    hello:{
   

8.        value:'00000',
   

9.        writable: true,
   

10.      enumerable: true,
    

11.      configurable: true},
    

12.    index:{
    

13.        value:'8888',
    

14.        writable: false,
    

15.      enumerable: false,
    

16.      configurable: false }
    

18.});

19. alert( obj.index);//8888
    6、Object.preventExtensions(O) / Object.isExtensible()
    Object.preventExtensions(O) 阻止对象拓展，即：不能增加新的属性，但是属性的值仍然可以更改，也可以把属性删除，
    Object.isExtensible(O)用于判断对象是否可拓展

20.    console.log(Object.isExtensible(o)); //true
    

21.    o.lastName = 'Sun';
    

22.    console.log(o.lastName);    //Sun ,此时对象可以拓展
    

23.    //////////////////////////////
    

24.    Object.preventExtensions(o);
    

25.    console.log(Object.isExtensible(o)); //false
    

27.    o.lastName = "ByronSun";
    

28.    console.log(o.lastName); //ByronSun，属性值仍然可以修改
    

30.    //delete o.lastName;
    

31.    console.log(o.lastName); //undefined仍可删除属性
    

33.     o.firstname = 'Byron'; //Can't add property firstname, object is not extensible 不能够添加属性
    

7、Object.seal(O) / Object.isSealed()
Object.seal(O)方法用于把对象密封，也就是让对象既不可以拓展也不可以删除属性（把每个属性的configurable设为false）,单数属性值仍然可以修改，Object.isSealed（）由于判断对象是否被密封

1.    Object.seal(o);
   

2.    o.age = 25; //仍然可以修改
   

3.    delete o.age; //Cannot delete property 'age' of #<Object>
   

8、Object.freeze(O) / Object.isFrozen()
终极神器，完全冻结对象，在seal的基础上，属性值也不可以修改（每个属性的wirtable也被设为false）