es6入门

/**
 * 字符串扩展
*/
// let xukai = 'aaaaxxxxx'
//字符串增长方法 includes() startsWith() endsWith()
// let str =  'xukai'.repeat(3) //循环次数
// let str = 'xukai'.padStart(8,'aa')     padEnd  //补全功能
// let str = `
// aaa${xukai}aaasdsd                      
// `
// console.log(str)

/**
 * 函数扩展
*/


//  function log (x , y = 'xukai') {  //能够加默认值 命名不能相同
//    console.log(x, y)
//  }
//  log ('')

// var f = v => v

// var f = function (v) {
//   return v
// }
// var sum = ( a , b ) => a + b


// let func = id => ({id:id , name : 'xukai'})   //返回值为对象须要用（）

// [1,2,3].map(function () {
//   return x*x
// })

// [1,2,3].map(() => x*x) 

// let res = [12323,2123].sort((a,b) => a-b)
//   箭头函数有几个使用注意点。

// （1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。

// （2）不能够看成构造函数，也就是说，不可使用new命令，不然会抛出一个错误。

// （3）不可使用arguments对象，该对象在函数体内不存在。若是要用，能够用 rest 参数代替。

// （4）不可使用yield命令，所以箭头函数不能用做 Generator 函数。

// 上面四点中，第一点尤为值得注意。this对象的指向是可变的，可是在箭头函数中，它是固定的。

// this指向的固定化，并非由于箭头函数内部有绑定this的机制，实际缘由是箭头函数根本没有本身的this，致使内部的this就是外层代码块的this。正是由于它没有this，因此也就不能用做构造函数。

// ES6
// function foo() {
//   setTimeout(() => {
//     console.log('id:', this.id);
//   }, 100);
// }

// ES5
// function foo() {
//   var _this = this;

//   setTimeout(function () {
//     console.log('id:', _this.id);
//   }, 100);
// }

/**
 * 数组扩展
*/
// const numn = [1,2,3,43,5,54,34]
// let add = (a,b,c) => a + b + c

// console.log(add(...numn))

// let xx =  Array.of('122',21,'xuakl')     //将一组数值转换为数组
// console.log(xx)

// Array.of方法能够用下面的代码模拟实现。

// function ArrayOf(){
//   return [].slice.call(arguments);
// }


// [1,2,34,21,4,325,1].find((n) => n <22)   //find查找

// new Array(3).fill(5) //填充值   fill(填充值，起始位，结束位)

// [1,2,3,4].includes(2)  //true     包含
// if (arr.indexOf(el) !== -1) {
//   // ...
// }


/**
 * 对象扩展
*/

// const o = {
//   method() {
//     return "Hello!";
//   }
// };

// 等同于

// const o = {
//   method: function() {
//     return "Hello!";
//   }
// };

// this关键字老是指向函数所在的当前对象，ES6 又新增了另外一个相似的关键字super，指向当前对象的原型对象。super关键字表示原型对象时，只能用在对象的方法之中，用在其余地方都会报错。


// 对象的扩展运算符等同于使用Object.assign()方法。

// let aClone = { ...a };
// // 等同于
// let aClone = Object.assign({}, a);

// Object.is('foo','foo') //比较

// const target = { a: 1 };

// const source1 = { b: 2 };
// const source2 = { c: 3 };

// Object.assign(target, source1, source2);
// target // {a:1, b:2, c:3}
// Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。

// 注意，若是目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

/**
 * Set和Map数据结构
*/
// Set 是一个没有重复值的数组
// [... new Set([1,2,1,2,3,4,4])]

// Set.prototype.constructor：构造函数，默认就是Set函数。
// Set.prototype.size：返回Set实例的成员总数。

// add(value)：添加某个值，返回 Set 结构自己。
// delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
// has(value)：返回一个布尔值，表示该值是否为Set的成员。
// clear()：清除全部成员，没有返回值。

// Array.from方法能够将 Set 结构转为数组。


// function dedupe(array) {   //数组去重
//   return Array.from(new Set(array));
// }

// dedupe([1, 1, 2, 3]) // [1, 2, 3]

// var arr = [1, 2, 3]
// var iterator = arr[Symbol.iterator]()
// console.log(iterator.next())
// console.log(iterator.next())
// console.log(iterator.next())
// console.log(iterator.next())

复制代码