kkb33_ES6和var的写法一样但是本身更加严谨相当于强化了作用域概念 ES6把作用域明显了以{}为作用域作为

当发现逻辑不断重复调用用递归并且需要不确定嵌套关系时在考虑嵌套

要是同级用的是循环
JavaScript三大组成部分
- BOM
- DOM
- ECMAScript 6.0标准包括js中的数据类型以及相关操作，流程控制，运算符及相关运算
  
  ES6是他的新版本
let和const
- let
  - var是声明变量的功能如果不声明也可以赋值成功
  - 和var的写法一样但是本身更加严谨相当于强化了作用域概念 ES6把作用域明显了以{}为作用域作为划分方式。
  - 只要在{}存在的地方就是有let作用域的地方其实要比var更好一些，因为作用域强
  - let不能重复声明可以重复赋值更合理更加严谨的功能
  - var本身会有一个预解析而let没有预解析不能在声明之前调用
  - let 在if和for中也受限制在if语句中设置限制变量声明局部变量只要有{}就有作用域限制
  - ```
  for(let i=0;i<3;i++){
      setTimeout(function(){
          console.log(i);
      });
  };
  //打印结果是012
  //如果用的var 打印结果是333
  //也就是说不用属性储存了
```
let和var的差异
- let允许声明一个在作用域限制在块级中的变量，语句或者表达式块级作用域----{}
  - var声明的变量只能是全局或者整个函数块的
  - let不能重复声明可以说是修复原来语言的一个漏洞
  - let不会被预解析新特性
const常量常量就是不会改变的量
- 实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址所保存的数据不得改动，对简单类型的数据（数值，字符串，布尔值），值就保存在变量指向的那个内存地址，因此等同于常量，但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指向实际数据的指针（即总指向另一个固定的地址），至于它指向的数据结构是不是可变的，就不能完全控制了，因此，将一个对象声明为常量必须非常小心。
  - 常量不能重新赋值 - 的值必须在声明的时候定义
  - 不能重复声明
  - 块级作用域
  - const不会被预解析
  - 一般用在版本的管理定义一些控件或者标准的时候很多的值是不允许轻易改动一般从项目上的整体的维护去使用

解构赋值其实是简化复杂的数据结构可以更方便的让我们获取复杂结构中更深层的数据的

对象的解构赋值

//如果想从一个复杂的数据结构中的一个深处的数据 就可以把它解构出来
        let obj = {
            a:12,
            b:5,
            c:{
                d:{
                    e:123
                }
            }
        }
        // console.log(obj.a)
        // console.log(obj.c.d.e)
        //把a b 变成了一个直接的变量
        let {b,a,c} = obj;
        let {d} =c; 
        let {e} =d;
        console.log(c);
        console.log(d);
        console.log(e);

数组的解构赋值

    // 数组解构赋值 必须和索引相对应
    let arr = ['a','文字','c'];
  
    // console.log(arr[1])
  
    let [c,b,a] = arr;
  
    console.log(c)

字符串的解构赋值

    let str = 'string';
  
    let [a,b,c] = str;
  
    console.log(a,b,c)

将一个dom节点的列表转换成为一个真正的数组

如果不是一个真正的数组是无法调用数组方法的可以更多的功能
- ```
var arr3 = Array.from(lis);  //方法一
```
- ```
var arr3 = [...lis]; //用展开符来转换
```
当后台数据完整之后发到前端之后再进行处理整体显示具体实现思路嵌套关系，相同结构的嵌套，不断地嵌套在自己的结构之内通过他是否有自己数据来判断是否需要添加 li
ES是ECEMC的简称 ECscirpt是脚本语言的规范平时使用的
ECMAScript6是js语法的新版本也是ES2015 不同名但是一个标准
let和const的使用和区别一个变量一个是常量的声明 let是一个基于块级作用域来做声明的方式 var是没有作用域概念的 ES5的之前的是在基于函数作为作用域划分标准的但凡看到花括号就能知道let的作用范围区别是 let不能重复声明其实本身来讲一个变量只需要生成一次只是需要重复更改值就可以了但是这个不能声明第二次不能被预解析

展开运算符 ...

一般情况下是用作数组的解析的

是为了帮助我们将数组和对象放到另外一个数组当中还有一个是将伪数组转化成真数组的作用

可以复制也可以合并对象

    let obj = {
        a:12,
        b:5
    }
  
    let obj3 ={
        c:666,
        d:888
    }
  
    let obj2 = {...obj,...obj3};

var arr = [1, 2, 3];
  
var arr2 = [4, 5, 6];
  
var arr3 = [...arr, ...arr2];
  
console.log(arr3);

set对象新的对象集合是为了解决数据重复问题 new Set() 还有一些方法

    let arr = [1,2,3,4,5,6,5,3,6]
    // 去重
    let setA = new Set(arr);
    // 长度
    console.log(setA.size)
    // 添加
    setA.add(8)
    // 删除
    setA.delete(3)
    // 验证是否存在
    let bool = setA.has(9)
    // 清空
    setA.clear();
    console.log(bool)
    console.log(arr.setA);

map是新增的数据类型本身就是一个数据结构是键值对的表现形式但是他的连接方式是等号加上括号的方式去连接的也有些方法

  let arr = [
      ["a", 12],
      ["b", 5]
  ];
  let mapA = new Map(arr);
  // 长度
  console.log(mapA.size)
  // 添加
  mapA.set("c", 888);
  // 删除
  mapA.delete("a")
  // 获取
  let b = mapA.get('b');
  //是否包含属性  
  let bool = mapA.has('f')
  // 清除
  mapA.clear();
  console.log(bool);
  console.log(b);
  console.log(mapA);

箭头函数
- 不能预解析声明方式是 let fn = () =>{} 区别是在于不写function
- 只有一行代码并且有返回值的时候是可以省略不写{}的不需要写 return 写了会报错
- 箭头函数中的arguments是不能使用的（被ES6抛弃了这个属性）要是需要获取不定参的话需要用（位置个数的实参）展开运算符来获取除了形参之外的所有参数，返回的是一个真数组列表可以用数组操作他。
在箭头函数中this是当前块级作用域下的对象跟声明位置有关系在哪个块级作用域中声明就是哪个函数
- 默认参数值声明方式是在形参后面直接等于具体的值这样的话调用的时候不传参就有默认的值可以更加灵活的对参数做一个设定
数组方法
- var arr2 = Array.from(arr);
  - 复制数组新的独立的数组即不是引用
  - 还有一种使用方法是将伪数组转换成真实数组以便调用数组方法
    
    document.querySelectorAll(); 获取的是一个dom的一个节点列表不能用数组方法进行操作
- var arr2 = Array.of(1,2,3,4);
  
  var arr2 = Array.of(1,2,3,4);这个结果是一个二维数组里面也只有一个数组项
  - var arr3 = Array.of(arr);出来的结果是一个数组里面包含一个数组原因是里面传递的是每个数组的单项（具体值）声明一个新数组但是参数每一个具体的值放进一个整体的数组
  - 暂时本身使用频率不高（相比较上一个方法而言）
  - 例子
    - 当数组声明的时候不确定每一项是什么的时候可以将不确定的值放进去但是可以用别的方法
- var item= arr.find(function(item){
  
  return s>4})
  - 用来查找并返回符合条件的第一个值
  - var index= arr.findIndex(function(item){
    
    return item>2})
    - 用来查找并返回符合条件第一个值的下标
  - var bool= arr.includes(3) 只能传一个参数值多个值不会报错但是无法识别
    - 用来查找数组中是否含有某个值并返回一个布尔值
- var arr = [
  
  [1,2],[3,4],[5,6],
  
  [
  
  [7,8],[9,0]
  
  ]
  
  ];
  
  var arr2 = arr.flat();
  - 解构赋值不仅可以解构数组，还可以结构对象
  - flat将数组扁平化传的参数决定了可以扁平化的层数 arr.flat(2);
  - 如果不想受到层数限制需要取出全部数据则传入Infinity
- var arr3 = arr.flatMap((item)=>{
  
  console.log(item);
  
  item2 = item.filter((item)=>item>3);
  
  return item2;
  
  }); 返回的是被过滤之后的数组
  - 遍历二维数组
字符串方法
- 模板字符串和普通字符串的区别
  - 支持换行支持变量（ ${}的形式可以调用函数$ {fn()} ）可以理解为只要在花括号里面的环境就是js里的语法环境
- var arr = '123456789';
  
  var bool = str.includes('123');
  - 查找字符串有的话返回true 没有返回false
- var bool2 = str.startsWith('1',1);(匹配字符，匹配下标)
  - 判定字符串是以哪个字符开头的;
- var bool3 = str.endsWith('7',6);(匹配字符，匹配下标)
  - 判定字符串是以哪个字符结束的;
- var str = '.'.repeat(100);
  - 输出结果是一百个点
对象扩展
- 对象扩展
```
var obj = {a:12,b:5,fn:function(){alert(this.a)}};
let a= 666;
let b= 888;
let obj2 = {
a,b,
    //函数简写
    fn(){
        alert(this.b)
    }
}
console.log(obj2.a)//666
obj2.fn();//执行函数888
```
```
属性名表达式
let n = 'c';
var obj = {
a:12,
[n]:5,
    fn:function(){
    	alert(this.a)		
    }
}
console.log(obj.n)//5 没加括号
console.log(obj.a)//5 加括号
```
- 除了用点点点来合并两个对象的属性还可以用
  - let obj3 = Object.assign({},obj, obj2); 组合对象，将对象合并成一个
    - 但是他里面的参数表示的是(新对象，)也就是说以第一个为主将后面的所有对象的属性加给新对象
- var bool = Object.is(n1,n2); 基本相当于’===‘
  - 判断连个对象是否一致返回一个布尔值 NaN可以相等
  - 可以判断数字 0 ，-0不相等不能判断两个符号相反的数字
顶层对象
- 在浏览器中指的是window对象，在Node指的是global对象
- 在ES中，顶层对象的属性与全局变量是等价的
  - 这在JavaScript语言中最大的设计败笔之一
  - ```
  window.a = 1;
  a // 1
  
  a = 2;
  window.a // 2
```
- 首先是没法在编译时就报出变量未声明的错误，只有运行的时候才能知道（因为全局变量可能是顶层对象的属性创造的，而属性的创造是动态的）；其次，程序员很容易不知不觉就创建了全局变量（比如打字出错）；最后，顶层对象的属性是可以到处书写的，这非常不利于模块化编程。另一方面，window对象有实体含义，指的是浏览器的窗口对象，顶层对象有一个实体含义的对象，也是不合适的。
- ES6为了改变这一点，一方面规定，为了保持兼容性，var命令和function命令声明的全局变量，依旧是顶层对象的属性；另一方面规定，let命令，const命令，class命令声明的全局变量，不属于顶层对象的属性。也就是说，从ES6开始，全局变量将逐步与顶层对象的属性脱钩。