day14 ES6

day14 ES6

1. let语法

(1) let是什么?

let用来声明变量,它的用法类似于var,但是所声明的变量,只在let命令所在的代码块内有效,类似于C,C++,JAVA局部变量的概念。

(2) 基本用法

1)块级作用域

{
    var a = 10;
    let b = 123;
}
console.log(a);
console.log(b);//Uncaught ReferenceError: b is not defined

上面代码在代码块之中,分别用let和var声明了两个变量。然后在代码块之外调用这两个变量,结果let声明的变量无法被打印,var声明的变量返回了正确的值。

这表明,let声明的变量只在它所在的代码块有效。

for(var i=0; i<10; i++){
    document.write(i);//0123456789
}
document.write(i);//10
for(let i=0; i<10; i++){
    document.write(i);//0123456789
}
document.write(i);// 看不到,i is not defined 

上面代码中,计数器i只在for循环体内有效,在循环体外引用就会报错。

2)暂时性死区

在被let修饰的同名变量下,根据就近原则,内部变量屏蔽外部变量。

下面代码在有两个同名变量a,但是却由于{}使得作用域不同,输出结果为123,456。

let a = 456;
{
    let a = 123;
    console.log(a);//123
}
console.log(a);//456

3) 不存在变量提升

var命令会发生”变量提升“现象,即变量可以在声明之前使用,值为undefined。这种现象多多少少是有些奇怪的,按照一般的逻辑,变量应该在声明语句之后才可以使用。

也就意味着被let声明的变量,必须先定义在使用。

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;
// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;

4) 不允许重复声明

var a = 123;  
var a = 123; //  可以实现
let b = 123;
let b = 123; //  Identifier 'a' has already been declared

2. this

1) 当this出现在普通方法时,this代表调用当前方法的对象本身。

2) 当this出现在事件中时,this代表触发当前事件的HTML元素本身。

//常规函数    
    function fun(){
        console.log(this);//this是window对象
    }
    fun();
//匿名函数
    setTimeout(function(){
        console.log(this);//this是window对象
    },2000);

//事件
    document.onclick = function(){
        console.log(this);//document对象
    }

3. bind

bind往往用来修改匿名函数的this指向;

语法:函数对象.bind(新this的指向):用新的参数改变this的指向;

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <style type="text/css">
            #box {
                height: 100px;
                width: 100px;
                background-color: red;
            }
        </style>
    </head>
    <body>
        <div id="box">    
        </div>
    </body>
</html>
<script type="text/javascript">
    let oBox = document.querySelector('#box');
    document.onclick = function(){
        //document不是元素,不能使用document.style.display会报错
        //所以必须使用bind修改this的指向,才能隐藏div块
        this.style.display = 'none';
    }.bind(oBox);
</script>

扩展:有名函数重新指定this对象: apply call

    function fun() {
        console.log(this);
    }

    //apply call
    fun.apply(oBox);
    fun.call(oBox);

4.JSON.parse/JSON.stringify

<script type="text/javascript">
    let jsonStr = '{"name":"小猫","age": 3}';
    let json = JSON.parse(jsonStr);
    console.log(typeof json);//object
    
    // let jsonObj = {"name":"小猫","age": 3};
    // let json = JSON.stringify(jsonObj);
    // console.log(typeof json);//String
</script>

5. const 用法

const命令用来声明常量,一旦声明,其值就不能改变。也就是只读变量。

基本用法:

1) 声明常量

const PI = 3.1415;
PI = 3;// TypeError: Assignment to constant variable.

2)常量必须初始化

const foo;//报错 Missing initializer in const declaration

3) 块级作用域

{
    const foo = 123;
}
console.log(foo);

上述代码依然报错,和let的效果是一样的。

4) 声明不提升(const修饰的变量必须先定义后使用)

if (true) {
    console.log(MAX); // ReferenceError
    const MAX = 5;
}

5) const修饰的变量不可重复定义

简单来说,let和const的功能基本类似,只是let用来修饰变量,const用来修饰常量

注意事项:

1.必须要初始化
const a;
a = 123;//X
2.不能改
3.建议只读变量名大写

6. for..in...和for...of...

let strArr = ["heihei","haha","laowang"];

    for(let index in strArr){ //遍历下标
        console.log(strArr[index]);
    }
    for(let item of  strArr){ //遍历值
        console.log(item);
    }

7. 字符串扩展方法

判断字符串是否包含在另一个字符串中:

在ES5 中使用的是 indexOf() 方法,在ES6中可以使用includes()、startsWith()、endsWith()三个方法。

  • str.includes(参数): 返回布尔值,表示是否找到了参数字符串。
  • str.startsWith(参数):返回布尔值,参数是否在源字符串的头部。
  • str.endsWith(参数): 返回布尔值,参数是否在源字符串的尾部。

UTF-16 0~65535/UTF-32:

JavaScript内部,字符以UTF-16的格式储存,每个字符固定为2个字节。对于那些需要4个字节储存的字(Unicode码点大于0xFFFF的字符),JavaScript会认为它们是两个字符。

如:var str = "𡱖"; 汉字"𡱖"的编码是21c56(需要四个字节),超过了FFFF。即超过javascript本身能表示的字符的最大范围。javascript就会把“𡱖”当作两个字符处理,

即str.length是2。而且,以前的函数,如:charAt()函数一次只能读取该汉字的其中一半。

<script type="text/javascript">
    var str = "𡱖";   //21c56
    console.log(str.length);//2
    console.log(str.charAt(0));//显示的结果有误
    console.log(str.charCodeAt(0).toString(16));//一次只能读两个字节
    console.log(str.codePointAt(0).toString(16));//21c56 
    console.log("\u{21c56}");//𡱖
</script>

8. 箭头函数 (针对匿名函数)

定义: ()=> {}

有参数: (参数1,参数2)=>{ }

带有返回值: () => {返回值}

//let fun = function(){
//    console.log('haha');
//}
let fun = ()=>{
    console.log('haha');
}
fun();

setTimeout(()=>{console.log(123)},2000);

document.onclick = () => {
        console.log("document");
}

9. 结构赋值

强调格式匹配:等号左边和右边一致

好处:

1)一次性定义很多个变量
let x=10,y=20;
let [a,b,c]=[3,4,5];//相当于a=3,b=4,c=5
//JSON对象赋值
let {name,age} = {name:"老王",age:66}; 
console.log(name,age);//老王 66

...逆运算符

    let arr = [1,2,3];
    let arr1 = arr;
    arr1[0] = 66;
    console.log(arr);//[66,2,3]
    let arr = [1,2,3];
    let arr1 = [...arr];
    arr1[0] = 66;
    console.log(arr);//[1,2,3]
2) 可以让一个函数一次性返回多个值
  • 使用[], 返回的是数组

        function fun(){
            return [1,2,3];
        }
        let arr = fun();
        console.log(arr);//数组
3) 实现两个数的交换
    let a=10,b=20;
    [a,b] = [b,a];
    console.log(a,b);//20 10

回顾其他两种交换数字的方法:

方法1:通过引起一个中间变量

    let a=10,b=20;
    let temp;
    temp = a;
    a = b;
    b = temp;
    console.log(a,b);//20 10

方法2:

    a = a + b;
    b = a - b; //b=a+b-b;=>b=a;
    a = a - b; //

10. set集合

set集合,类似于数组的一种容器

1)定义

let set = new Set(数组);
let set = new Set([1,1,2,2,3,4,5,5]);

2) 特点

自动去重,没有下标

3) set的遍历

let set = new Set([1,1,2,2,3,4,5,5]);
for(let item of set){
    console.log(item);
}

4) 实现数组去重

Array.from(集合): 将参数容器转换成数组

let arr =[2,3,4,2,3,4,2,3,4];
let set = new Set(arr);
arr = Array.from(set);    
console.log(arr);

5) set集合的方法

  • add(参数) 向集合中添加一个元素(默认添加到最后)
  • delete(值) 删除集合中某个数
  • has(值) 判断集合中是否含有某个值,返回true/false
  • clear() 清空集合

11. map 键值对

map:映射->key-value; 在map中,通过key来操作value。key是唯一的。

  • set(key,value)向集合中添加一个元素
  • get(键) 根据键去取值
  • delete(键) 删除集合中某个数
  • has(键) 判断集合中是否含有某个值
  • clear() 清空集合
let map = new Map();
map.set("1","大黄");
map.set("2","小明");
map.set("3","老王");
//map.delete("3");
//map.clear();
console.log(map.has("0"));
console.log(map.get("2"));
console.log(map);

map的遍历:

for(let item of map){   
        console.log(item[0] + item[1]); //0代表Key  1代表value
    }

12. ES6 字符串模板

传统的字符串拼接不能正常换行;

传统的字符串拼接不能友好的插入变量;

传统的字符串拼接不能友好的处理单引号、双引号互相嵌套的问题;

ES6的模板字符串解决了以上问题。

es6 使用``(windows键盘英文输入法下tab键上面那个键)来定义一个字符串。

<script type="text/javascript">
    let oBox = document.querySelector('#box');
    // oBox.innerHTML = "<span id='haha'>" + 123 + "</span>";//传统的字符串拼接
    
    //ES6模板字符串
    oBox.innerHTML = `<span id="haha">456</span>`;
    let oUl = document.querySelector('ul');   
    for(let i=0;i<10;i++){
        //${变量}
        oUl.innerHTML += `<li>${i}</li>`;
    }
</script>

评论

暂无评论