JavaScript的Object中28个原型方法、静态方法和属性

Object.prototype原型方法、属性

序号	方法名	参数	返回值
1	constructor属性	-----------------------	返回实例构造函数
2	hasOwnProperty
3	isPrototypeOf(obj)	对象	调用此方法的对象是否存在与参数obj的原型链上。是返回布尔值true
4	propertyIsEnumerable(propName)	实例的属性名	属性是否可枚举，是返回布尔值true
5	toLocalString(obj)	对象	对象的字符串表示
6	toString(obj)	对象	对象的字符串表示
7	valueOf(obj)	对象	将对象转换为原始值

Object静态方法

序号	静态方法名	参数	返回值
1	assign(targetObj,sourceObj,s2,s3...)	目标对象，源对象	将源对象合并到目标对象，返回修改后的目标对象，浅拷贝
2	create(sourceObj)	源对象	以源对象为原型创建一个对象并返回
3	defineProperties(obj,props)	要修改的对象，修改后的属性	为一个对象声明多个属性，返回修改后的原对象
4	defineProperty(obj,propName,propVal)	要修改的对象，修改后的属性	为一个对象声明一个属性，返回修改后的原对象
5	entries(obj)	要遍历的对象	给定对象自身可枚举属性的键值对数组。
6	freeze(obj)	要冻结的对象	返回浅冻结的原对象
7	fromEntries(arr[arr1,arr2...])	键值对二维数组	从二维数组转化而来的对象
8	getOwnPropertyDescriptor(obj,propName)	对象，对象的属性名	返回对象的自有属性描述对象
9	getOwnPropertyDescriptors(obj)	对象	返回对象的所有自有属性描述对象组成的对象
10	getOwnPropertyNames(obj)	对象	对象自有属性名组成的数组
11	getOwnPropertySymbols(obj)	对象	对象自有Symbol类型的属性组成的数组
12	getPrototypeOf(obj)	对象	对象的原型
13	is(val,val2)	值	是同一个值返回布尔值true，不是返回false，无强制类型转换
14	isExtensible(obj)	对象	是否可扩展（可以添加属性），是返回布尔值true
15	isFrozen(obj)	对象	是否被冻结，被冻结返回布尔值true
16	isSealed(obj)	对象	是否是密封的，密封（不可扩展、不可删除、不可配置，不一定不可写），是密封返回布尔值true
17	keys(obj)	对象	由obj可枚举属性组成的数组
18	preventExtensions(obj)	对象	让对象变得不可扩展，不能添加属性，返回阻止扩展后的对象
19	seal(obj)	对象	密封一个对象，返回密封后的对象
20	setPrototypeOf(obj,obj2)	对象	将obj2设置为obj的原型
21	values(obj)	对象	由对象可枚举属性组成的数组

 代码示例：

        let p = (...args) => {
            console.log(...args);
        }
        
        p(Object.prototype);
        p('------------------------');
        let hero = {
            name:"Asia",
            id:23,
            say(){
                p(`I am ${this.name}`);
            }
        }
        let o = {
            id:24,
            sex:'man',
            ob:{
                a:{
                    b:"a"
                }
            }
        }
        
        // p(hero.constructor());
        
        // p(Object.assign(hero,o));
        // hero.ob.a.b = "00000";
        // p(hero);
        // p(o);
        
        // let tom = Object.create(hero);
        // p(tom);
        // tom.name = "tomA";
        // tom.say();
        
        // let result = Object.defineProperties(hero,{
        //     'newProperty1':{
        //         value:'val1',
        //         writable:true
        //     },
        //     'newProperty2':{
        //         value:"val2",
        //         writable:true,
        //     }
        // });
        // p(result);
        
        // let result = Object.defineProperty(hero,'newProperty',{
        //     value:'val',
        //     writable:true
        // });
        // p(result);
        
        // for(const [key,val] of Object.entries(hero)){
        //     p(key,val);
        // }
        
        // Object.freeze(hero);//浅冻结
        // hero.id = 9999;
        // p(hero.id);//
        
        // o = Object.fromEntries([
        //     ['a','aa'],
        //     ["b",'bb'],
        // ]);
        // p(o);
        
        // let result = Object.getOwnPropertyDescriptor(hero,'name');
        // p(result);
        
        // let result = Object.getOwnPropertyDescriptors(hero);
        // p(result);
        
        // let arr = Object.getOwnPropertyNames(hero);
        // p(arr);
        
        // let s1 = Symbol("a");
        // let s2 = Symbol('b');
        // hero[s1] = 'symbol1';
        // hero[s2] = 'symbol2';
        // let arr = Object.getOwnPropertySymbols(hero);
        // p(arr);
        
        // let result = Object.getPrototypeOf(hero);
        // p(result);
        
        // p(Object.is(1,1));
        // p(Object.is(1,"1"));
        
        // p(Object.isExtensible(hero));
        
        // p(Object.isFrozen(hero));
        
        // p(Object.prototype.isPrototypeOf(hero));
        
        // p(Object.isSealed(hero));
        
        // p(Object.keys(hero));
        
        // Object.preventExtensions(hero);//使hero不可扩展
        // hero.aaa = "1";
        // p(hero);
        
        // p(hero.propertyIsEnumerable('name'));
        
        // p(Object.seal(hero));
        
        // Object.setPrototypeOf(hero,null);
        // p(hero.prototype);
        
        // p(hero.toLocaleString());
        
        // p(hero.toString());
        
        // p(hero.valueOf());
        
        p(Object.values(hero));