阅读 11

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())

复制代码
关注下面的标签,发现更多相似文章
评论