Object 相关属性方

web修理工

已于 2022-02-22 15:17:44 修改

阅读量130

点赞数

分类专栏： JavaScript 文章标签： javascript

于 2021-08-10 14:45:01 首次发布

本文链接：https://blog.csdn.net/qq_42374676/article/details/119569650

版权

JavaScript 专栏收录该内容

163 篇文章 2 订阅

订阅专栏

参考:https://www.cnblogs.com/z-dl/p/8204023.html

1.Object.apply 借用其他对象的方法
2.Object.assign 拷贝属性
3.Object.arguments 函数内部的隐藏参数,用来接受实参,保存实参
4.Object.call 借用其他对象的方法
5.Object.create 创建一个新的对象,并设置原型对象
6.Object.caller 返回一个函数,返回调用当前函数的函数
在全局作用域调用返回null
7.Object.constructor 指向对用的构造函数
8.Object.getOwnPropertyDescriptor 获取对象中某个实例属性的描述信息
configurable 是否可配置(1.是否可删除 2.是否可以修改该配置)
enumerable 是否可枚举
value 值
writable 是否可修改
9.Object.defineProperty 定义一个属性,并设置这个属性的描述信息
1>.如果修改已经存在的属性默认是true
2>.如果添加新的属性,默认是false
10.Object.getOwnPropertyNames 获取实例属性的属性名返回一个数组,数组存放所有的属性名
11.Object.keys 获取属性名只获取实例属性,不包括不可以枚举的实例属性
12.Object.getPrototypeOf 获取一个对象的原型对象

13.Object.preventExtensions | Object.isExtensible
禁止扩展,不能添加属性,可以删除和修改
14.Object.seal 密封对象 | Object.isSealed
不能添加属性,不能删除,可以修改
15.Object.freeze 冻结对象 | Object.isFrozen
不能添加属性,不能删除,不能修改

    //  valueOf() 返回当前对象对应的值
    //  toString()返回当前对象对应的字符串形式,用来判断一个值的类型
    //  toLocaleString()返回当前对象对应的本地字符串形式
    //  hasOwnProperty()判断某个属性是否为当前对象自身的属性，还是继承自原型对象的属性
    //  isPrototypeOf()判断当前对象是否为另一个对象的原型
    //  propertyIsEnumerable()判断某个属性是否可枚举


<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Object静态方法</title>
</head>

<body>
    <script>
        // Object.create() 创造对象
        // Object.defineProperty() 修改对象
        // Object.getOwnPropertyDescriptor() 描叙对象
        // ----------------------------------------------------
        //Object.keys()  Object.getOwnPropertyNames
        // 可枚举的属性
        let obj = {
            name: 'zs',
            age: 18,
            sex: '女'
        }
        //------------------------------------------------------
        var obj1 = Object.create({
            pro: 'xx'
        }, {
            name: {
                value: 'lis',
                // 可枚举
                enumerable: true
            },
            age: {
                value: 18,
                // 不可枚举
                enumerable: false,
                // 可修改属性
                configurable: true
            },
            sex: {
                value: '男',
                // 可枚举
                enumerable: true,
                // 可修改属性
                configurable: true
            },
        })
        // 不可枚举属性 (){pro: 'xx'} 原型属性  name age sex 为实例属性 
        // configurable: 当且仅当该属性的 configurable 为 true 时，该属性描述符才能够被改变，同时该属性也能从对应的对象上被删除。默认为 false。
        // enumerable: 当且仅当该属性的enumerable为true时，该属性才能够出现在对象的枚举属性中。默认为 false。
        // value: 该属性对应的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。默认为 undefined。
        // writable: 当且仅当该属性的writable为true时，value才能被赋值运算符改变。默认为 false。
        // getter: 一个给属性提供 getter 的方法，如果没有 getter 则为 undefined。该方法返回值被用作属性值。默认为 undefined。
        // setter:  一个给属性提供 setter 的方法，如果没有 setter 则为 undefined。该方法将接受唯一参数，并将该参数的新值分配给该属性。默认为 undefined。
        // 注意：如果一个描述符同时设置value,writable,get和set关键字，它将被认为是一个数据描述符。如果一个描述符同时有value或writable和get或set关键字，将产生异常。

        // Object.getOwnPropertyNames方法还能返回不可枚举的属性名
        // Object.getOwnPropertyDescriptor( obj, prop)  返回一个指定对象上的自有属性对应的属性描述 （自由属性指，直接赋值的属性，不需要从原型上查找的属性）
        // Object.defineProperty( obj, prop, decriptor)  直接在一个对象上定义一个新属性，或修改一个对象的现有属性，并返回这个对象，默认情况下使用此方法添加的属性值是不能被修改的 


        console.log('obj:', obj)
        console.log('keys:', Object.keys(obj)) // ["name", "age", "sex"]
        console.log('getOwnPropertyNames:', Object.getOwnPropertyNames(obj)) // ["name", "age", "sex"]
        console.log('getOwnPropertyDescriptor:', Object.getOwnPropertyDescriptor(obj, 'name')) // {configurable: true, enumerable: true,value: "lis",writable: true}
        console.log('getOwnPropertyDescriptors:', Object.getOwnPropertyDescriptor(obj)) // {configurable: true, enumerable: true,value: "lis",writable: true}
        console.log('defineProperty', Object.defineProperty(obj, 'age', {
            configurable: true, enumerable: false, value: "lis", writable: false
        }))
        console.log('defineProperties:', Object.defineProperties(obj, {
            sex: {
                configurable: true, enumerable: false, value: "lis1", writable: true
            },
            love: {
                configurable: true, enumerable: true, value: "打球", writable: true
            },
        }))
        console.log('propertyIsEnumerable', obj.propertyIsEnumerable("love"))

        console.log('-----------------------------------------------------------------------------------')
        console.log('obj1:', obj1)
        console.log('keys:', Object.keys(obj1))  // ["name", "sex"]
        console.log('getOwnPropertyNames:', Object.getOwnPropertyNames(obj1)) //  ["name", "age", "sex"]
        console.log('getOwnPropertyDescriptor:', Object.getOwnPropertyDescriptor(obj1, 'name')) // {configurable: false, enumerable: true,value: "lis",writable: false}
        console.log('getOwnPropertyDescriptors:', Object.getOwnPropertyDescriptors(obj1)) // {configurable: false, enumerable: true,value: "lis",writable: false}

        console.log('defineProperty', Object.defineProperty(obj1, 'age', {
            configurable: true, enumerable: false, value: "lis", writable: true
        }))
        console.log('defineProperties:', Object.defineProperties(obj1, {
            sex: {
                configurable: true, enumerable: false, value: "lis1", writable: true
            },
            love: {
                configurable: true, enumerable: false, value: "打球", writable: true
            },
        }))

        console.log('propertyIsEnumerable', obj1.propertyIsEnumerable("sex"))


        // 4.控制对象状态的方法
        // Object.preventExtensions() 防止对象扩展
        // Object.isExtensible() 判断对象是否可扩展
        // Object.seal() 禁止对象配置
        // Object.isSealed() 判断一个对象是否可配置
        // Object.freeze() 冻结一个对象
        // Object.isFrozen() 判断一个对象是否被冻结
        console.log('-----------------------------------------------------------------------------')
        let object1 = {};
        Object.preventExtensions(object1);
        // 阻止对象扩展，让一个对象变的不可扩展，也就是永远不能再添加新的属性
        try {
            Object.defineProperty(object1, 'property1', {
                value: 42
            });
        } catch (e) {
            console.log(e);
            // expected output: TypeError: Cannot define property property1, object is not extensible
        }

        try {
            object1.property.remove = function () {
                console.log('remove')
            }
        } catch (e) {
            console.log(e)
        }

        console.log('isExtensible:', Object.isExtensible(obj))
        console.log('isExtensible:', Object.isExtensible(obj1))
        console.log('isExtensible:', Object.isExtensible(object1))
        // Object.seal()
        // 让一个对象密封，并返回被密封后的对象。密封对象是指那些不能添加新的属性，不能删除已有属性，以及不能修改已有属性的可枚举性、可配置性、可写性，但可以修改已有属性的值的对象
        let object = {}
        Object.seal(object)
        object1.name = 'zs'
        object.name = 'zs'
        try {
            object.property.remove = function () {
                console.log('remove')
            }
        } catch (e) {
            console.log(e, '===')
        }

        console.log('isSealed:', Object.isSealed(object))
        console.log('isSealed:', Object.isSealed(object1))
        console.log(object)
        console.log(object1)
        // Object.freeze() 冻结一个对象
        //这个方法比 Object.seal 更绝，冻结对象是指那些不能添加新的属性，不能修改已有属性的值，不能删除已有属性，以及不能修改已有属性的可枚举性、可配置性、可写性的对象。也就是说，这个对象永远是不可变的。

        console.log('原型:---------------------------')
        // Object.creat() 可以指定原型对象和属性，返回一个新的对象
        // Object.getPrototypeOf() 获取对的的Prototype对象
        var a = {
            pro: 'xx'
        }
        var objp = Object.create(a, {
            name: {
                value: 'xs'
            }
        })
        console.log('create', objp)
        console.log('getPrototypeOf:', Object.getPrototypeOf(objp))
        console.log('isPrototypeOf:', Object.prototype.isPrototypeOf(a))
        console.log('hasOwnProperty:', objp.hasOwnProperty('name'), objp.hasOwnProperty('pro'))  // 实例属性
        console.log('---------------------')
        // Object.setPrototypeOf() ,Object.getPrototypeOf()
        console.log('getPrototypeOf:', Object.getPrototypeOf(objp))
        console.log('propertyIsEnumerable', objp.propertyIsEnumerable("name"))
        // 替换原型
        // console.log('setPrototypeOf:', Object.setPrototypeOf(objp, { age: '19' }), objp)

        //  valueOf() 返回当前对象对应的值
        //  toString()返回当前对象对应的字符串形式,用来判断一个值的类型
        //  toLocaleString()返回当前对象对应的本地字符串形式
        //  hasOwnProperty()判断某个属性是否为当前对象自身的属性，还是继承自原型对象的属性
        //  isPrototypeOf()判断当前对象是否为另一个对象的原型
        //  propertyIsEnumerable()判断某个属性是否可枚举

        function Person(obj) {
            this.init(obj)
        }
        Person.prototype = {
            init(obj) {
                this.name = obj.name;
                this.age = obj.age;
                this.sex = obj.sex;
            },
            print() {
                console.log(`${this.name}今年${this.age},是${this.sex}`)
            }
        }
        var person = new Person({
            name: 'xiaoming',
            age: 18,
            sex: '男'
        })
        console.log('valueOf:', person.valueOf())
        console.log('toString:', person.toString())
        console.log('toLocaleString:', person.toLocaleString())
        console.log('hasOwnProperty:', person.hasOwnProperty('name'))
        console.log('isPrototypeOf:', Object.prototype.isPrototypeOf(Person))
        console.log('propertyIsEnumerable', person.propertyIsEnumerable("name"))

        //  目前，有四个操作会忽略enumerable为false的属性。
        //　for...in循环：只遍历对象自身的和继承的可枚举的属性。
        //  Object.keys()：返回对象自身的所有可枚举的属性的键名。
        //  JSON.stringify()：只串行化对象自身的可枚举的属性。
        //  Object.assign()： 忽略enumerable为false的属性，只拷贝对象自身的可枚举的属性。
        //  ES6 规定，所有 Class 的原型的方法都是不可枚举的
        //  属性的遍历一共有5种：
        //  for...in循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）。
        //  Object.keys返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）的键名。
        //  Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名。
        //  Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性的键名。
        //  Reflect.ownKeys返回一个数组，包含对象自身的所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举。

        // 深拷贝
        console.log('-----------------------------------------------------------------')
        var target = {
            name: 'zs'
        }
        var sources = {

            age: 18,
            sex: '女'



        }
        var b = {
            car: 'car'
        }

        function merge(target, sources, b) {
            return Object.assign(target, sources, b);
        }
        var objz = merge(target, sources)
        objz.name = 'ls'
        console.log(objz, target, '===merge')

        //如果希望合并后返回一个新对象，可以改写上面函数，对一个空对象合并。

        // const merge = (...sources) => Object.assign({}, ...sources);


        // 4.Object.is() 它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致

        Object.is('foo', 'foo')
        // true
        Object.is({}, {})
            // false
            // 不同之处只有两个：一是+0不等于-0，二是NaN等于自身。
            + 0 === -0 //true
        NaN === NaN // false

        Object.is(+0, -0) // false
        Object.is(NaN, NaN) // true

        // is 方法实现
        Object.defineProperty(Object, 'is', {
            value: function (x, y) {
                if (x === y) {
                    // 针对+0 不等于 -0的情况
                    return x !== 0 || 1 / x === 1 / y;
                }
                // 针对NaN的情况
                return x !== x && y !== y;
            },
            configurable: true,
            enumerable: false,
            writable: true
        });

    </script>
</body>

</html>