Object.defineProperty():
在对象上直接定义个新的属性,或者修改现有的属性,并返回此对象;
/**
* Object.defineProperty()
* @param 第一个参数为对象 obj
* @param 第二个参数为属性 name
* @param 第三个参数为数据属性
* @return 目标对象
*/
let obj = {}
Object.defineProperty(obj,'d',{
value: 4
})
Object.assign():
将所有可枚举属性从一个或多个源对象分配到目标对象,并返回目标对象。可用于对象浅拷贝;
/**
* Object.assign()
* @param target:目标对象
* @param source:源对象
* @return 目标对象
*/
const obj = {username:'张三',age:30}
const obj2= {city:'河北保定'}
const user = Object.assign(obj,obj2)
Object.create():
创建一个新对象,使用现有的对象来提供新创建对象的原型。
/**
* Object.create()
* @param proto:新创建对象的原型对象
* @param [propertiesObject]:可选,对象的属性的描述
* @return 一个新对象,带着指定的原型对象和属性
*/
let obj = {
name:'张三',
print:function(){
console.log(`我是${this.name}`)
}
}
let user = Object.create(obj);
console.log(user);
console.log(user.__proto__);
console.log(user.name);
Object.is()
判断两个值是否为同一个值,它与==或===两个运算符都不一样,Object.is()不会强制转换两边的值,并且===运算符将数字-0和+0视为相等,而Object.is()则不是,它更加严格。
/**
* Object.is()
* @param val:被比较的第一个值
* @param val2:被比较的第二个值
* @return 一个布尔类型标识两个参数是否是同一个值
*/
console.log(Object.is(undefined,undefined)) ==>true
console.log(Object.is(+0,-0)) ==>false
console.log(Object.is(NaN,NaN))==>true
Object.getPrototypeOf()
获取实例的隐式原型(proto)的指向
/**
* Object.getPrototypeOf()
* @param obj:要实例对象
*/
function Person(username){
this.username = username;
}
var p = new Person('张三');
console.log(Object.getPrototypeOf(p))
Object.setPrototypeOf()
设置一个指定的对象的原型(即内部[[Prototype]]属性到另一个对象或null。
/**
* Object.setPrototypeOf()
* @param obj:要设置其原型的对象
* @param prototype:该对象的新原型(一个对象或null)
*/
var obj1={name:'name1'}
var obj2={name2:'name2'}
Object.setPrototypeOf(obj1,obj2)
console.log(obj1)
console.log(obj1.name2)
Object.keys():
返回一个由一个给定对象的自身可枚举属性组成的数组,这些属性的顺序与手动遍历该对象属性时一致;
/**
* Object.keys()
* @param obj:要返回其枚举自身属性的对象
* @return 一个表示给定对象的所有可枚举属性的字符串数组
*/
let obj = {
name:'张三',
print:function(){
console.log(`我是${this.name}`)
}
}
console.log(Object.keys(obj));
Object.values():
返回一个给定对象自身的所有可枚举属性值的数组;
/**
* Object.values()
* @param obj:被返回可枚举属性值的对象
* @return 一个包含对象自身的所有可枚举属性值的数组
*/
let obj = {
name:'张三',
print:function(){
console.log(`我是${this.name}`)
}
}
console.log(Object.values(obj));
Object.entries():
返回一个给定对象自身可枚举属性的键值对数组;
/**
* Object.entries()
* @param obj:可以返回其可枚举属性的键值对的对象
* @return 给定对象自身可枚举属性的键值对数组
*/
let obj = {
name:'张三',
print:function(){
console.log(`我是${this.name}`)
}
}
console.log(Object.entries(obj));
Object.prototype.toString()
返回一个表示该对象的字符串;
/** * Object.prototype.toString() * @return 一个表示该对象的字符串 */
call
改变对象的this指向,使之指向两一个对象。
/***
* call:改变对象的this指向,使之指向两一个对象
* @param obj : 要传入的对象
* @param 参数以逗号分隔开输入
*/
function Anmial(){
console.log(this)
}
function Cat(){
}
var obj = {}
Anmial.call();
Anmial.call(null);
Anmial.call(undefined);
Anmial.call(1);
Anmial.call('');
Anmial.call(true);
Anmial.call(Cat);
Anmial.call(obj);
apply
改变对象的this指向,使之指向两一个对象。
/***
* apply:改变对象的this指向,使之指向两一个对象
* @param obj : 当前对象
* @param 参数以数组方式输入
*/
function Anmial(){
console.log(this)
}
function Cat(){
}
var obj = {}
Anmial.apply();
Anmial.apply(null);
Anmial.apply(undefined);
Anmial.apply(1);
Anmial.apply('');
Anmial.apply(true);
Anmial.apply(Cat);
Anmial.apply(obj);
call和apply区别:
接受参数方式不同,apply接受两个参数,第一个参数为this,第二个参数为参数列表;
function Anmial(name){
this.name = name;
this.getName = function(){
return this.name;
}
}
function Cat(name){
Anmial.call(this,name);
//Anmial.apply(this,[name])
}
var cat = new Cat('小猫');
console.log(cat.getName())
for/in
使用for/in
遍历对象属性
const obj = {
name: "张三",
age: 10
};
for (let key in obj) {
console.log(key, obj[key]);
}
for/of
for/of
用于遍历迭代对象,不能直接操作对象。可以通过Object
对象的keys()返回的是迭代对象。
const obj = {
name: "张三",
age: 10
};
for (const key of Object.keys(obj)) {
console.log(key);
}
获取所有对象属性
const obj = {
name: "张三",
age: 10
};
for (const key of Object.values(obj)) {
console.log(key);
}