JavaScript Object 对象-数据类型 ​

Object.create(prototype, [descriptors])

var newObj=Object.create(obj,{
  sex:{// 键名
    value:"男",// 键值，默认 undefined
    writable:true,// 是否可以被修改。默认 false
    configurable:true,// 是否可以被删除。默认 false
    enumerable:true,// 是否支持可枚举(for in 访问)。默认值是 false
  }
});

Object.defineProperty(obj, [propName], descriptor)

var obj = {sex1:''};

Object.defineProperties(obj,{
  sex:{
    // 也可以有 Object.create() 的配置
    set(value){// 赋值时调用
      this.sex1=value;
    },
    get(){// 获取值时调用
      return this.sex1;
    }
  }
})

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
});

Object.assign(target, ...sources)

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const returned = Object.assign(target, source);

console.log(target); // Object { a: 1, b: 4, c: 5 }
console.log(returned); // Object { a: 1, b: 4, c: 5 }

var user ={
 name:"tom",
 age:25
}

var keys = Object.keys(user)// ['name','age'] 返回键的数组，参数可以是原型对象

// 只遍历键
for (let key of Object.keys(obj)){
  console.log(key);
}

var user ={
 name:"tom",
 age:25
}
var keys = Object.values(user) // ["tom", 25]

// 只遍历值

for(let item of Object.values(obj)){
  console.log(item);
}

for(let [key,item] of Object.entries(obj)){
  console.log(item,key);
}

Object.getOwnPropertyNames(Person.prototype) // ["constructor", "name", "job", "sayName"] 返回键的数

Object.getOwnPropertySymbols(obj)
// 参数：要返回 Symbol 属性的对象。
// 返回值：对象自身上找到的所有 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); // 2
console.log(objectSymbols)     // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0])   // Symbol(a)

Object.getOwnPropertyDescriptors({a:1})
/* {
  a:{
    configurable: true
    enumerable: true
    value: 1
    writable: true
  }
} */

Object.is(value1, value2);
// 比较两个值是否相等，与 == 和 === 不一样。返回 true/false

Object.is('foo', 'foo'); // true
Object.is(window, window); // true
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.getPrototypeOf(object) // 返回参数的原型对象，没有继承属性则返回 null
Object.getPrototypeOf( Object ); // ƒ () { [native code] }
Object.getPrototypeOf( Function ); // ƒ () { [native code] }
Object.getPrototypeOf( Object ) === Function.prototype; // true

var obj = new Object();
Object.prototype === Object.getPrototypeOf( obj ); // true
Object.prototype === Object.getPrototypeOf( {} ); // true

Object.freeze(obj); // 返回被冻结的对象; 返回传递的对象，不是创建一个被冻结的副本
// 冻结一个对象，冻结后不能添加删除，包括配置，可枚举，可写性等;也包括原型上的属性

Object.seal(obj); // 返回被封闭的对象的引用
// 阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。
// 不会影响从原型链上继承的属性。但 __proto__ 属性的值也会不能修改。

const obj = {};
obj.prop = 42;
console.log(obj.hasOwnProperty('prop')); // true
console.log(obj.hasOwnProperty('toString')); // false