码迷,mamicode.com
首页 > 其他好文 > 详细

es6的新特性

时间:2019-10-01 14:06:05      阅读:87      评论:0      收藏:0      [点我收藏+]

标签:def   自定义属性   二次   简写   调用函数   array   继承   字符串格式化   拼接   

1.不一样的变量声明:const和let

ES6推荐使用let声明局部变量,相比之前的var(无论声明在何处,都会被视为声明在函数的最顶部)

let和var声明的区别:

var x = 全局变量;
{
  let x = 局部变量;
  console.log(x); // 局部变量
}
console.log(x); // 全局变量

let表示声明变量,而const表示声明常量,两者都为块级作用域;const 声明的变量都会被认为是常量,意思就是它的值被设置完成后就不能再修改了:

const a = 1
a = 0 //报错

如果const的是一个对象,对象所包含的值是可以被修改的。抽象一点儿说,就是对象所指向的地址没有变就行:

const student = { name: cc }

student.name = yy;// 不报错
student  = { name: yy };// 报错

有几个点需要注意:

  • let 关键词声明的变量不具备变量提升(hoisting)特性
  • let 和 const 声明只在最靠近的一个块中(花括号内)有效
  • 当使用常量 const 声明时,请使用大写变量,如:CAPITAL_CASING
  • const 在声明时必须被赋值

2.模板字符串

在ES6之前,我们往往这么处理模板字符串:
通过“\”和“+”来构建模板

$("body").html("This demonstrates the output of HTML \
content to the page, including students\
" + name + ", " + seatNumber + ", " + sex + " and so on.");

而对ES6来说

  1. 基本的字符串格式化。将表达式嵌入字符串中进行拼接。用${}来界定;
  2. ES6反引号(``)直接搞定;
$("body").html(`This demonstrates the output of HTML content to the page, 
including students ${name}, ${seatNumber}, ${sex} and so on.`);

3.箭头函数(Arrow Functions)

ES6 中,箭头函数就是函数的一种简写形式,使用括号包裹参数,跟随一个 =>,紧接着是函数体;

箭头函数本身没有this,如果在箭头函数内部使用this,这个this一定是它上级的this。

箭头函数可以代替函数表达式,但代替不了函数声明,它还是需要声明才能使用的。

箭头函数最直观的三个特点。

  • 不需要 function 关键字来创建函数
  • 省略 return 关键字
  • 继承当前上下文的 this 关键字
// ES5
var add = function (a, b) {
    return a + b;
};
// 使用箭头函数
var add = (a, b) => a + b;

// ES5
[1,2,3].map((function(x){
    return x + 1;
}).bind(this));
    
// 使用箭头函数
[1,2,3].map(x => x + 1);

细节:当你的函数有且仅有一个参数的时候,是可以省略掉括号的。当你函数返回有且仅有一个表达式的时候可以省略{} 和 return;

同时复习一下this的认识:

1.在函数体外,this指的就是window对象

2.在函数体内,谁调用函数this就指向谁

3.在html标签中,this指的是当前的这个标签元素

4.在ES6中,对于箭头函数,要看它在哪里创建的,和当前函数的作用域。

补充es6箭头函数的this

箭头函数的this定义:箭头函数的this是在定义函数时绑定的,不是在执行过程中绑定的。简单地说,函数在定义时 ,this就继承了定义函数的对象(即继承了父级的this)。

所以,这会很好的解决匿名函数和setTimeout和setInterval的this指向问题。我们不用再去给其用that变量储存this了。

看下面代码;

<script>
  var obj = {
    say: function () {
      setTimeout(function () {
        console.log(this)
      });
    }
  }
  obj.say();
</script>

结果:window

匿名函数,定时器中的函数,由于没有默认的宿主对象,所以默认this指向window

问题: 如果想要在setTimeout中使用这个对象的引用呢?

用一个变量提前把正确的this引用保存起来,我们通常使用that = this,或者_this = this来保存我们需要的this指针!

<script>
  var obj = {
    func: function() {},
    say: function () {
      var that = this;   //此时的this就是obj对象
      setTimeout(function () {
        console.log(this)
        that.func()
      });
    }
  }
  obj.say();
</script>

示例2

window.val = 1;
var obj = {
  val: 2,
  dbl: function () {
    this.val *= 2;
    val *= 2;
    console.log(val);
    console.log(this.val);
  }
};
// 说出下面的输出结果
obj.dbl();
var func = obj.dbl;
func();

结果:2 4 8 8

<1>12行代码obj.dbl();调用

val变量在没有指定对象前缀,默认从函数中找,找不到则从window中找全局变量

即val *=2就是window.val*=2

this.val默认指的是obj.val;因为db()第一次被obj直接调用

<2>14行代码调用

func()没有任何前缀,类似于全局函数,即window.func调用,所以

第二次调用的时候,this指的是window,val指的是window.val

第二次的结果受第一次的影响

示例3.箭头函数中的this

<script>
  var obj = {
    say: function () {
      var f1 = () => {
        console.log(this); // obj
        setTimeout(() => {
          console.log(this); // obj
        })
      }
      f1();
    }
  }
  obj.say()
</script>
技术图片

结果:都是obj

f1继承父级this指代的obj,不管f1有多层箭头函数嵌套,都是obj

<script>
  var obj = {
    say: function () {
      var f1 = () => {
        console.log(this); // obj
        setTimeout(() => {
          console.log(this); // obj
        })
      }
      f1();
    }
  }
  obj.say()
</script>

复制代码

结果:window,window

第一个this:f1调用时没有宿主对象,默认是window

第二个this:继承父级的this,父级的this指代的是window.

4. 函数的参数默认值

在ES6之前,我们往往这样定义参数的默认值:

// ES6之前,当未传入参数时,text = ‘default‘;
function printText(text) {
    text = text || default;
    console.log(text);
}

// ES6;
function printText(text = default) {
    console.log(text);
}

printText(hello); // hello
printText();// default

5.Spread / Rest 操作符

Spread / Rest 操作符指的是 ...,具体是 Spread 还是 Rest 需要看上下文语境。

当被用于迭代器中时,它是一个 Spread 操作符:(参数为数组)

function foo(x,y,z) {
  console.log(x,y,z);
}

let arr = [1,2,3];
foo(...arr); // 1 2 3

当被用于函数传参时,是一个 Rest 操作符:(参数转化为数组)

function foo(...args) {
  console.log(args);
}
foo( 1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]

6.二进制和八进制字面量

ES6 支持二进制和八进制的字面量,通过在数字前面添加 0o 或者0O 即可将其转换为八进制值:

let oValue = 0o10;
console.log(oValue); // 8
 
let bValue = 0b10; // 二进制使用 `0b` 或者 `0B`
console.log(bValue); // 2

7.对象和数组解构

// 对象
const student = {
    name: Sam,
    age: 22,
    sex: 
}
// 数组
// const student = [‘Sam‘, 22, ‘男‘];

// ES5;
const name = student.name;
const age = student.age;
const sex = student.sex;
console.log(name +  ---  + age +  ---  + sex);

// ES6
const { name, age, sex } = student;
console.log(name +  ---  + age +  ---  + sex);

8.对象超类

ES6 允许在对象中使用 super 方法:

var parent = {
  foo() {
    console.log("Hello from the Parent");
  }
}
 
var child = {
  foo() {
    super.foo();
    console.log("Hello from the Child");
  }
}
 
Object.setPrototypeOf(child, parent);
child.foo(); // Hello from the Parent
             // Hello from the Child

9.for...of 和 for...in

for...of用于遍历一个迭代器,如数组:

let letter = [a, b, c];
letter.size = 3;
for (let letter of letters) {
  console.log(letter);
}
// 结果: a, b, c

for...in用来遍历对象中的属性:

let stu = [Sam, 22, ];
stu.size = 3;
for (let stu in stus) {
  console.log(stu);
}
// 结果: Sam, 22, 男

for in与for of的区别:

for in:

1 一般用于遍历对象的可枚举属性。以及对象从构造函数原型中继承的属性。对于每个不同的属性,语句都会被执行。
2 不建议使用for in 遍历数组,因为输出的顺序是不固定的。
3 如果迭代的对象的变量值是null或者undefined, for in不执行循环体,建议在使用for in循环之前,先检查该对象的值是不是null或者undefined

for of:

1.for…of 语句在可迭代对象(包括 Array,Map,Set,String,TypedArray,arguments 对象等等)上创建一个迭代循环,调用自定义迭代钩子,并为每个不同属性的值执行语句

总结:在循环对象属性的时候,使用for...in,在遍历数组的时候使用for...of

for...in循环出的是key,for...of循环出的是value

for...of是ES6新引入 的特性。修复了ES5引入的for..in的不足

for...of不能循环普通的对象,需要通过和Object.keys()搭配使用

假设我们要遍历一个数组的value,let a Array = [‘a‘,123,{a:‘1‘,b:‘2‘}]

使用for...in循环:

for(let index in aArray){
    console.log(`${aArray[index]}`);
}

使用for...of循环:

for(var value of aArray){
    console.log(value);
}

咋一看好像好像只是写法不一样而已,那为什么说for...of修复了for...in的缺陷和不足。
假设我们往数组添加一个属性name:
aArray.name = ‘demo‘,再分别查看上面写的两个循环:

for(let index in aArray){
    console.log(`${aArray[index]}`); //Notice!!aArray.name也被循环出来了
}
for(var value of aArray){
    console.log(value);
}

所以说,作用于数组的for-in循环除了遍历数组元素以外,还会遍历自定义属性。

for ...of循环不会循环对象的key,只会循环出对象的value,因此for...of不能循环遍历普通对象,对普通对象的属性遍历推荐使用for...in

更详细可以参考:https://blog.csdn.net/qq_38523017/article/details/82387655

10.ES6中的类

ES6 中支持 class 语法,不过,ES6的class不是新的对象继承模型,它只是原型链的语法糖表现形式。

函数中使用 static 关键词定义构造函数的的方法和属性:

class Student {
  constructor() {
    console.log("I‘m a student.");
  }
 
  study() {
    console.log(study!);
  }
 
  static read() {
    console.log("Reading Now.");
  }
}
 
console.log(typeof Student); // function
let stu = new Student(); // "I‘m a student."
stu.study(); // "study!"
stu.read(); // "Reading Now."

类中的继承和超集:

class Phone {
  constructor() {
    console.log("I‘m a phone.");
  }
}
 
class MI extends Phone {
  constructor() {
    super();
    console.log("I‘m a phone designed by xiaomi");
  }
}
 
let mi8 = new MI();

extends 允许一个子类继承父类,需要注意的是,子类的constructor 函数中需要执行 super() 函数。
当然,你也可以在子类方法中调用父类的方法,如super.parentMethodName()。
在 这里 阅读更多关于类的介绍。

有几点值得注意的是:

  • 类的声明不会提升(hoisting),如果你要使用某个 Class,那你必须在使用之前定义它,否则会抛出一个 ReferenceError 的错误
  • 在类中定义函数不需要使用 function 关键词

es6的新特性

标签:def   自定义属性   二次   简写   调用函数   array   继承   字符串格式化   拼接   

原文地址:https://www.cnblogs.com/psxiao/p/11613566.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!