标签：def 自定义属性 二次 简写 调用函数 array 继承 字符串格式化 拼接
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‘ };// 报错
有几个点需要注意：
在ES6之前，我们往往这么处理模板字符串：
通过“\”和“+”来构建模板
$("body").html("This demonstrates the output of HTML \ content to the page, including student‘s\ " + name + ", " + seatNumber + ", " + sex + " and so on.");
而对ES6来说
$("body").html(`This demonstrates the output of HTML content to the page, including student‘s ${name}, ${seatNumber}, ${sex} and so on.`);
ES6 中，箭头函数就是函数的一种简写形式，使用括号包裹参数，跟随一个 =>，紧接着是函数体；
箭头函数本身没有this，如果在箭头函数内部使用this，这个this一定是它上级的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.
在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
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]
ES6 支持二进制和八进制的字面量，通过在数字前面添加 0o 或者0O 即可将其转换为八进制值：
let oValue = 0o10; console.log(oValue); // 8 let bValue = 0b10; // 二进制使用 `0b` 或者 `0B` console.log(bValue); // 2
// 对象 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);
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
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：
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
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 关键词
标签：def 自定义属性 二次 简写 调用函数 array 继承 字符串格式化 拼接
原文地址：https://www.cnblogs.com/psxiao/p/11613566.html
