Object方法讲解

最新推荐文章于 2023-08-25 08:44:15 发布

iYannn

最新推荐文章于 2023-08-25 08:44:15 发布

阅读量61

点赞数

文章标签： javascript 原型模式开发语言

本文链接：https://blog.csdn.net/qq_52910120/article/details/127706418

版权

Object方法讲解

概述:Object是所有类的父类,他的方法和属性所有对象都可以使用

原型方法和属性

hasOwnProperty(判断当前对象是否具备这个属性不会读取原型上的属性)

        //原型方法是对象实例使用的  由于Object是顶层父类  所有的对象都可以调用他的原型方法
        let obj = {
            name: 'jack'
        }

        function Person(name, age) {
            this.name = name
            this.age = age
        }
        Person.prototype.sex = '男'
        let person = new Person('tom', 18)
        Person.address = '湖南长沙'
            //判断当前对象是否具备该属性  obj.hasOwnProperty()  不会读取原型上的属性  直接赋值可以读到
        console.log(person.hasOwnProperty('sex'));
        console.log(person.hasOwnProperty('address'));

isPrototypeOf(判断当前对象是否处在传入对象的原型链上)

function Person(){
    
}
function Son() {
            Person.call(this)
        }
        let person1 = new Person('tom', 18)
        Son.prototype = person1

        function Child() {
            Son.call(this)
        }
        let son = new Son()
        Child.prototype = son //在原型上添加son
        let child = new Child()
        console.log(person1.isPrototypeOf(son));
        console.log(son.isPrototypeOf(child));
        console.log(person1.isPrototypeOf(child));

__defineGetter 定义获取的方法 (废弃)

defineSetter 定义设置的方法 (废弃)

lookupGetter 返回定义的获取方法 **(废弃)

lookupSetter 返回定义的设置方法 **(**废弃)

 let obj1 = {
            name: 'tom',
            age: 18
        }
        let model = {
            name: 'tom',
            age: 18
        }
        obj1.__defineGetter__('name', function() {
            console.log('触发了');
            return model.name
        })
        obj1.__defineSetter__('name', function(v) {
            console.log('触发了');
            model.name = v
        })
        console.log(obj1.name);
        obj1.name = '你好'
        console.log(obj1.name);
        //propertyIsEnumerable  可以迭代的类型
        console.log(obj1.propertyIsEnumerable('name'));
        //根据本地格式转为字符串
        console.log(obj1.toLocaleString());
        //转为字符串
        console.log(obj1.toString());
        //valueof 提取对应的value值
        console.log(obj1.valueOf(name));

propertylsEnumerable 判断当前属性是否可以枚举(可以遍历)
toLocalString 根据本地格式转为字符串
toString 转为字符串
valueOf提取对应的value值

 //propertyIsEnumerable 传入一个属性 判断这个属性的Enumerable属性的结果是什么
       //Enumerable 可枚举 可以进行遍历
       console.log(obj.propertyIsEnumerable('name'));
       //转字符串
       console.log(obj.toLocaleString()); //本地格式
       console.log(obj.toString());
       //valueOf 返回对应的值
       console.log(obj.valueOf());

原型属性

contructor 指向当前对象的构造函数

__proto__对象的隐式原型

静态方法(Object.方法调用的)

Object.is判断两个对象是否一个对象

object.is(NaN,NaN)

assign 将后面的对象拷贝到第一个对象中(浅拷贝(第一层只拷贝值第二层拷贝的都是地址))

它返回的是目标对象的地址如果给了一个空数组去接收拷贝的值能拷贝到但是值地址并不相同

        let obj = {
                arr: [1, 2, 3]
            }
            //将后面对象的内容拷贝到前面这个对象里面返回前面这个对象
        let obj1 = Object.assign(obj, {
            name: 'jack'
        }, {
            age: 18
        })
        console.log(obj);
        console.log(obj1);
        console.log(obj1 == obj); //true
        //对应的浅拷贝完成 （浅拷贝只拷贝第一层的值 第二层拷贝的都是地址）
        let copyObj = Object.assign({}, obj)
        console.log(copyObj);
        console.log(copyObj == obj); //false

create 根据传入的内容创建相关的对象

这个传入的内容会在创建的对象的原型链上面 ,但是两个不是同一个对象

//create方法 
        function Person(name) {
            this.name = name
        }
        let person = new Person('tom')
            //根据传入对象创建相关的对象 但是这个对象跟传入的对象不是一个对象
            //它会将创建对象的原型指向传入对象
        let createObj = Object.create(person)
        console.log(createObj);
        console.log(person == createObj);//false
        console.log(person.isPrototypeOf(createObj));//true

keys 将可枚举的key全部加入到一个迭代器返回
values 将他的value全部加入到一个迭代器返回
entires 将他的键值队全部加入到一个迭代器返回

  //keys  values  entries
        let obj2 = {
            name: 'jack',
            age: 18,
            sex: '男'
        }
        console.log(Object.keys(obj2));//['name', 'age', 'sex']
        console.log(Object.values(obj2));//['jack', 18, '男']
        console.log(Object.entries(obj2));//[Array(2), Array(2), Array(2)]

getPrototypeOf获取原型
setPrototypeOf 设置原型

 //setPrototypeOf 设置原型
        function Child(name) {
            this.name = name
        }
        let child = new Child('tom')
        let proto = {
            address: '北京',
            city: "河北石家庄"
        }
        Object.setPrototypeOf(child, proto)
        console.log(child); //Child {name: 'tom'}
        //getPrototypeOf 获取原型
        let protoObj = Object.getPrototypeOf(child)
        console.log(protoObj); //{address: '北京', city: '河北石家庄'}

freeze 冻结（只能查询） isFrozen 是否冻结

seal 密封（只能查询和修改不能删除和添加新的属性）i sSealed **是否密封

preventExtensions 不可扩展（不能添加新的属性） isExtensible 是否可扩展

        let obj = {
                name: 'jack',
                age: 18,
                sex: '男'
            }
            //冻结  (只要冻结就会密封  密封必定不可拓展)
        Object.freeze(obj) //冻结当前的obj对象,只能查询
            // Object.seal(obj) //密封,能查询和修改
        obj.age = 20
        console.log(obj.name);
        delete obj.sex
        obj.address = '长沙'
        for (key in obj) {
            console.log(key);
        }
        console.log(obj);
        // Object.preventExtensions() //不可以扩展(不能添加新的属性)
        console.log(Object.isFrozen(obj)); //是否冻结
        console.log(Object.isSealed(obj)) //是否密封
        console.log(Object.isExtensible(obj)) //是否可拓展

freeze>seal>preventExtensions(冻结必定密封密封必定不可扩展)

getOwnPropertyNames 获取所有的属性名(除symbol的keys以外)
getOwnPropertySymbols 获取所有symbol为键的属性名
getOwnPropertyDescriptor 获取对应属性的详情(属性对象)
getOwnPropertyDescriptors 获取所有属性的详情(对象)

        let symbol = Symbol()
        let obj = {
            name: 'jack',
            age: 18,
        }
        obj[symbol] = '你好'
            //获取所有的属性名 传入的是一个对象 返回的是一个字符串数组(除了symbol)
        let names = Object.getOwnPropertyNames(obj)
        console.log(names);
        //获取所有的symbol修饰的属性(获取所有的symbol为键的属性) 返回symbol数组
        let symbols = Object.getOwnPropertySymbols(obj)
        console.log(symbols);
        //Descriptor  获取属性详情  返回是一个属相对象
        let desc = Object.getOwnPropertyDescriptor(obj, 'name')
        console.log(desc);
        //获取所有的属性(返回所有的属性详情  返回的是一个对象 每个对象的key是键名 值为属性对象)
        let desc1 = Object.getOwnPropertyDescriptors(obj)
        console.log(desc1);

属性对象(不定义的话默认为false)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qjt4WGlf-1667641310451)(C:\Users\ThankPad\AppData\Roaming\Typora\typora-user-images\1667638366237.png)]

defineProperty 定义单个属性

        let obj = {
            name: 'jack'
        }
        Object.defineProperty(obj, 'age', {
            configurable: true, //是否可以删除
            enumerable: false, //是否可枚举  是否可以被遍历
            value: 18,
            writable: true //是否可以修改
        })
        console.log(obj);
        //for in 只能遍历可枚举的属性
        for (key in obj) {
            console.log(key);
        }
        obj.age = 30
        console.log(obj);

defineProperties定义多个属性

  let obj1 = {}
        let model1 = {}
        Object.defineProperties(obj1, { //返回本身的话会一直调用函数
            username: {
                configurable: true,
                enumerable: true,
                get() {
                    console.log(model1.name);
                    return model1.username
                },
                set(v) {
                    model1.username = v
                }
            },
            password: {
                configurable: true,
                enumerable: true,
                get() {
                    return model1.password
                },
                set(v) {
                    model1.password = v
                }
            }
        })
        obj1.username = '张三'
        obj1.password = '123456'
        console.log(obj1);
        console.log(model1);

面试题

for in 和 Object,keys和Object.getOwnPropertyNames的区别

for in 包含继承的属性以及自身的属性(不包含不可枚举的属性)

Object.keys 只包含自身的属性(不包含继承的和不可枚举的属性)

Object.getOwnProertyNames只包含自身的属性(不包含继承的包含不可枚举的)

obj1.username = ‘张三’
obj1.password = ‘123456’
console.log(obj1);
console.log(model1);


### 面试题

#### for in 和 Object,keys和Object.getOwnPropertyNames的区别

for in 包含继承的属性以及自身的属性(不包含不可枚举的属性)

Object.keys 只包含自身的属性(不包含继承的和不可枚举的属性)

Object.getOwnProertyNames只包含自身的属性(不包含继承的  包含不可枚举的)

三个内容都不包含symbol属性