Promise、Set、Map数据类型，类的创建和使用、类的继承，

Promise

 

resolve 代表成功

reject 代表失败

 

 

catch 用于捕获异常

猜数器

Set数据不重复

可解决数组去重

常用方法

将Set集合转换为数组 Array.from(Set);

// 创建一个set集合
console.log("---------创建一个set集合---------");
let s_1 = new Set([1, 2, 3, 4, 21, 2]);
console.log(s_1); //输出  [ 1, 2, 3, 4, 21 ]  会自动去重
​
// 获取set集合的长度   size
console.log("---------获取set的长度----------");
let s_2 = new Set([1, 2, 3, 4, 21, 2]);
console.log(s_2.size); //输出 5   获取长度
​
// 向集合中添加元素 add()
console.log("---------向集合中添加元素---------");
let s_3 = new Set([1, 2, 3, 4, 21, 2]);
s_3.add(7).add(12);
console.log(s_3); //输出  [ 1, 2, 3, 4, 21, 7, 12 ]  两个新增
​
// 将集合转换为Array  Array.from()
console.log("---------将集合转换为数组类型---------");
let s_4 = new Set([1, 2, 3, 4, 21, 2]);
let arr = Array.from(s_4);
console.log(s_4);
console.log(arr);
​
// 数组转换为Set集合
console.log("---------数组转换为Set集合---------");
let arr1 = [1, 2, 3, 4, 21, 2];
console.log(arr1); //输出 Array(6) [ 1, 2, 3, 4, 21, 2 ]
let s_8 = new Set(arr1);
console.log(s_8); //输出 Set(5) [ 1, 2, 3, 4, 21 ]
​
// 删除集合中的元素 has()   返回布尔值
console.log("---------查询Set集合中是否有某个元素---------");
let s_6 = new Set([1, 2, 3, 4, 21, 2]);
console.log(s_6.has(2)); //有这个值 返回true
console.log(s_6.has(11)); //没有这个值 返回false
​
// 删除集合中的元素 delete()    返回布尔值
console.log("---------删除集合中的某一个元素---------");
let s_5 = new Set([1, 2, 3, 4, 21, 2]);
console.log(s_5.delete(2)); //有这个值 删除成功 返回true
console.log(s_5.delete(11)); //没有这个值 删除失败 返回false
console.log(s_5); //输出  Set(4) [ 1, 3, 4, 21 ]
//可结合has()方法进行删除    更加银性化
//先查询集合中有没有该数据
if(s_5.has(1)){
    s_5.delete(1)
    alert("删除成功")
}else{
    alert("该条数据不存在")
}
​
// 清空集合
console.log("---------清空集合---------");
let s_7 = new Set([1, 2, 3, 4, 21, 2]);
console.log(s_7); //清空前  Set(5) [ 1, 2, 3, 4, 21 ]
s_7.clear()
console.log(s_7); //清空后  Set() []

Set的遍历 迭代

let s_1 = new Set([1, 2, 3, 45, 6, 8]);
// 第一种遍历方法 s_1.keys()    返回键名
console.log("---第一种遍历方法 s_1.keys() 返回键名---");
for (const item of s_1.keys()) {
    console.log(item);
}
​
// 第二种遍历方法 s_1.values()  返回键值
console.log("---第二种遍历方法 s_1.values() 返回键值---");
for (const item of s_1.values()) {
    console.log(item);
}
​
// 第三种遍历方法 s_1.entries() 返回键值对
//因为entries()方法 便利的同时包括键名和键值 所以会输出每个数组 并且两个而值相等 
console.log("---第三种遍历方法 s_1.entries() 返回键值对---");
for (const item of s_1.entries()) {
    console.log(item);
}

forEach()遍历

arr.forEach((val,key)=>{
    console.log(key +":"+val)
})

Map键值对

// 创建一个map结构
let m_1 = new Map();
// 向字典中添加元素
console.log("---向字典中添加元素---");
m_1.set('张三', '139红酒白酒葡萄酒');
m_1.set('李四', '1383838438');
m_1.set('王五', '84811491');
console.log(m_1); //Map(3) { "张三" → "139红酒白酒葡萄酒", "李四" → "1383838438", "王五" → "84811491" }
​
// 通过size获取长度
console.log("---通过size获取长度---");
console.log(m_1.size) //3
​
// 通过键值对查找特定的值并返回
console.log("---通过键值对查找特定的值并返回---");
console.log(m_1.get('李四')) //1383838438
​
// 查找是否有该键
console.log("---查找是否有该键---");
console.log(m_1.has('王五')); //true
console.log(m_1.has('赵六')); //false
​
//通过键值从字典中移除对应元素
console.log("---通过键值从字典中移除对应元素---");
console.log(m_1.delete("李四")); //true
console.log(m_1); //Map { "张三" → "139红酒白酒葡萄酒", "王五" → "84811491" }
​
//清除Map结构
console.log("---清除Map结构---");
m_1.clear()
console.log(m_1); //Map(0)

Map的遍历迭代

let m_1 = new Map();
m_1.set("张三", "123123")
m_1.set("李四", "524352")
m_1.set("王五", "254235")
// 第一种遍历方法 s_1.keys()    返回键名
console.log("---第一种遍历方法 s_1.keys() 返回键名---");
for (const item of m_1.keys()) {
    console.log(item);
}
​
// 第二种遍历方法 s_1.values()  返回键值
console.log("---第二种遍历方法 s_1.values() 返回键值---");
for (const item of m_1.values()) {
    console.log(item);
}
​
// 第三种遍历方法 s_1.entries() 返回键值对
//因为entries()方法 便利的同时包括键名和键值 所以会输出每个数组 并且两个而值相等 
console.log("---第三种遍历方法 s_1.entries() 返回键值对---");
for (const item of m_1.entries()) {
    console.log(item);
}

相互转换

Set： 数据不可重复

Map：键值对

Array：数据可重复

//转换为数组
arr1 = Array.from(map_1);
arr2 = Array.from(set_1)

 

class类

语法格式：

class 类名（首字母大写）{

}

/**
* 类是一个宏观概念 而对象是具体的某一个
* **/
// 创建类 首字母大写
class Person {
    // 构造函数实现初始化   固定格式 constructor
    constructor(name, sex, age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    work() {
        console.log("工作");
    }
    sayHello() {
        console.log(`你好，我叫${this.name}，性别${this.sex}，年龄${this.age}`);
    }
    getName() {
        return this.name
    }
    //使用static修饰的函数 表示该函数属于Person类本身 而不属于对象本身
    //只能通过类名来调用 Person.fun()，不能被实例对象调用 
    static fun(){
        console.log("静态函数")
    }
}
// 实例化一个人
let p1 = new Person("张三", "男", 20)
console.log(p1);    //Object { name: "张三", sex: "男", age: 20 }
p1.work()   //工作
p1.sayHello()   //你好，我叫张三，性别男，年龄20
var name = p1.getName()
console.log(name);  //张三

继承 extends

//继承  Student 为子类 Person为父类；
//当子类继承父类后，子类就可以访问父类中的属性、函数
//实例化对象的时候，构造函数中的参数的个数一定要完整
class Student extends Person{}
let stu_1 = new Student("李四","男",19)
​
//继承之后 再写构造函数之前 需要先访问父级的构造函数
class Student extends Person{
    constructor(name,sex,age,stuId){
        super(name,sex,age);    //必须先调用super函数
        this.stuId = stuId
    }
    //当父类和子类中有相同名称的函数时，调用子类中的函数相当于子类将父类的重名函数进行了重写
    //多态 函数重载
    sayHello(){
        super.sayHello()    //可以通过super调用父类中的函数
        console.log(`子类中：大家好，我叫${this.name}`)
    }
    sayHello(n){
        console.log(`大家好，我叫${this.name}，${n}`)
    }
}
let stu_2 = new Student("李四","男",19)
sayHello(10)

super