ECMAScript6入门学习--第一天

Posted Jen Ho

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了ECMAScript6入门学习--第一天相关的知识,希望对你有一定的参考价值。

  ECMAScript与javascript的关系

   ECMA是是一个国际标准化的一个组织,规定了浏览器脚本的语言标准,在上个实际,javascript公司Netscape把javascript托付给ECMA,让其为javascript设置标准,经常见到到版本ES5就是在ES6的上一代标准。

  let

     什么是let?

   狭义理解let是更完美的var,也就是说 他是用来声明变量,方法与var类似,但是优于var,那它的优点是什么呢,下面将详述

   let声明的变量只在该变量的代码块中有效
{
   var a = 1;
   let b = 2 ;       
}  
console.log(a);   //1
console.log(b);  //undefined
   var声名的变量是全局有效的,输出的值是全局变量 
for (var i= 0;i<5;i++){
            //do something
        }
console.log(i) //5

   此时i随着变量提升,已经变成一个全局变量,此时i的值是5

        for (let i= 0;i<5;i++){
            //do something
        }
        console.log(i) //undefined

   如果用let 显示i的值是 undefined 

   下面的两个例子就更加清楚的说明了let声明的变量和var声明的变量的区别了

        var a=[];
        for( var i=0 ;i<5;i++){
             a[i]=function (){
                console.log(i)
            }
        }
        console.log(a[4]())  //5
        var a=[];
        for( let i=0 ;i<5;i++){
            a[i]=function (){
                console.log(i)
            }
        }
        console.log(a[4]()) //4

   var 声明的i是全局变量,循环因子一直是i,只是每次循环i的值发生改变,当访问i时,访问的是全局变量i,所以值就是5

   而let声明的变量是局部变量,每一次循环都要重新声明i,导致当你传入i的时,返回的值就是当前i,所以值就是4

    暂时性死区

     let有一个语法要求,就是let声明之前不能使用var声明变量,否则会产生语法错误

      

   暂时性死区(TDZ:temporal dead zone),在下述代码中就是在let声明命令之前都是变量的死区

        //TDZ起始点
        var tmp = 21;
        //dosomething
        let tmp = 22
//TDZ结束点


   还有一些不易发现的TDZ
        function tdz( x=y,y=2){
                   //dosomething       
        }
        tdz()        //error y undefined

        function tdz( x=2,y=x){
                   //dosomething       
            }
        tdz()   //success
    

     在第一个例子中 ,此时y还没有声明,y就是一个暂时性死区,而在第二个例子中x已经声明了,当第二个形参的值等于已经声明的值,所以不存在暂时性死区 

   let不允许重复声明

    

   let是不允许重复声明一个变量的,但var是可以的,可以这样理解,var声明变量存在变量提升的效果与功能,但是let是不存在变量提升的,这点是let声明变量的特色之一,声明参数必须要咋局部环境中声明,写JS都知道,一是要减少DOM操作,二是不要过多使用全局变量,污染环境。

    块级作用域

     外层代码不受内层代码的影响,有了块级作用域,就不用使用立即执行函数,让外层代码不受内层代码的影响

        function fn(){
            var a = 10;
            {
                var a=20;
            }
            console.log(a);
        }
        fn() //20
        function fn(){
            var a = 10;
            {
                let a=20;
            }
            console.log(a);
        }
        fn() //10

    显然let的块级作用域,在函数内部的一个局部作用域中用let声明一个变量,这个局部作用域声明的变量不影响函数内部的变量,当然块级作用域是允许多层嵌套的  

  const

   const是一个只读常量,一旦声明就不能再次声明,常量的值不会再改变

const c=1;
var  c= 2 
//error

       const与let命令相同,只在声明的块级作用域有效,const也不能重复声明

    const本质上,const声明的变量不是值不能改变,而是变量所指的内存地址不能改动,变量是指向一段地址,这个地址有一个变量,并且这个变量存在一个值

      ES6声明变量的方法

    var let const import class 

       变量的解构

    从数组和对象中提取值,对变量进行赋值,这被称为解构

   数组的解构

        let [a1,b1,c1]=[1,2,3];
        console.log(a1); //1
        console.log(b1); //2
        console.log(c1); //3

        对象的解构

        let {a2,b2,c2}={a2:123,b2:456,c3:789}
        console.log(a2);  //123
        console.log(b2);  //456
        console.log(c2);  //789

     嵌套解构

        var obj={
            p:[
                {per1:123},
                {per2:456}
            ]
        }
        let {p:[{per1},{per2}]}=obj;
        console.log(per1);  //123
        console.log(per2);  //456

     字符串解构

        const [a,b,c] = "123";
        console.log(a)  //1
        console.log(b)  //2
        console.log(c)  //3

    扩展方法

     把类数组对象转成数组

  [].slice.call()  

    silce(start,end) 

    start:数组片段开始处的数组下标。

    end:数组片段结束处的数组下标。

    ES5使用的是[].slice.call() 将类数组转成真正的数组 

    而ES6给了一个语法糖,仅仅使用Array.from()就可以将类数组转成数组

        let obj2 ={
            "0" : "123",
            "1" : "456",
            length:2
        }
        var _a=Array.from(obj2)
            var _b=[].slice.call(obj2)
        console.log(_a)   //["123","456"]
            console.log(_b)   //["123","456"]
  Array.of 是将一组值转换成数组,比较简单
let arr = Array.of(1,2,3)
console.log(arr) //[1,2,3]
    copyWithin方法,在数组内部,将数组成员复制到其他位置处

    copyWithin(target,start,end);

    target:替换数组的位置处

    start:从该位置读取数组。

    end:该位置前(不包括该位置)停止读取数组的位置处

let newarr = [1,2,3,4,5].copyWithin(0,1,2)
console.log(newarr ); //[2,2,3,4,5]
     find()找到首次符合条件的数组成员

     array.find(function (){return })

    let result1 = [1,2,3,4,5].find(function (x){return (x%2)===0})  //方法1
    let result2 = [1,2,3,4,5].find(x => (x%2)===0)  //方法2
    console.log(result1);  //2
    console.log(result2);   //2

      方法1和方法2是等价的,find方法和高阶函数map和filter一样回调函数返回的结果都是return 为true时

      entires() keys() values() 遍历返回 entires返回的是键-值 keys是键 values返回的是值

    for (let x of [1,2,3].keys()){
        console.log(x);   // 0 1 2 
    }

    for (let x of [1,2,3].entries()){
        console.log(x);  // 1,2,3
    }
         for (let x of [1,2,3].values()){
         console.log(x); [key,value]->[0,1] [1,2] [2,3]
     } 
       箭头函数

       箭头函数有一个最大的特点,就是解决了this的指向问题,this一般指向的是当前对象,但是箭头函数声明了一个变量_this=this,也就是指向函数定义生效时所在的对象

       ES6允许 =>定义函数

    var fn = v =>v 等价于

    var fn=function (v){return v;}

        箭头函数的this对象,就是在定义时所在的对象,而不是使用的时候所在的对象

     function Foo(){
         this.v1=0;
         this.v2=0;
         setInterval(()=> this.v1++,1000);
         setInterval(function (){this.v2++},1000);
     }
      var foo = new Foo();
        setTimeout(() => console.log(foo.v1),3000);  //3
        setTimeout(() => console.log(foo.v2),3000);  //0

    第一个定时器用的是箭头函数,当前定义所在的对象是构造函数,而第二个定时器当前定义所在的对象是this所指的作用域,所以结果是不更新的,永远是0

         Object.assign用于对象的合并
var obj1={a:1}
var obj2={b:2}
var obj3={c:3}
Object.assign(obj1,obj2,obj3)
console.log(obj1) //{a:1,b:2,c:3}

    set

     set解构不会添加重复的值

      var s =new Set()

  //let newarr =new Set([array])

   array.forEach( x=>s.add(x));

    for(let x of s){

    console.log(x);

  }

   set下面有4个常用方法

     add()     

   delete()  (返回值bool)

     has  (返回值bool)

   clear

let s = new Set();
s.add(1).add(2).add(3)

   Set可用于数组去重

[...new Set(array)]

Array.from(new Set(array));

    ...是一个扩展运算符,将一个数组转为以“,”分隔的参数序列  

 map

   map数据组构是键值对的集合,这个键可以是字符串

 map数组组构也有set get has 三个常用的方法

     var set1=new Map();
     var str={p:\'123\'};
     set1.set(str,"123");
     set1.get(str);
     console.log(set1);// Map(1) {Object {p: "123"} => "123"}

 结果是一个key-value的键值对,键是一个json对象,也可以是字符串

    下面是一个将map数据组构转成json的一个事例

    function maptoobj(permate){
        var obj= Object.create(null);
        for([key,value] of permate){
            obj[key]=value;
        }
        return obj;
    }
    function objtojson(permate){
        return JSON.stringify(maptoobj(permate));
    }
    var mo =new Map().set("1","2").set("2","3");
    console.log(objtojson(mo));  //{"1":"2","2":"3"}

    首先要建一个map mo ,将mo先要抓成对象,也就是 maptoobj函数,再将转成的对象JSON.stringify成字符串,也就是 objtojson函数

       将json数据转成map

       根据将map数据组构转成json的思想,逆向思考,给的是json字符串,先将其json.parse 将parse的结果在解析成map,是不是又要传到一个函数里面,这个函数的功能就是将对象解析成map,是不是又要使用map的set方法了?其中是不是用到for of语句

        function jsontomap(permate){
            var m = new Map()
            for(let x of Object.keys(permate)){
                m.set(x,permate[x])
            }
            return m ;
        }
        function fn(permate){
            return jsontomap(JSON.parse(permate));
        }
        console.log(JSON.parse(\'{"1":"2","2":"3"}\'))
        console.log(obj[2]);
        console.log(fn(\'{"name":"2","sex":"3"}\'))

    这里面补充一下 obeject.key与object[key]有什么区别

    有时候我们在写一个对象的时候

        var obj={
            "name":"1",
            "time":"2"
        }
        console.log(obj.time); //1
        console.log(obj.name);  //2

        var _obj={
            "1":"1",
            "2":"2"
        }
        console.log(_obj[1]); //1
        console.log(_obj[2]);  //2

    但是什么时候用这两个,根据网上查资料,object.key的方法是在没有使用for循环或者遍历,如果为for循环,涉及到依次遍历,则就需使用object[key]了

    就像上面的例子

for(let  x of Object.keys(permate)){
     m.set(x,permate[x])      
}

    具体的也可以参考一下  obeject.key与object[key]有什么区别 

    

  学习总结

   这就是我学习ES6总结的一些知识点,写的不好,望轻喷~~

  

  

以上是关于ECMAScript6入门学习--第一天的主要内容,如果未能解决你的问题,请参考以下文章

学习php第一天

python入门学习第一天

三天爆肝快速入门机器学习第一天

ECMAScript6入门-序言

学习python第一天

黑马程序员---三天快速入门Python机器学习(第一天)