ES6新特性

一、循环、数组、对象的回顾

1、冻结对象：Object.freeze(obj)

​ （1）遍历对象的属性：for…in

​ for(let k in obj){ }

2、构造函数：

​ （1）作用：初始化对象（是对象的模型），所有的对象都是用这个模型造出来的

​ （2）this：指向由构造函数创建的对象（代表当前对象）

​ （3）对象：是属性和行为的结合体

​ 属性：是对象的静态特征（成员变量）

<script>
        /*需求：定义构造函数Student,属性分别是：id、name、html、css、JavaScript
             (1)创建5个Student对象,把这5个对象存入数组
             (2)找出总成绩最高的对象
             (3)根据javascript成绩对数组进行降序排序
        */
       //1.定义构造函数
        function Student(id,name,html,css,javascript){
            //1.1 定义属性：this后的是属性
            this.id = id
            this.name = name
            this.html = html
            this.css = css
            this.javascript = javascript
            //1.2 定义方法：求对象的总成绩
            this.total = function(){
                return this.html + this.css + this.javascript
            }
        }
        //2.创建对象，然后将对象存入数组
        let s1 = new Student(101,'贾宝玉',78,85,95)
        let s2 = new Student(102,'贾元春',65,88,98) 
        let s3 = new Student(103,'贾探春',75,65,88)
        let s4 = new Student(104,'贾迎春',90,80,92)
        let s5 = new Student(105,'贾惜春',72,78,86)
        let arr = [s1,s2,s3,s4,s5] //arr数组称为对象数组
        console.log(arr)
        //3. 找总成绩最高的
        let max = arr[0]  //假定数组中第一个对象的总成绩最高
        for(let i=1;i<arr.length;i++){
            if(arr[i].total() > max.total()){
                max = arr[i]
            }
        }
        console.log("总成绩最高的是：",max)
        //4.按JavaScript的成绩进行降序排序
        for(let i=0;i<arr.length;i++){
            for(let j=0;j<arr.length-1;j++){
                if(arr[j].javascript < arr[j+1].javascript){
                    let t = arr[j]
                    arr[j] = arr[j+1]
                    arr[j+1] = t
                }
            }
        }
        console.log(arr)
    </script>

<script>
        /* 需求：统计给定字符串中有多少种字符？每个字符的个数是多少？
           采用对象进行处理
               (1)将字符串中的字符作为对象的属性
               (2)若对象中有这个属性(字符)，让属性值加1，若没有这个属性(字符)，则将该字符作为对象的属性加入，让属性值为1
        */
       let str = 'skjfsjfadsfjlksadsaadascbdsfasdfs'
       let obj = {}
        /*访问对象属性的方法：
            (1)对象名.属性名
            (2)对象名['属性名']
        */
       for(let i=0;i<str.length;i++){
        if(obj[str[i]]){ //表示对象obj有str[i]这个属性，对应的属性值加
            obj[str[i]] ++ 
        }else{
            obj[str[i]] = 1
        }
       }
       console.log(obj)
    </script>

二、DOS的基本命令

1、DOS：Disk Operating System，磁盘操作系统

​ MS-DOS、PC-DOS、UC-DOS

2、操作系统：

​ （1）单用户单任务的操作系统：DOS

​ （2）单用户多任务的操作系统：windows系列

​ （3）多用户多任务的操作系统：unix

3、基本概念

​ （1）目录：就是window中的文件夹

​ （2）. ：代表当前目录（当前文件夹）

​ （3）.. ：代表当前目录的上一级目录（父目录）

​ （4）根目录：盘符所在的目录

4、基本指令

​ （1）目录转换：从一个目录转换到另一个目录（从一个文件夹进入到另一个文件夹）

​ cd 目录名 —>进入到指定的目录中

​ cd .. —>返回当前目录的上一级目录（父目录）

​ cd \ —>表示退回到根目录（\ 代表根目录）

​ （2）列举当前目录下的子目录和文件：

​ dir —-> 在名称前带

的是目录，不带

的是文件

​ dir /p ：分屏显示（子目录和文件）

​ dir /w ：宽屏显示（用[]括起来的都是目录）

​ （3）创建目录（新建文件夹）

​ md 目录名

​ （4）删除目录（删除文件夹）

​ rd 目录名

三、ES6的新特性

1、临时死区：用let和const声明的变量，放在‘临时死区’，使用let声明的变量、const声明的常量的作用域不会被提升

2、在循环中使用var的情况：

 ```javascript

let arr = []
for(var i=0;i<5;i++){ //var定义的i是全局的，若将var改为let,则输出0 1 2 3 4
arr.push(function(){ //arr是一个函数数组：数组的每个单元都是函数
console.log(i)
})
}

  arr.forEach(function(item){ //item是函数：输出5个5
        item()
    })
 ```

3、解构赋值：Rest运算符：”…”

​ （1）当迭代器使用：会按顺序遍历容器中的元素

function fun(x,y,z){
            console.log(x,y,z)
        }
        let arr = [11,22,33]
        fun(...arr) //'...'运算符的作用是一个迭代器：依次遍历数组中的元素

 （2）替代函数的内置属性arguments

function fun(...args){
            console.log(args)
        }
        let arr = [11,22,33]
        fun(arr)

3）通过解构赋值可以简化变量的赋值

let arr = [11,22,33]
let [a,b,c] = arr
console.log(a)

（4）通过”…”把特定的元素放在变量里

let [a,...arr] = [11,22,33]  //将11赋给a,将22,33赋给arr,arr就是一个数组
console.log(a)
console.log(arr)

 （5）通过解构来交换变量的值

let a = 10
let b = 20; //必须要以分号结尾
[a,b] = [b,a]
console.log(a,b)

4、对象的解构

​ （1）将对象的属性解构出来赋给变量

let obj = {
            id:1001,
            userName:'关羽',
            sex:'男'
        }
        let { id,userName,sex } = obj  //变量名必须和对象的属性名相同
        console.log('编号：',id)
        console.log('用户名：',userName)
        console.log('性别：',sex)

（2）解构多层对象

let obj = {
            id:1001,
            userName:'关羽',
            sex:'男',
            score:{
                html: 98,
                css:95,
                js: 85
            }
        }
        let { id,userName,sex,score:{html,css,js} } = obj  //变量名必须和对象的属性名相同
        console.log('编号：',id)
        console.log('用户名：',userName)
        console.log('性别：',sex)
        console.log('css的成绩：',css)

（3）在解构时可以给变量取别名

let obj = {
            id:1001,
            userName:'关羽',
            sex:'男',
            score:{
                html: 98,
                css:95,
                js: 85
            }
        }
        let { id:userId,userName:name } = obj  //userId是id的别名,name是userName的别名
        console.log('编号：',userId)
        console.log('用户名：',name)
        console.log('性别：',sex)

接

6、Symbol类型

​ （1）ES5的数据类型：number、string、boolean、bigint、null、undefined、object

​ （2）ES6新增的Symbol：表示一个唯一的值

​ a、直接创建：let 变量名 = Symbol

​ b、间接创建：传字符串 let 变量名 = Symbol（字符串)

7、Set集合：是一种数据结构，里面不能存放重复的值。可以用于数组去重、字符串去重

​ （1）创建方式：

​ a、使用new运算符：let 变量 = new Set()

​ b、通过数组来创建：let 变量名 = new Set( [1,2,3,5,6] ) ,去除重复的元素

let s1 = new Set() //创建一个空集合
        console.log(s1)
        let arr = [1,2,3,2,0,3,5]
        let s2 = new Set(arr)
        console.log(s2)

（2）常用的方法：

​ a、add(val)：向集合中添加元素

​ b、delete(val)：删除集合中的元素。删除成功返回true，删除失败返回false

​ c、has(val)：判断val在集合中是否存在，若存在返回true，不存在返回false

​ d、clear()：清空集合，没有返回中

​ e、values()：获取的是集合中所有value

​ f、keys()：获取集合中的key

强调：Set集合也是key-value格式，它的key和value是相同的

​ （3）属性：size 存放的是集合中元素的个数

​ （4）遍历方法：

​ a、for … of

for(let i of s1.keys()){
        console.log(i)
    }

 b、forEach

s1.forEach(function(value,key){
        console.log(value+'  ----  '+key)
    })

（5）集合运算

​ a、并集：

let setA = new Set([4,5,6])
let setB = new Set([5,6,7])
let bj = new Set([...setA,...setB])
console.log(bj)

​ b、交集：

let arr = [...setA]  //解构集合setA，将其转换成数组  
       //对arr进行过滤：使用filter函数
       //依次从arr中取出元素传递给item,在函数体内设置筛选条件，将满足条件的元素返回给temp
       let temp = arr.filter(function(item){
           if(setB.has(item)){ 
              return item
           }
       })
    console.log(temp)

​ c、差集

let arr = [...setA]  //解构集合setA，将其转换成数组  
       //对arr进行过滤：使用filter函数
       //依次从arr中取出元素传递给item,在函数体内设置筛选条件，将满足条件的元素返回给temp
       let temp = arr.filter(function(item){
           if(setB.has(item)==false){ 
              return item
           }
       })
    console.log(temp)

问题1：创建Set集合时为什么用new运算符？

​ （1）Set是一个构造函数，凡是用构造函数创建对象时都要用new

问题2：Set构造方法的参数为什么是数组或null？

8、WeakSet集合：只是一个对象集合。即集合中只能存放对象。它支持 add，has 和 delete 方法

课堂练习：创建构造函数Student，它的属性有id、name、html、CSS、js。

​ （1）利用该构造函数创建5对象，并将这5个对象存放到Set集合中

​ （2）把css成绩不及格的对象挑选出来

<script>
      function Student(id,name,html,css,js){
            this.id =id;
            this.name=name;
            this.html=html;
            this.css=css;
            this.js=js;
        }

        let a = new Student(1,"张三",70,45,70)
        let b = new Student(2,"李四",80,25,40)
        let c = new Student(3,"王五",30,95,90)
        let d = new Student(4,"赵六",100,85,67)
        let e = new Student(5,"雷七",78,38,72)
        let arr = [a,b,c,d,e]
        let set = new Set([])
        for(let i = 0;i<arr.length;i++){
            set.add(arr[i]) 
        }
        console.log(set)

        let t =[...set].filter(function(item){
            if(item.css<60){
                return item
            }
        })
        console.log(t)

    </script>