js 中对Object 方法 的整理总结

这几天逛了逛各个论坛，和博主的博客，自己想的总结备份一个Object的用法，供自己使用，本文大多是代码的搬运，如有雷同，敬请谅解，若有问题欢迎来批

Object 方法

es6 中：

1. 简洁写法的属性名总是字符串，属性名表达式与简洁表示法，不能同时使用；
2. 属性名表达式如果是一个对象，默认情况下会自动将对象转为字符串[object Object],多个对象会默认为是一个key，value会覆盖

       let obj1={naem:"hhh"}
       let obj2= {name:"111"}
       let obj={
           [obj1]:"sss",
           [obj2]:"hhhh"
       }//[object Object]: "hhhh"
   复制代码

3. obj = new Object([value]);

       value 可以是任意的js数据类型（数字、布尔值或字符串）返回本身。
       var obj = new Object(1) //Number{1}  obj==1 // true     obj===1//false
       如果是队形就返回未修改的对象，
       如何是null,undefined,未提供，则创建空对象{}
   
       var p1 = new Person();//js new 出对象；
           //new 实行过程：
           var obj = {};
           obj.__proto__=Person.prototype; //给obj绑定原型上的方法和属性
           Person.call(obj) //改变Person中this的指向，obj可以调用Person构造函数中的实例属性和方法
           return obj 返回obj 给p1变量.
   复制代码

Object Objct 属性

1. proto

       var stringProp = { desc: "description" };
   
       String.__proto__ = stringProp;
       var s1 = "333";
       var s2 = new String("333");
   
       if (console && console.log) {
   
           console.log(String.desc === "description"); // Returns true
           console.log(s1.desc === "description");     // Returns false
           console.log(s2.desc === "description");     // Returns false
   
           s1.__proto__ = String;  // Can't be set. s1使用子面量创建的，所以调用完__proto__临时对象就被销毁，所以设置了无法生效，
           s2.__proto__ = String;
   
           console.log(s1.desc === "description"); // Returns false
           console.log(s2.desc === "description"); // Returns true
       }
   复制代码

2. constructor

       constructor 属性是每个具有原型的对象的原型成员 这包括除 Global 和 Math 对象之外的所有内部 JavaScript 对象
   复制代码

3. prototype 为对象的类返回原型的引用

   所有内部 JavaScript 对象都有一个只读的 prototype 属性。  
   可将属性和方法添加到原型中，但不能为对象分配其他原型。  
   但是，可以向用户定义的对象分配新的原型。  
   
   JavaScript 内置对象的原型不能重新分配其他原型，分配也不生效，可以给原型新增属性和方法
   String.prototype={1};
   String.prototype // String
   复制代码

方法

1. object.hasOwnProperty(proName)

       此方法只是检测独一性本身的属性，不会检测对象原型链中的属性
       var obj={name:"xx"};
       obj.hasOwnProperty("name") //true
   复制代码

2. prototype.isPrototypeOf(object) //检测原型是不是object的原型

       prototype   对象原型
       object 的原型链中具有 prototype，则 isPrototypeOf 方法返回 true
   
       Object.prototype.isPrototypeOf(obj) //true
   复制代码

3. object. propertyIsEnumerable(proName) //对象属性是不是可以枚举

       true时候可以用for枚举
       方法不考虑原型链中的对象。
       var obj={name:"xx"};
       obj.propertyIsEnumerable("name") //true
   复制代码

4. dateObj.toLocaleString()

       dateObj //任意的Date对象
       var d = new Date();
       d.toLocaleString() //"2018/7/26 上午10:52:31"
   复制代码

5. objectname.toString([radix])

       radix 用于数值转换2 8 16 进制
       数组：逗号分隔的字符串
       var x=12;
           x.toString(16);// c
   复制代码

6. object.valueOf( )

       var arr=[1,3,4]
       arr.valueOf() //[1,2,3]
   复制代码

Object Object 的函数

1. Object.assign(target, ...sources )潜拷贝 //将来自一个或多个源对象中的值复制到一个目标对象

   复制可以枚举的属性object. propertyIsEnumerable(proName) 为ture的属性
   
       克隆继承属性
       function clone(origin) {
       let originProto = Object.getPrototypeOf(origin);
       return Object.assign(Object.create(originProto), origin);
       }
   
   复制代码

2. Object.create(prototype, descriptors) //创建具有指定原型并可选择包含指定属性的对象。

       prototype 必需。  要用作原型的对象。  可以为 null。  
       descriptors 可选。  包含一个或多个属性描述符的 JavaScript 对象。  
       返回值： 一个具有指定的内部原型且包含指定的属性（如果有）的新对象。
       var obj1={name："test"}
       var obj=Object.creat(obj1,{
           age:{
               value:12,
               //未指定后三个数据属性，则值默认值为false
               writable:true,//是否可以写
               enumerable:true, //是否可以枚举
               configurable: true
           }
       })
       obj.__propo__===obj1//true
   数据属性：
       【value】表示属性的值，默认为undefined
       【writable】该属性是否为可写，如果直接在对象上定义属性，则默认为true。如果设置为false，则属性仅为可读。
       【configurable】 如果为false的话，则不能修改（writabel,configurable,enumerable），如果直接在对象上定义属性，则默认为true
       【enumerable】是否能够被枚举，如果直接在对象上定义属性，则默认为true。
   访问器属性：
       【get】当对象访问prop属性的实话，会调用这个方法，并返回结果。默认为undefined
       【set】当对象设置该属性的时候，会调用这个方法，默认为undefined。
   异常：
       prototype 参数不是对象且不为 null。
       descriptors 参数中的描述符具有 value 或 writable 特性，并具有 get 或 set 特性。
       descriptors 参数中的描述符具有不为函数的 get 或 set 特性。
   用null创建的对象没有原型
   
   复制代码

3. Object.defineProperties(object, descriptors) 将一个或多个属性添加到对象，并/或修改现有属性的特性。

       返回object
       descriptors 参数是一个包含一个或多个描述符对象的对象。
       //新增属性
       var obj = {};
       Object.defineProperties(obj, {
           newDataProperty: {
               value: 101,
               writable: true,
               enumerable: true,
               configurable: true
           },
           newAccessorProperty: {
               set: function (x) {
                   document.write("in property set accessor" + newLine);
                   this.newaccpropvalue = x;  //注意此处是newaccpropvalue 和 get newaccpropvalue相对应
               },
               get: function () {
                   document.write("in property get accessor" + newLine);
                   return this.newaccpropvalue;
               },
               enumerable: true,
               configurable: true
           }
       });
       obj.newAccessorProperty = 10;
       //此处相当于给obj添加了三个属性： newDataProperty newAccessorProperty newaccpropvalue
       console.log(obj.newDataProperty)//101
       console.log(obj.newAccessorProperty)//10
       console.log(obj.newaccpropvalue)//10
   
       //修改属性
       Object.defineProperties(obj, {
           newDataProperty: { writable: false },//改成只读
           newAccessorProperty: { enumerable: false },//修改可枚举性
           anotherDataProperty: { value: "abc" }
       });
   复制代码

4. Object.defineProperty(object, propertyname, descriptor) //新增修改属性

       Object.defineProperty(obj,prop,descriptor)
           //obj 需要定义属性的对象。
           //prop 需定义或修改的属性的名字。
           //descriptor { } 将被定义或修改的属性的描述符,可设置以下值。
   
               【value】表示属性的值，默认为undefined
               【writable】该属性是否为可写，如果直接在对象上定义属性，则默认为true。如果设置为false，则属性仅为可读。
               【configurable】 如果为false的话，则不能修改（writabel,configurable,enumerable），如果直接在对象上定义属性，则默认为true
               【enumerable】是否能够被枚举，如果直接在对象上定义属性，则默认为true。
               【get】当对象访问prop属性的实话，会调用这个方法，并返回结果。默认为undefined
               【set】当对象设置该属性的时候，会调用这个方法，默认为undefined。
   
           // 返回值 返回传入函数的对象，即第一个参数obj
       var obj = {};
       Object.defineProperty(obj, "newDataProperty", {
           value: 101,
           writable: true,
           enumerable: true,
           configurable: true
       });
   复制代码

5. Object.freeze(object) //阻止修改现有属性，阻止添加属性

   1. 阻止修改验证对象属性

       Object.freeze 函数执行下面的操作：
       
           使对象不可扩展，这样便无法向其添加新属性。
           为对象的所有属性将 configurable 特性设置为 false。在 configurable 为 false 时，无法更改属性的特性且无法删除属性。
           为对象的所有数据属性将 writable 特性设置为 false。当 writable 为 false 时，无法更改数据属性值。
   
       Object.preventExtensions() 不扩展对象， 不能新增，但是可以删除和修改
       Object.seal(person) 密封的对象
   
   
   复制代码

   • 阻止修改对象属性

     函数	对象已设置为不可扩展的	为每个属性将 configurable 设置为 false	为每个属性将 writable 设置为 false
     Object.freeze	是	是	是
     Object.seal	是	是	否
     Object.preventExtensions	是	否	否

   • 检测对象属性的设置，满足下表中标记的所有条件，则以下函数返回 true

     函数	对象是否可扩展	为所有属性将 configurable 设置为 false	为所有数据属性将 writable 设置为 false
     Object.isFrozen	否	是	是
     Object.isSealed	否	是	是
     Object.isExtensible	是	否	否

6. Object.getOwnPropertyDescriptor(object, propertyname) //获取指定对象的自身（非继承）属性描述符

       let obj = { foo: 123 };
       var desc=Object.getOwnPropertyDescriptor(obj, 'foo')
       //  {
       //    value: 123,
       //    writable: true,
       //    enumerable: true,
       //    configurable: true
       //  }
       desc.value=333;
   
       for...in循环：只遍历对象自身的和继承的可枚举的属性。
       Object.keys()：返回对象自身的所有可枚举的属性的键名。
       JSON.stringify()：只串行化对象自身的可枚举的属性。
       Object.assign()： 忽略enumerable为false的属性，只拷贝对象自身的可枚举的属性。
   复制代码

7. Object.getOwnPropertyNames(object)

       返回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名。
   复制代码

8. Object.getOwnPropertySymbols(object);

       Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性的键名。
       var obj = {};
       var key = Symbol('description');
       obj[key] = 'data';
       var symbols = Object.getOwnPropertySymbols(obj);
       console.log(s[0].toString());    //Symbol(description)
   复制代码

9. Object.getPrototypeOf(object) //返回对象的原型。

       1. 先判断object是不是Object,不是就TyopeError
       2. 返回object 的内部属性
   复制代码

10. Object.is() 基本等同于“===” 不同有:

        NaN===NaN//false
        +0===-0 // true
        Object.is(+0,-0)//false
        Object.is(NaN,NaN)//true
        //自己实现
        Object.defineProperty(Object,"is",{
            value:function(a,b){
                if(a===b){
                    return a!==0 ||1/a===1/b
                }
                return a!==a && b!==b
            },
            configurable:true,
            enumerable:fakse,
            writable:true
        })
    
    复制代码

11. Object.setPrototypeOf(obj, proto)//返回是第一个参数

        // 格式
            Object.setPrototypeOf(object, prototype)
    
        // 用法
            const o = Object.setPrototypeOf({}, null);
        //该方法等同于下面的函数。
            function (obj, proto) {
                obj.__proto__ = proto;
                return obj;
            }
    复制代码

12. super关键字：this关键字总是指向函数所在的当前对象，ES6 又新增了另一个类似的关键字super，指向当前对象的原型对象。 super关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。

        const proto = {
        foo: 'hello'
        };
    
        const obj = {
        foo: 'world',
        find() {
            return super.foo;
        }
        };
    
        Object.setPrototypeOf(obj, proto);
        obj.find() // "hello"目前，只有对象方法的简写法可以让 JavaScript 引擎确认，定义的是对象的方法。
    复制代码