JavaScript Object方法

配置对象

{
	属性名:{	会成为所创建对象的数据属性
		value:属性值
		configurable 只有该属性描述符的类型可以被改变并且该属性可以从对应对象中删除,默认false。
		writable:true/false 是否可修改,默认为false
		enumerable：true/fasle 是否可以能用 for in等循环枚举，默认为false						
	}
}

Object.create：创建指定的原型对象的对象

var 对象=Object.create(指定对象,{配置对象});

• 指定对象将会作为赋值对象的原型,即对象.proto=指定对象
• 配置对象中的属性将会成为赋值对象的属性

Object.defineProperties、Object.defineProperty：配置对象属性

Object.defineProperties(指定对象,{属性名:{配置对象}})
Object.defineProperty(指定对象,‘属性名’,{配置对象})

• 为指定对象定义扩展多个属性
• get:function(){} 用来获取当前属性值的回调函数,即obj.属性名
  • 不能同时指定get和值或可写属性,设置后因为没有指定value,所以打印出来的对象上没有该属性,但能够访问到
• set:function(外部修改变化的值){} 修改当前属性值触发的回调函数,即obj.属性名=xx;
  • 不能同时指定set和值或可写属性
• this指向指定对象
• 配置对象中定义的属性只能通过get来获取,并且无法被修改

对象本身的set、get方法

var obj={
	xxx
	get 扩展属性名(){return xxx};
	set 扩展属性名(外部修改的值内容){xxx};
}

Object.getPrototypeOf：获取对象的原型类型

Object.getPrototypeOf(对象)

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

var b = 123;
Object.getPrototypeOf(b) === Number.prototype; // true

var c = 'abc';
Object.getPrototypeOf(c) === String.prototype; // true

var d = false;
Object.getPrototypeOf(d) === Boolean.prototype; // true

var e = null;
Object.getPrototypeOf(e); // TypeError: Cannot convert undefined or null to object

var f = undefined;
Object.getPrototypeOf(f); // TypeError: Cannot convert undefined or null to object

var g = Symbol('g');
Object.getPrototypeOf(g) === Symbol.prototype; // true

Object.getPrototypeOf( Object ) === Function.prototype;        // true

Object.getPrototypeOf( Object )是把Object这一构造函数看作对象，
返回的当然是函数对象的原型，也就是 Function.prototype。

正确的方法是，Object.prototype是构造出来的对象的原型。
var obj = new Object();
Object.prototype === Object.getPrototypeOf( obj );              // true

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

Object.seal：密封对象

let obj=Object.seal(obj)

• 密封会让这个对象:
  • 不能添加新属性,但可以改变现有属性的值
  • 一个数据属性不能被重新定义成为访问器属性,或者反之

	Object.defineProperty(obj, 'foo', {
	  get: function() { return 'g'; }
	}); // throws a TypeError

Object.freeze：冻结对象

let obj=Object.freeze(obj)

• 在Object.seal基础上,不能改变现有属性的值

Object.getOwnPropertyNames：获取对象上的属性(键名),不包括继承来的

• Object.getOwnPropertyNames(对象); 返回数组形式

Object.setPrototypeOf：修改指定对象的原型

Object.setPrototypeOf(对象,指向的原型)

• 如果原型参数不是一个对象或者null(例如，数字，字符串，boolean，或者 undefined),则什么都不做,否则,该方法将obj的[[Prototype]]修改为新的值。

获取、转换对象上的键、值的集合

• Object.keys(对象);
• Object.values(对象);
• Object.entries(对象); 返回[[key,value],[key,value],…]
• Object.fromEntries(数组|Map); [[key,value],[key1,value1]] 返回 {key:value,key1:value1}

Object.is:严格判断

Object.is(m,n) 和===类似,不过有两点不同

• 先说===：

  • 如果类型不同,就不相等
  • 如果两个都是数值，并且是同一个值，那么相等；
    • 值得注意的是，如果两个值中至少一个是NaN，那么不相等（判断一个值是否是NaN，可以用isNaN()或Object.is()来判断）。
    • NaN不等于NaN
  • 如果两个都是字符串，每个位置的字符都一样，那么相等；否则不相等。
  • 如果两个值都是同样的Boolean值，那么相等。
  • 如果两个值都引用同一个对象或函数，那么相等，即两个对象的物理地址也必须保持一致；否则不相等。
  • 如果两个值都是null，或者都是undefined，那么相等。

• Object.is()：其行为与===基本一致,不过有两处不同

  • +0不等于-0。
  • NaN等于自身。

Object.prototype.toString.call

判断对象类型

• 必须使用call，否则会因为Object内部调用,使得一直判断为[Object Object]

const a =1;
Object.prototype.toString(a)		[Object Object]
Object.prototype.toString.call(a)   [Object Number]

• 不能直接对象.toString():

因为对于Array对象,重写了toString方法,使得不会返回类型
const a=[1];
Object.prototype.toString.call(a);	[Object Array]
a.toString();	"1"

Object.isExtensible:检测对象是否可扩展

即是否可以添加新的属性,以及 __proto__是否可以被修改

	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.getOwnPropertyDescriptors：获取所有属性的描述符对象

for (const name of Object.keys(descriptors)) {
	const descriptor = descriptors[name]; // 拿到属性的属性描述符对象
	if (descriptor.get) {
		// ...
	} else if (typeof descriptor.value === "object") {
		// ...
	}
}

Object.getOwnPropertySymbols：获取对象所有的 Symbols 属性key

const object1 = {};
const a = Symbol('a');
const b = Symbol.for('b');

object1[a] = 'localSymbol';
object1[b] = 'globalSymbol';

const objectSymbols = Object.getOwnPropertySymbols(object1);

console.log(objectSymbols); // [Symbol(a), Symbol(b)]
console.log(object1[objectSymbols[0]]) // "localSymbol"