Object方法讲解
概述:Object是所有类的父类,他的方法和属性所有对象都可以使用
原型方法和属性
hasOwnProperty(判断当前对象是否具备这个属性 不会读取原型上的属性)
//原型方法是对象实例使用的 由于Object是顶层父类 所有的对象都可以调用他的原型方法
let obj = {
name: 'jack'
}
function Person(name, age) {
this.name = name
this.age = age
}
Person.prototype.sex = '男'
let person = new Person('tom', 18)
Person.address = '湖南长沙'
//判断当前对象是否具备该属性 obj.hasOwnProperty() 不会读取原型上的属性 直接赋值可以读到
console.log(person.hasOwnProperty('sex'));
console.log(person.hasOwnProperty('address'));
isPrototypeOf(判断当前对象是否处在传入对象的原型链上)
function Person(){
}
function Son() {
Person.call(this)
}
let person1 = new Person('tom', 18)
Son.prototype = person1
function Child() {
Son.call(this)
}
let son = new Son()
Child.prototype = son //在原型上添加son
let child = new Child()
console.log(person1.isPrototypeOf(son));
console.log(son.isPrototypeOf(child));
console.log(person1.isPrototypeOf(child));
__defineGetter 定义获取的方法 (废弃)
defineSetter 定义设置的方法 (废弃)
lookupGetter 返回定义的获取方法 **(废弃)
lookupSetter 返回定义的设置方法 **(**废弃)
let obj1 = {
name: 'tom',
age: 18
}
let model = {
name: 'tom',
age: 18
}
obj1.__defineGetter__('name', function() {
console.log('触发了');
return model.name
})
obj1.__defineSetter__('name', function(v) {
console.log('触发了');
model.name = v
})
console.log(obj1.name);
obj1.name = '你好'
console.log(obj1.name);
//propertyIsEnumerable 可以迭代的类型
console.log(obj1.propertyIsEnumerable('name'));
//根据本地格式转为字符串
console.log(obj1.toLocaleString());
//转为字符串
console.log(obj1.toString());
//valueof 提取对应的value值
console.log(obj1.valueOf(name));
- propertylsEnumerable 判断当前属性是否可以枚举(可以遍历)
- toLocalString 根据本地格式转为字符串
- toString 转为字符串
- valueOf提取对应的value值
//propertyIsEnumerable 传入一个属性 判断这个属性的Enumerable属性的结果是什么
//Enumerable 可枚举 可以进行遍历
console.log(obj.propertyIsEnumerable('name'));
//转字符串
console.log(obj.toLocaleString()); //本地格式
console.log(obj.toString());
//valueOf 返回对应的值
console.log(obj.valueOf());
原型属性
contructor 指向当前对象的构造函数
__proto__对象的隐式原型
静态方法(Object.方法调用的)
Object.is判断两个对象是否一个对象
object.is(NaN,NaN)
assign 将后面的对象拷贝到第一个对象中(浅拷贝(第一层只拷贝值 第二层拷贝的都是地址))
它返回的是目标对象的地址 如果给了一个空数组去接收拷贝的值 能拷贝到但是值 地址并不相同
let obj = {
arr: [1, 2, 3]
}
//将后面对象的内容拷贝到前面这个对象里面返回前面这个对象
let obj1 = Object.assign(obj, {
name: 'jack'
}, {
age: 18
})
console.log(obj);
console.log(obj1);
console.log(obj1 == obj); //true
//对应的浅拷贝完成 (浅拷贝只拷贝第一层的值 第二层拷贝的都是地址)
let copyObj = Object.assign({}, obj)
console.log(copyObj);
console.log(copyObj == obj); //false
create 根据传入的内容创建相关的对象
这个传入的内容会在创建的对象的原型链上面 ,但是两个不是同一个对象
//create方法
function Person(name) {
this.name = name
}
let person = new Person('tom')
//根据传入对象创建相关的对象 但是这个对象跟传入的对象不是一个对象
//它会将创建对象的原型指向传入对象
let createObj = Object.create(person)
console.log(createObj);
console.log(person == createObj);//false
console.log(person.isPrototypeOf(createObj));//true
- keys 将可枚举的key全部加入到一个迭代器返回
- values 将他的value全部加入到一个迭代器返回
- entires 将他的键值队全部加入到一个迭代器返回
//keys values entries
let obj2 = {
name: 'jack',
age: 18,
sex: '男'
}
console.log(Object.keys(obj2));//['name', 'age', 'sex']
console.log(Object.values(obj2));//['jack', 18, '男']
console.log(Object.entries(obj2));//[Array(2), Array(2), Array(2)]
- getPrototypeOf获取原型
- setPrototypeOf 设置原型
//setPrototypeOf 设置原型
function Child(name) {
this.name = name
}
let child = new Child('tom')
let proto = {
address: '北京',
city: "河北石家庄"
}
Object.setPrototypeOf(child, proto)
console.log(child); //Child {name: 'tom'}
//getPrototypeOf 获取原型
let protoObj = Object.getPrototypeOf(child)
console.log(protoObj); //{address: '北京', city: '河北石家庄'}
freeze 冻结(只能查询) isFrozen 是否冻结
seal 密封 (只能查询和修改 不能删除和添加新的属性)i sSealed **是否密封
preventExtensions 不可扩展 (不能添加新的属性) isExtensible 是否可扩展
let obj = {
name: 'jack',
age: 18,
sex: '男'
}
//冻结 (只要冻结就会密封 密封必定不可拓展)
Object.freeze(obj) //冻结当前的obj对象,只能查询
// Object.seal(obj) //密封,能查询和修改
obj.age = 20
console.log(obj.name);
delete obj.sex
obj.address = '长沙'
for (key in obj) {
console.log(key);
}
console.log(obj);
// Object.preventExtensions() //不可以扩展(不能添加新的属性)
console.log(Object.isFrozen(obj)); //是否冻结
console.log(Object.isSealed(obj)) //是否密封
console.log(Object.isExtensible(obj)) //是否可拓展
freeze>seal>preventExtensions(冻结必定密封 密封必定不可扩展)
- getOwnPropertyNames 获取所有的属性名(除symbol的keys以外)
- getOwnPropertySymbols 获取所有symbol为键的属性名
- getOwnPropertyDescriptor 获取对应属性的详情(属性对象)
- getOwnPropertyDescriptors 获取所有属性的详情(对象)
let symbol = Symbol()
let obj = {
name: 'jack',
age: 18,
}
obj[symbol] = '你好'
//获取所有的属性名 传入的是一个对象 返回的是一个字符串数组(除了symbol)
let names = Object.getOwnPropertyNames(obj)
console.log(names);
//获取所有的symbol修饰的属性(获取所有的symbol为键的属性) 返回symbol数组
let symbols = Object.getOwnPropertySymbols(obj)
console.log(symbols);
//Descriptor 获取属性详情 返回是一个属相对象
let desc = Object.getOwnPropertyDescriptor(obj, 'name')
console.log(desc);
//获取所有的属性(返回所有的属性详情 返回的是一个对象 每个对象的key是键名 值为属性对象)
let desc1 = Object.getOwnPropertyDescriptors(obj)
console.log(desc1);
属性对象(不定义的话默认为false)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qjt4WGlf-1667641310451)(C:\Users\ThankPad\AppData\Roaming\Typora\typora-user-images\1667638366237.png)]
defineProperty 定义单个属性
let obj = {
name: 'jack'
}
Object.defineProperty(obj, 'age', {
configurable: true, //是否可以删除
enumerable: false, //是否可枚举 是否可以被遍历
value: 18,
writable: true //是否可以修改
})
console.log(obj);
//for in 只能遍历可枚举的属性
for (key in obj) {
console.log(key);
}
obj.age = 30
console.log(obj);
defineProperties定义多个属性
let obj1 = {}
let model1 = {}
Object.defineProperties(obj1, { //返回本身的话会一直调用函数
username: {
configurable: true,
enumerable: true,
get() {
console.log(model1.name);
return model1.username
},
set(v) {
model1.username = v
}
},
password: {
configurable: true,
enumerable: true,
get() {
return model1.password
},
set(v) {
model1.password = v
}
}
})
obj1.username = '张三'
obj1.password = '123456'
console.log(obj1);
console.log(model1);
面试题
for in 和 Object,keys和Object.getOwnPropertyNames的区别
for in 包含继承的属性以及自身的属性(不包含不可枚举的属性)
Object.keys 只包含自身的属性(不包含继承的和不可枚举的属性)
Object.getOwnProertyNames只包含自身的属性(不包含继承的 包含不可枚举的)
obj1.username = ‘张三’
obj1.password = ‘123456’
console.log(obj1);
console.log(model1);
### 面试题
#### for in 和 Object,keys和Object.getOwnPropertyNames的区别
for in 包含继承的属性以及自身的属性(不包含不可枚举的属性)
Object.keys 只包含自身的属性(不包含继承的和不可枚举的属性)
Object.getOwnProertyNames只包含自身的属性(不包含继承的 包含不可枚举的)
三个内容都不包含symbol属性