es6常用api总结(上)

2019-07-25 本文已影响0人 shenjianbo

变量
- ES6新增let变量，用来声明变量，用法类似于var，只是声明的变量只在let命令所在的代码块内有效
- 例1：
- ```
for(var j = 0; j < 3 j++) {} console.log(j); // 3
for(let i = 0; i < 3 i++) {} console.log(i); // ReferenceError: i is not defined
```
- 例2：
- ```
var a = [];
for (var i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 10
```
- ```
var a = [];
for (let i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 6
```
- const也是用于声明变量，表明声明一个常量，一旦声明后，值不能被修改，也就意味着一旦声明就必须进行初始化
- 例：
- ```
const str = 123;
str = 456; // TypeError: Assignment to constant variable.
```
- 以上两种声明方式不存在变量提升，也就是只能在声明之后使用，一旦在声明之前使用则会报错，var则存在声明提升
- 例：
- ```
console.log(a); // undefined;
var a = 1;
console.log(b); // 报错
let b = 1;
```
- 在一个块级作用域内，同一个变量不能被重复声明
- ```
let a = 1;
let a = 2; // 报错
```
- 块级作用域
  - 类似于function，在块级作用域外不能访问作用域内的变量
  - 例：
  - ```
  {
      let a = 1;
  }
```

变量解构与赋值

准确来说是模式匹配

数组的解构
例1:

let [a, b, c] = [1, 2, 3];
// a 1
// b 2
// c 3

以上是按照顺序进行匹配赋值
例2：

let [a, , b] = [1, 2];
// a 1
// b undefined

例3：设置默认值

let [a = 3, , b = 4] = [1, 2];
// a 1
// b 4

对象的解构
例1：

let {a, b} = {a: 1, b: 2}
// a 1
// b 2

例2：

let {c, b} = {a: 1, b: 2}
// c undefined
// b 2

例3：设置默认值

let {a = 1, b = 2} = {a: 3}
// a 3
// b 2

解构嵌套
例：

let obj = {
  p: [
    'Hello',
    { y: 'World' }
  ]
};

let { p: [x, { y }] } = obj;
x // "Hello"
y // "World"

字符串扩展
- 模板字符串
  - 在es5及之前，想要将几个字符串组合为一个，并且加上参数，必须通过+来拼接
  - 例：
  - ```
  let h = '标题';
  let p = '段落';
  let result = '<div>'
  + '<h1>' + h + '<h1>'
  + '<p>' + p + '</p>'
  + '</div>';
```
- 在es6中新增反引号来标识的模板字符串来简化上面这一过程
- 例：
- ```
let h = '标题';
let p = '段落';
let result = `<div>
    <h1>${h}</h1>
    <p>${p}</p>
div`;
```
  - 上面的${}中可以写任何表达式
  - 例：
  - ```
  let h = '标题';
  let p = '段落';
  let result = `<div>
      <h1>${h ? h : '标题不存在'}</h1>
      <p>${p}</p>
  div`;
```
- 模板字符串也可以用来执行函数
- 例：
- ```
alert`1`;
```
- 以下方法用来表示一个字符串是否在两一个字符串中，支持两个参数
- includes 第一个参数表示需要查找的字符串，第二个参数表示查找的起始下标位置
- ```
let a = 'abc';
let result1 = a.includes('a'); // true
let result2 = a.includes('d'); // false
let result3 = a.includes('a', 1); // false
```
- startsWith 第一个参数表示需要查找的字符串，第二个参数表示查找的起始下标位置
- ```
let a = 'abc';
let result1 = a.startsWith('a'); // true
let result2 = a.startsWith('b'); // false
let result3 = a.startsWith('b', 1); // true
```
- endsWith 第一个参数表示需要查找的字符串，第二个参数表示查找的字符串从前往后的个数，查前多少个的意思，不按照下标来计算
- ```
let a = 'abc';
let result1 = a.endsWith('c'); // true
let result2 = a.endsWith('b'); // false
let result3 = a.endsWith('b', 2); // true
```

数值的方法

Number.isInteger()
判断是否为一个整数
例：

Number.isInteger(2); // true
Number.isInteger(2.1); // false

指数运算符**,指数运算符从右往左计算
例：

let result = 2 ** 3; // 8
let result = 2 ** 3 ** 2; // 512  相当于2 ** (3 ** 2)

函数的扩展

为参数加默认值
例：es5中,为了保证程序的正常运行，我们一般会像下面这样写

function fn(a, b) {
  a = a || 123;
  b = b || 456;
  console.log(a, b); // 1 456
}
fn(1, '');

es6中
例：

function fn(a = 123, b = 456) {
  console.log(a, b); // 1 456
}
fn(1, '');

配合解构

function fn({a = 123, b = 456}) {
  console.log(a, b); // 1 456
}
fn({a: 1})

箭头函数
例：

let fn1 = id => {
  console.log(id); // 1
}
fn1(1);
// 等同于
let fn2 = function(id) {
  console.log(id); // 2
}
fn2(2);

// 需要返回值时
let fn3 = id => id;
// 等同于
let fn4 = function(id) {
  return id;
}

// 箭头函数会把箭头后面的{}解析为代码块，如果需要返回一个对象时,需要用小括号包裹
let fn5 = (id1, id2) => ({a: id1 ** 2, b: id2 ** 3});

rest参数
例：

// 当参数不固定时，想要获取一个参数的集合
// es5
function fn1() {
  console.log(arguments) // [2, 3, 4] 是一个伪数组
}
fn1(2, 3, 4);
// es6
function fn2(...arg) {
  console.log(arg) // [2, 3, 4] 真实的数组
}
fn2(2, 3, 4);

扩展运算符

数组的扩展
例：
扩展到的地方必须有一个宿主，比如对象或者数组

let [...a] = [1, 2, 3];
console.log(a); // [1, 2, 3]
let {...b} = [1, 2, 3];
console.log(b); {0: 1, 1: 2, 2: 3}

例：

let a = [1, 2, 3];
let b = [...a];
console.log(b); // [1, 2, 3];

合并数组

let a = [1, 2, 3];
let b = [4, 5, 6];
let c = [...a, ...b];
console.log(c); // [1, 2, 3, 4, 5, 6]

只能进行浅拷贝

let a = [
  {
      name: 'li'
  }
]
let b = [...a];
console.log(a[0] === b[0]); // true;
b[0].name = 'wang';
console.log(a[0] === b[0]); // true;
// 我们发现b拷贝于a，但是当b里面子对象的值发生改变后，依然影响到了a，所以慎用

与解构混用
- 当使用扩展运算符时，把扩展运算符的表达式放在最后一位，否则会报出错误

let a = [1, 2, 3, 4, 5];
let [b, ...c] = a;
console.log(b, c); // 1, [2, 3, 4, 5]

字符串扩展

let a = 'hello';
let [...b] = a;
console.log(b); // ['h', 'e', 'l', 'l', 'o'];

Array.form()方法
用于将类数组的对象转为真实的数组，比如dom

let domList = document.getElementsByTagName('div');
let result = Array.from(domList);
console.log(resule, result instanceof Array); // [div, div, div] true

Array.of()
用于将一组值转为数组

let a = '123';
let b = '456';
let result = Array.of(a, b);
console.log(result); // ['123', '456']

Array.fill()
用于填充一个数组，常常用于数组的初始化，设置默认的初始值

let a = [1, 2, 3].fill(0);
console.log(a); // [0, 0, 0]

还可以接受第二个和第三个参数, 分别代表填充的起始位置和结束位置，不会填充结束位置

let a = [1, 2, 3, 4, 5].fill({name: 'li'}, 2, 3);
console.log(a); // [1, 2, {name: 'li'}, 4, 5]

数组实例的includes方法
相当于indexOf(),用于检测一个元素是否存在于一个数组中，返回布尔值，和indexOf不同的是，它可以检测到NaN的是否存在，而在es5中NaN和任何值都是不相等的

let a = [1, 2, 3, NaN];
console.log(a.includes(2)); // true
console.log(a.includes(NaN)); // true
console.log(a.includes(5)); // false

也可以接受两个参数，第二个参数代表检查的起始位置，默认从0开始

let a = [1, 2, 3, NaN];
console.log(a.includes(2, 0)); // true
console.log(a.includes(2, 2)); // false
console.log(a.includes(NaN， -1)); // true 从倒数的位置查，如果负值绝对值大于数组长度，则从0开始

参考：http://es6.ruanyifeng.com/

es6常用api总结(上)

猜你喜欢

热点阅读