对象常用的方法
思维导图
对象中常用的方法： Object.prototype
1. hasOwnProperty
- 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。 检测是否为私有属性
- 即使属性的值是
null或undefined，只要属性存在，hasOwnProperty依旧会返回true。检测的属性的 String 字符串形式表示的名称，或者 Symbol。
const object1 = {};
object1.property1 = 42;
console.log(object1.hasOwnProperty('property1'));
// expected output: true
console.log(object1.hasOwnProperty('toString'));
// expected output: false
console.log(object1.hasOwnProperty('hasOwnProperty'));
// expected output: false
2. toString
-
检测数据类型的 Object.prototype.toString.call([value])
var toString = Object.prototype.toString;
toString.call(new Date); // [object Date]
toString.call(new String); // [object String]
toString.call(Math); // [object Math]不常用
- + isPrototypeOf 方法用于测试一个对象是否存在于另一个对象的原型链上。
- + valueOf方法返回指定对象的原始值。
- + propertyIsEnumerable方法返回一个布尔值，表示指定的属性是否可枚举
把Object作为一个普通对象，学习其静态私有属性方法 -> Object.xxx()
- **跟规则没关系的方法==3==个：**
1. Object.assign(obj1,obj2,...)
合并两个(或多个)对象,让obj2及以后的对象替换obj1中的内容,返回obj1
//Object.assign(obj1,obj2,...) 合并两个(或多个)对象,让obj2及以后的对象替换obj1中的内容,返回obj1
const obj1 = { a: 1, b: 2 };
const obj2 = { b: 4, c: 5 };
const newObject = Object.assign(obj1, obj2);
console.log(obj1);
//{a: 1, b: 4, c: 5}
console.log(newObject);
//{a: 1, b: 4, c: 5}
//newObject===obj1//true2.Object.create(obj)
创建一个空对象，并且把obj作为其原型对象 返回值:一个新对象，带着指定的原型对象和属性。
let obj = { name: "lisa" }
let obj2 = Object.create(obj)
console.log(obj2);
实现继承--------------------
// Shape - 父类(superclass)
function Shape() {
this.x = 0;
this.y = 0;
}
Shape.prototype.move = function (x, y) {
this.x += x;
this.y += y;
console.info('Shape moved.');
};
// Rectangle - 子类(subclass)
function Rectangle() {
Shape.call(this); // call super constructor.
}
// 子类续承父类
let son = Rectangle.prototype = Object.create(Shape.prototype);
let son2 = Rectangle.prototype.constructor = Rectangle;
console.log(son);
console.log(son2);3.Object.is(value1,value2)`
基于三个等于号，绝对相等进行比较的【ES6新增】
let obj = Object.is(NaN, NaN)
console.log(obj);//true 这里可以判断一个值是不是NaN，做的也是全等比较对象中属性操作的方法
1.`Object.defineProperty(obj,key,descriptor)`
:==对当前对象中的某个属性进行监听或劫持，以及设置一些规则==
let obj = {
name: 'lisa'
};
let proxy = { ...obj };
Object.defineProperty(obj, 'name', {
get() {
// 当我们获取obj的name属性值的时候，会触发GETTER函数，方法返回的值就是获取的属性值
console.log('GETTER');
return proxy.name;
},
set(value) {
// 当我们设置name属性值的时候，会触发SETTER函数，value是需要新设置的值
console.log('SETTER', value);
proxy.name = value;
}
});
console.log(obj.name);
obj.name = 'red';
- 2. `configurale:true`:是否可以基于delete删除name属性
- 3. `enumerable:true`:是否是可枚举的name属性，如果不可枚举，则for/in/Object.key()等操作无法遍历到该属性
- 4. ` writable:true`:是否可以修改值【只要设置了该描述，不管true或false，都不能使用get/set方法】
- 5. `get(){return xxx}`:对获取obj.name属性操作进行拦截，return的值，就是真正获取到的值
- 6. set(value){xxx}`:对设置obj.name=value操作进行拦截，并执行函数体内的操作
-
`7. Object.getOwnPropertyDescriptor(obj,key)`:获取obj中key属性所设置的规则的状态(可删除/枚举/修改..)
-
8.Object.getOwnPropertyDescriptors(obj)`:获取obj中每一个属性所设置的规则的状态
let obj = { name: 'lisa', age: 13 };
Object.defineProperty(obj, 'name', {
// 是否可以基于delete删除
configurable: false,
// 是否是可以枚举的，如果是不可枚举的属性，则基于for/in循环或者Object.keys等操作都无法获取这个属性
enumerable: false,
// 是否可以修改值「不能和get/set同时设置」
// writable: true,
get() { },
set() { }
}); 获取当前对象不同类型的键或值==5==个：
1.`Object.getOwnPropertyNames(obj)`:获取当前对象所有非Symbol类型的私有属性【含不可枚举的】
let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
Object.defineProperty(obj, 'name', { enumerable: false });
let keys = Object.getOwnPropertyNames(obj);
console.log(keys); //['name', 'age',] 2.`Object.getOwnPropertySymbols(obj)`:获取当前对象所有**Symbol**类型的私有属性【含不可枚举的】
let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
Object.defineProperty(obj, obj[Symbol('AA')], { enumerable: false });
let keys = Object.getOwnPropertySymbols(obj);
console.log(keys); //[Symbol(AA)3.`Object.keys(obj)`:获取当前对象所有非Symbol类型且可枚举的私有属性名【不能获取不可枚举的】
let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
Object.defineProperty(obj, "name", { enumerable: false });
let keys = Object.keys(obj);
console.log(keys); //['age']
4.Object.values(obj)`:获取当前对象所有非Symbol类型且可枚举的私有属性值
let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
Object.defineProperty(obj, "name", { enumerable: false });
let keys = Object.values(obj)
console.log(keys); //['13']5. Reflect.ownKeys获取所有私有属性【包含各种类型及可枚举和不可枚举的】
let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
Object.defineProperty(obj, "name", { enumerable: false });
let keys = Reflect.ownKeys(obj)
console.log(keys); //['name', 'age', Symbol(AA)]冻结：
- 不让其设置defineProperty劫持
- `Object.freeze(obj)`:冻结，把一个对象进行冻结，目的是让其不能在再基于Object.defineProperty做劫持，
- 后续可以基于`Object.isFrozen(obj):`检测对象是否是冻结的
let obj = { name: 'lisa', age: 13 };
Object.freeze(obj)
Object.defineProperty(obj, 'name', {
get() { },
set() { }
});
//Uncaught TypeError: Cannot redefine property: name无法重新定义属性：name
console.log(Object.isFrozen(obj));//true 检测对象是否是冻结的设置和获取原型：
- - Object.getPrototypeOf(obj)`:获取`obj.__proto__`指向的原型
- - `Object.setPropertyOf(obj,property)`:设置obj原型对象`obj.__proto__===prototype`
let obj = { name: 'lisa', age: 13 };
let property = { name: 'red', age: 28 };
Object.getPrototypeOf(obj)//constructor: ƒ Object()
Object.setPrototypeOf(obj, property)//{name: 'lisa', age: 13}**阻止扩展*：不能再为其设置新的属性
- - `Object.preventExtensions(obj)`:把obj变为不可扩展对象
- - `Object.isExtensible(obj)`:判断一个对象是不是可扩展对象
let obj = { name: 'lisa', age: 13 };
Object.preventExtensions(obj);
obj.sex = "男"
console.log(obj);//{name: 'lisa', age: 13,}
console.log(Object.isExtensible(obj));//false不可扩展**封存：**
- 不允许添加或删除对象中的属性,但允许修改对象中存在的属性
- `Object.seal(obj)`:封存对象，不允许添加或删除对象中的属性,但允许修改对象中存在的属性
- - `Object.isSealed(obj)`:判断一个对象是否封存了。
let obj = { name: 'lisa', age: 13 };
Object.seal(obj);
obj.sex = "男";
console.log(obj); //{ name: 'lisa', age: 13 }
obj.age = 28;
console.log(obj);//{name: 'lisa', age: 28}
Object.isSealed(obj)//true 不允许添加或删除对象中的属性,但允许修改对象中存在的属性- **对象的属性与二维数组互相转换：*
- `Object.entries(obj):`将对象中的每个==可枚举的==键值对转为数组，返回一个二维数组
- - `Object.fromEntries(arr)`:将二维数组的各数据项，转换为对象，返回一个对象
let obj = { name: 'lisa', age: 13 };
let arr = Object.entries(obj)
console.log(arr);//[Array(2) Array(2)]对象中的每个可枚举的键值对,转为数组返回一个二维数组