javascript 对象api

 // Object 构造函数的属性:
 Object.prototype//可以为所有 Object 类型的对象添加属性

 class A extends B{
     constructor(){
         super();
     }
 }

 // Object 构造函数的方法:

 //Object.assign(目标对象, 要复制的对象)//通过复制一个或多个对象来创建一个新的对象
 //方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
 //不会拷贝目标对象的继承对象(不会拷贝prototype属性)
 //返回 目标对象

 //Object.create()
 //使用指定的原型对象和属性创建一个新对象
 //Object.create()方法会继承指定的原型对象的属性和方法去创建一个新的对象。
 //该方法接收两个参数，其中第一个参数是这个新创建的对象的原型，
 //第二个是可选参数，与Object.definePropertperties()方法的第二个参数格式相同。

 //defineProperty(要在其上定义属性的对象, 要定义或修改的属性的名称, 将被定义或修改的属性描述符);
 {
 //方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象!
 //属性描述符:描述符必须是这两种形式之一；不能同时是两者
 //数据描述符()/存储描述符(存取描述符)(作用于 get set 的描述符)
 //                         configurable    enumerable    value    writable    get    set

 //数据描述符:                Yes                Yes        Yes       Yes        No     No

 //存储描述符:                Yes                Yes        No        No         Yes    Yes

 //数据描述符 默认值:
     //value : 1,
     //writable : true,
     //configurable : true,
     //enumerable : true

 //存储描述符 默认值:
     //value : 1,
     //writable : false,
     //configurable : false,
     //enumerable : false
 // 例:
 class MyName{
     constructor(){
         //super();
         this.name = 'n';
     }
 }
 let myname = new MyName();

 Object.defineProperty(myname, 'name', {
     configurable:false,//false不可被配置,删除, 但可以配置 writable和value，默认值为true
     enumerable:false,//flase为不能被递归，默认值为true
     writable:false,//flase属性的值为:不可写,只读，默认值为true
     value:'lizi' //修改对象属性的默认值（数值，对象，函数等）
 });

 //例 修改prototype属性
 function myclass() {
 }
 var value;
 Object.defineProperty(myclass.prototype, "x", {
   get() {
     return value;
   },
   set(x) {
     value = x;
   }
 });

 var a = new myclass();
 var b = new myclass();
 a.x = 1;
 console.log(a.x);//
 console.log(b.x); //

 //例 自存档 日志 1
 function Archiver() {
   var temperature = null;
   var archive = [];

   Object.defineProperty(this, 'temperature', {
     get: function() {
       console.log('get!');
       return temperature;
     },
     set: function(value) {
       temperature = value;
       archive.push({ val: temperature });
     }
   });

   this.getArchive = function() { return archive; };
 }

 var arc = new Archiver();
 arc.temperature; // 'get!'
 arc.temperature = 11;
 arc.temperature = 13;
 arc.getArchive(); // [{ val: 11 }, { val: 13 }]

 //例 自存档 日志 2
 var pattern = {
     get: function () {
         return 'I alway return this string,whatever you have assigned';
     },
     set: function () {
         this.myname = 'this is my name string';
     }
 };

 function TestDefineSetAndGet() {
     Object.defineProperty(this, 'myproperty', pattern);
 }

 var instance = new TestDefineSetAndGet();
 instance.myproperty = 'test';

 // 'I alway return this string,whatever you have assigned'
 console.log(instance.myproperty);
 // 'this is my name string'
 console.log(instance.myname);//继承属性
 }

 //defineProperties(obj, 将被定义或修改的属性描述符)(在其上定义或修改属性的对象, );
 {
 //多条修改(给对象添加多个属性并分别指定它们的配置)
 //例:要定义其可枚举属性或修改的属性描述符的对象
 var obj = {};
 Object.defineProperties(obj, {
   'property1': {
     value: true,
     writable: true
   },
   'property2': {
     value: 'Hello',
     writable: false
   }
 });
 }

 //Object.entries(obj);//返回给定对象自身可枚举属性的 [key, value] 数组
 {
 //for in 区别:Object.entries 不会枚举原型链上的属性
 //例1
 const obj = { foo: 'bar', baz: 42 };
 console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

 //例2
 for (let [key, value] of Object.entries(obj)) {
   console.log(`${key}: ${value}`);
 }
 //Object.values()//返回给定对象自身可枚举值的数组
 //Object.keys()//返回一个包含所有给定对象自身可枚举属性名称的数组
 }

 //Object.freeze(obj);//冻结目标对象 其他代码不能删除 或 更改任何属性
 {
 //Object.isFrozen(obj)//判断对象是否已经冻结
 //冻结的对象:
 //Object.freeze(obj)//作用于构造函数
 //Object.freeze(obj.prototype)//作用于目标原型链
 //不能添加属性;
 //不能删除属性
 //不能修改属性;
 //不能重定义属性;
 //返回和传入的参数相同的对象
 //例
 let obj = {
   prop: 42,
   config:{}
 };
 Object.freeze(obj);
 obj.prop = 33;
 console.log(obj.prop);//
 obj.config.a = 1;
 console.log(obj.config.a);//
 }

 //Object.seal(obj)//防止其他代码删除对象的属性, 封闭一个对象(但属性的值仍然可以修改)
 {
 //Object.isSealed(obj);//判断是否是一个封闭对象
 //密封的对象:
 //不能添加新属性，
 //不可配置属性。
 //不能成为访问器属性
 //不可删除，
 //不能被重新定义
 //不会影响从原型链上继承的属性。但 __proto__ (  ) 属性的值也会不能修改。
 //返回被密封对象的引用。
 //例
 var obj = {
   prop: function() {},
   foo: 'bar'
 };
 var o = Object.seal(obj);
 o === obj; // true
 Object.isSealed(obj); //true
 }

 //Object.preventExtensions(obj)//防止对象的任何扩展
 {
 //对象变得不能扩展,也就是永远不能再添加新的属性
 //仅阻止添加自身的属性。但属性仍然可以添加到对象原型

 //Object.isExtensible(obj) //判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）
 //默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__ 属性可以被更改。
 //Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）
 //例
 // 新对象默认是可扩展的.
 var empty = {};
 Object.isExtensible(empty); // === true
 // ...可以变的不可扩展.
 Object.preventExtensions(empty);
 Object.isExtensible(empty); // === false
 // 密封对象是不可扩展的.
 var sealed = Object.seal({});
 Object.isExtensible(sealed); // === false
 // 冻结对象也是不可扩展.
 var frozen = Object.freeze({});
 Object.isExtensible(frozen); // === false
 }

 //Object.getOwnPropertyDescriptor(需要查找的目标对象, 目标对象内属性名称); //返回属性特性配置
 {
 //方法返回指定对象上一个自有属性对应的属性描述符(自有属性:对象自身属性,不包括原型链, 属性描述符:属性配置)
 //如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined
 //例
 obj = { get foo() { return 17; } };
 d = Object.getOwnPropertyDescriptor(obj, "foo");
 // d {
 //   configurable: true,
 //   enumerable: true,
 //   get: /*the getter function*/,
 //   set: undefined
 // }

 //Object.getOwnPropertyNames(obj)//方法返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。
 //例
 var arr = ["a", "b", "c"];
 console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]
 }

 //Object.getOwnPropertySymbols(obj) 方法返回一个给定对象自身的所有 Symbol 属性的数组
 {
 //例
 var obj = {};
 var a = Symbol("a");
 var b = Symbol.for("b");
 obj[a] = "localSymbol";
 obj[b] = "globalSymbol";
 var objectSymbols = Object.getOwnPropertySymbols(obj);

 console.log(objectSymbols.length); //
 console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
 console.log(objectSymbols[0])      // Symbol(a)
 }

 //Object.getPrototypeOf(obj) 方法返回指定对象的原型（内部[[Prototype]]属性的值）
 {
 //例
 const prototype1 = {};
 const object1 = Object.create(prototype1);
 console.log(Object.getPrototypeOf(object1) === prototype1);// expected output: true
 }

 //Object.is(value1, value2);//方法判断两个值是否是相同的值
 {
 //和传统的 == 运算不同，== 运算符会对它两边的操作数做隐式类型转换, Object.is 不会做这种类型转换
 //这与 === 运算符的判定方式也不一样。=== 运算符（和== 运算符）将数字值 -0 和 +0 视为相等，并认为 Number.NaN 不等于 NaN
 //例
 Object.is('foo', 'foo');     // true
 Object.is(window, window);   // true
 Object.is('foo', 'bar');     // false
 Object.is([], []);           // false
 var foo = { a: 1 };
 var bar = { a: 1 };
 Object.is(foo, foo);         // true
 Object.is(foo, bar);         // false
 Object.is(null, null);       // true
 // 特例
 Object.is(0, -0);            // false
 Object.is(0, +0);            // true
 Object.is(-0, -0);           // true
 Object.is(NaN, 0/0);         // true
 }

 //Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或  null
 // 该方法运行较慢,影响性能,不赞成使用

 //get set :(给属性加把锁!)
 {
 // --------------------------------------------------------------------------例1
 /* let myname = {
     name : 'n',
     age : undefined,
     fun : function (){console.log(this);},
     get name(){
         console.log('this get');
         return name;
     },
     set name(v){
         console.log('this set');
         name = v;
     }
 }; */

 // -------------------------------------------------------------------------- 例2
 /* function MyName(){
     let name = 'n';//this.name === name;
     let age = 1;
     Object.defineProperty(this, 'age', {
         get:function (){
             console.log('this get');
             return age;
         },
         set:function (v){
             console.log('this set');
             age = v;
         }

     });
     Object.defineProperties(this, {
         name:{
             get : function (){
                 console.log('this get');
                 return name;
             },
             set : function (v){
                 console.log('this set');
                 name = v;
             }
         }
     });
 }
 let myname = new MyName(); */

 // -------------------------------------------------------------------------- 例3
 /* class MyName{
     constructor(){
         //super();
         this.config = {name:'n'};
         //this.name;
         //this.color = 'red';
     }

     get name() {
         console.log('this get');
         return this.config.name;
     }

     set name(v) {
         if(v){
             console.log('this set');
             this.config.name = v;
         }
     }

 }
 let myname = new MyName(); */
 }

 //Object 实例和 Object 原型对象
 //继承:

 //属性:

 //Object.prototype.constructor
 //返回创建实例对象的 Object 构造函数的引用。
 //注意，此属性的值是对函数本身的引用，而不是一个包含函数名称的字符串。对原始类型来说，如1，true和"test"，该值只可读
 //例
 var o = {};
 o.constructor === Object; // true

 var o = new Object;
 o.constructor === Object; // true

 var a = [];
 a.constructor === Array; // true

 var a = new Array;
 a.constructor === Array // true

 var n = new Number(3);
 n.constructor === Number; // true

 //方法:
 Object.prototype.isPrototypeOf()//返回一个布尔值，表示指定的对象是否在本对象的原型链中
 object.prototype.hasOwnProperty(property)//返回一个布尔值 ，表示某个对象是否含有指定的属性，而且此属性非原型链继承的
 Function.prototype.apply()//在一个对象的上下文中应用另一个对象的方法；参数能够以数组形式传入
 Function.prototype.call()//在一个对象的上下文中应用另一个对象的方法；参数能够以列表形式传入