1.对象API拓展
is
判断两个值是否相等 is(+0,-0);false is(NaN,NaN) true (NaN === NaN) false
// 1.is 判断两个值是否相等
console.log(Object.is(1,1));
console.log(Object.is(+0,-0));//返回false
console.log(+0 === -0);
console.log(Object.is(NaN,NaN));
console.log(NaN === NaN);
assign
1.两个参数 对象得复制
Object.assign(o,obj);将第二个参数得内容复制给第一个参数返回第一个参数
针对于基本数据类型实现的是深拷贝 针对于引用数据类型实现得是浅拷贝
obj = {
name:"",
age:12,
clazz:{
no:'1001'
}
}
2.三个参数 对象合并
Object.assign(o,obj,obj1);将后面两个对象合并到o对象中 返回o对象
// 2.assign方法 两个参数 代表的是复制对象 三个参数代表的是合并对象
/*** 两个参数 assign(目标对象,要复制的对象) 返回值返回也是目标对象* */
let o = {};
let obj = {name:'zhangsan',age:12,//对基本数据类型实现深拷贝 (对引用数据类型实现浅拷贝--半深拷贝)clazz:{no:'2023'}
}
let res = Object.assign(o,obj);//将obj对象复制给o对象 同时返回o对象
console.log(res,res===o,res===obj);
o.clazz.no = '2024';
console.log(o,obj);/*** 三个参数：合并对象 (o,obj1,obj2) 将后面对象进行合并合并到第一个对象中 返回第一个对象* */
let o = {name:'zhangsan'};
let obj = {age:12};
let obj1 = {gender:'male'};
let res = Object.assign(o,obj,obj1);//返回第一个参数
console.log(res,res===o);
getPropertypeOf
(目标对象) 获取原型对象
let obj = {name:"zhangsan",age:12
}
// 获取原型对象 getPrototypeOf
console.log(obj.__proto__);
console.log(obj.constructor.prototype);
console.log(Object.getPrototypeOf(obj));setPropertypeOf
(obj,新原型对象) 设置原型对象
/*** 设置原型对象 setPropertypeOf*/
let obj = {};
let obj1 = {name:'zhangsan',age:12};
Object.setPrototypeOf(obj,obj1);//将obj原型对象设置为obj1
console.log(obj.__proto__)
console.log(obj.constructor.prototype);//注意 获取不到新原型对象
console.log(Object.getPrototypeOf(obj));keys
获取对象属性名组成数组
values
获取对象属性值组成数组
entries
获取对象属性名和属性值组成数组
fromEntries
将属性名和属性值组成数组转为对象
let obj = {name:'zhangsan',age:12,gender:'male'
}
console.log(Object.keys(obj));//获取obj属性名组成数组
console.log(Object.values(obj));//获取obj属性值组成数组
console.log(Object.entries(obj));//获取obj属性名和属性值组成二维数组
console.log(Object.fromEntries(Object.entries(obj)));//将对象属性名和属性值组成二维数组转为对象2.数组API拓展
静态方法：
Array.from 将类数组转为数组
Array.of 创建数组实例
实例方法：
find 查找数组元素 参数:回调函数(item,index,arr) 返回值：返回符合条件得第一个数组元素或者undefined
findIndex 查找数组元素 参数:回调函数(item,index,arr) 返回值：返回符合条件得第一个数组元素索引或者-1
includes 检测数组元素是否存在数组中 存在返回true 不存在返回false NaN 返回true
flat 展开数组层级 扁平化数组 参数：n 或者 Infinity
fill 填充数组 修改原数组
flatMap flat和map结合
keys 返回得都是迭代器对象
values 返回得都是迭代器对象
entries 返回得都是迭代器对象
/*** 静态方法拓展 from of* 实例方法拓展 find findIndex flat keys values entries ....*/
// 1.将类数组对象转为数组对象 from
function foo(){console.log(arguments,'类数组对象');console.log(Array.from(arguments));console.log([...arguments]);console.log(Array.prototype.slice.call(arguments,0))
}
foo(1,2,3,4)// 2.of 创建数组实例
let arr1 = new Array(10);
let arr = Array.of(10);
console.log(arr,arr1,arr instanceof Array);// 3.find 返回第一个满足条件得数组元素或者undefined 参数:回调函数
let arr = [1,2,3,4,5];
let res = arr.find(function(item,index,arr){return item>3
});
console.log(res);// 4.findIndex 返回第一个满足条件得数组元素索引或者-1 参数：回调函数
let arr = [1,2,3,4,5];
let res = arr.findIndex((item,index,arr)=>{console.log(item,index,arr);return item>5
});
console.log(res,arr);// includes 检测数组元素是否存在数组中 存在返回true 不存在返回false
let arr = [1,2,3,4,('hello'/2)];
console.log(arr.includes('2'));//针对于NaN优化
console.log(arr.includes(('hello'/2)));
console.log(arr.indexOf(('hello'/2)));// fill 填充数组 修改原数组
let arr = [1,2,3,4];
let res = arr.fill(8);
console.log(arr,res);/*** keys values entries 返回得是实现了迭代器接口对象 iterator */
let arr = [1,2,3,4,5];
console.log(arr.keys());
console.log(arr.values());
console.log(arr.entries());// flat方法 扁平化数组 数组层级展开
let arr = [1,2,[3,4,5,[6,7,8,[9,10,[11]]]]];
console.log(arr.flat(1));
console.log(arr.flat(Infinity));// flatMap flat和map方法结合 需求 将数组展开 每个数组元素*2
let arr = [1,2,[3,4]];
let res = arr.flatMap((item,index,arr)=>{// console.log(item,index,arr)if(typeof item=='number'){return item * 2}else{return item.map((it)=>{return it*2})}
})
console.log(res);3.类
构造函数另一种写法 创建对象模板 通过class创建类
/*** 类看成构造函数得另一种写法 使用class关键字创建类 创建对象模板*/
class Person{// 类体默认会提供一个空的构造器 constructor(name,age,gender){/*** new关键字作用:* 1.创建Person类实例对象* 2.将this指向Person类实例对象* 3.执行函数体* 4.返回Person类得实例对象*/// 实例私有属性和私有方法this.name = name;this.age = age;this.gender =gender;this.say = function(){console.log(this,'查看this');}}// 写在类体中的方法就是实例公共方法 ---类似于写在原型对象中 Person.prototypesayName(){console.log(this.name)}
}
let p1 = new Person('zhangsan',12,'male');
let p2 = new Person();
console.log(p1);
p1.sayName();
console.log(p1.sayName === p2.sayName,'写在类体中 实例公共方法');
console.log(p1.say === p2.say,'实例私有方法--写在构造器中');
console.log(p1.constructor);
实例公共方法 相当于写在Person.prototype
sayName(){
}
class Person{// 使用static关键字声明类得方法和属性 静态方法和静态属性 只能由类本身访问static PersonAttr = 'Person静态属性';static PersonMethod = function(p){console.log('Person静态方法');return p instanceof Person}// 默认提供一个空的构造器 constructor(){}
}
let p1 = new Person();
// console.log(p1.PersonAttr);
// console.log(p1.PersonMethod(p1));
console.log(Person.PersonAttr,'静态属性');
console.log(Person.PersonMethod(p1),'静态方法'); 写在类体中属性也是私有属性
test = 'hello';
firends = [];
静态属性 只能由类本身去调用属性 Person.xxx = '' Person.method = function(){}
static attr = '静态属性'
static method = '静态方法'
class Person {constructor(name, age, gender) {// 写在构造器中属性和方法是实例私有属性和方法this.name = name;this.age = age;this.gender = gender;// this.test = xxx// this.friends=xxx}// 写在类体中得方法是实例公共方法 相当于写在Person原型对象中sayName() {console.log(this.name)}// 写在类体中得属性是是实例私有属性test = 'hello';friends = [];static attr = 'Person类静态属性';static method = function(){console.log('Person类静态方法');}
}
let p1 = new Person('terry',18,'male');
let p2 = new Person('larry',20,'female');
p1.sayName();//terry
p2.sayName();//larry
console.log(p1.sayName === p2.sayName);//true
p1.friends.push('tom');
console.log(p1.friends === p2.friends);//false
p1.test='我被修改了';
console.log(p1.test === p2.test);//false
)
函数)
