js高级属性

js对象高级属性

每个对象里面都有个默认get``set方法，
get:获取属性方法
set:修改属性方法

1.writable是否可更改，还是只读

let prson = {};//注意这里是defineProperty而不是defineProperties
//defineProperty第一个参数是对象名，第二参数对象属性名，第三个是属性值的对象
Object.defineProperty(prson, "name", {
            writable: false,//这里设置false是不允许修改的
            value: '奥术大师'
 })
        console.log(prson);
        prson.name='胜多负少的'
        console.log(prson);

2.configurable是否可以删除如果为false则不能删除，也不能修改

 let prson = {};
        Object.defineProperty(prson, "name", {
            configurable: true,
            value: '奥术大师1'
        })
        delete prson.name //先删除
        console.log(prson);
        prson.name = '胜多负少的'	//再赋值
        console.log(prson);

3.Enumaerable枚举

 var obj = { a: 1, b: 2 };
        obj.c = 3;
        Object.defineProperty(obj, 'd', {
            value: 4,
            enumerable: false
        });
        console.log(obj);
       for (var key in obj) console.log(obj[key]); 

如果使用Enumaerable那么下面三种方法是无法检测到改属性

• for…in循环
  Object.keys方法
  JSON.stringify方法

访问器属性

访问器属性是不能直接定义的，必须使用Object.defineProperty()

定义一个对象对象里面包含伪私有成员,公共成员,私有成员

let obj={
	year_:'伪私有成员',
	age:18//公共成员
	_name:'私有成员',
}

这里面主要区分 _ 的作用，这种写法是约定俗成的并不是一定是这样

访问器属性里面有默认的getter setter访问器属性是优先于数据属性

• 访问器属性也有4个特征（configurable,enumerable,get,set）
• 不能直接定义，需要使用Object.defineProperty（）来定义;__proto__就是一个访问器属性，不能对其随意设置的，会有拦截。

工厂模式创建对象缺点，创建所有的对象都是object类型，无法进一步区分（obj对象赋值）

这个相当于我创建了无数个人，然后在每个人身上安装2个眼睛一个鼻子

 function createObj(name, age, adress) {
            var o = new Object();//每个创建的都是值得这个对象类型也只能是对象类型
            o.name = name;
            o.age = age;
            o.getName = function () {
                return this.name
            }
            o.adress = adress;
            return o
        }
        let aa = createObj('creaObj', 18, {
            name: '我创建的对象',
            code: '10000'
        });
        let aa2 = createObj('creaObj', 18, {
            name: '我创建的对象',
            code: '10000'
        });
        console.log(aa.getName === aa2.getName);//false

这是一段构造函数构建的对象每个对象都开辟一个地址，这是缺点（this赋值）

这个打个比方就相当于我创建了n个对象每个对象都从我这里拿眼睛和鼻子 ，那么基本属性都是眼睛和鼻子，复杂属性至于眼睛和鼻子安装没安装那就是不同的结果，有的只安装了一个眼睛

function Person() {
            this.name = "cao";
            this.age = 18
            this.adress = {
                name: '伤害哦',
                code: '109001'
            }
            this.getName = function () {
                return this.name
            }
        }
        // 生成两个实例
        var person = new Person()
        var person2 = new Person()
        console.log(person.adress === person2.adress);//false  同样的方法开辟了两个空间
        console.log(person.name === person2.name);//true

基于原型对象创建（prototype）

这个打个比方就相当于在人的磨具原型添加眼睛和鼻子，每个人拿到磨具就赋值的一样的

        function Person() {
            Person.prototype.name = "cao";
            Person.prototype.age = 18
            Person.prototype.adress = {
                name: '伤害哦',
                code: '109001'
            }
            Person.prototype.getName = function () {
                return this.name
            }
        }
        // 生成两个实例
        var person = new Person()
        var person2 = new Person()
        console.log(person.getName === person2.getName);//true
        console.log(person.name === person2.name);//true

构造函数和原型混合的模式

构造函数和原型混合的模式是目前最常见的创建自定义类型对象的方式
构造函数中用于定义实例的属性，原型对象中用于定义实例共享的属性和函数，通过构造函数传递参数，这样每个实例都能拥有自己的属性值，同时实例还能共享函数的引用，最大限度节约内存的空间，混合模式可谓集二者之所长

   // 构造函数 不共享
        function createObj(name, age, adress) {
            this.name = name
            this.age = age
            this.adress = adress
        }
        // 原型 共享属性
        createObj.prototype.getName = function () {
            return this.name
        }
        var aa = new createObj('zjb', 18, {
            name: '上海',
            code: 1000
        })
        var aa2 = new createObj('zjb2', 118, {
            name: '上海1',
            code: 10001
        })
        console.log(aa.getName === aa2.getName);