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