ES6(三) 数组、函数、迭代器

1.数组

1.1数组创建

Array.of()：将参数中所有值作为元素形成数组。

从上面的例子来看参数值为不同类型；如果参数为空时返回的是空数组。

Array.from()：将类数组对象或可迭代对象转化为数组。

console.log(Array.from([1, 2])); // [1, 2]
 
console.log(Array.from([1, , 3])); // [1, undefined, 3]

参数为数组,返回与原数组一样的数组，如果参数有空位时返回的是undefined。

类数组对象
一个类数组对象必须含有 length 属性，且元素属性名必须是数值或者可转换为数值的字符。

从上面例子看如果没有length属性，就会返回空数组；如果元素属性名不为数值且无法转换为数值，返回长度为 length 元素值为 undefined 的数组

转换可迭代对象
转换 map

let map = new Map();
map.set('key1', 'value1');
map.set('key2', 'value2');
console.log(Array.from(map)); // [['key1', 'value1'],['key2', 'value2']]

转换 set

let arr = [1, 2, 3];
let set = new Set(arr);
console.log(Array.from(set)); // [1, 2, 3]

转换字符串

let str = 'abc';
console.log(Array.from(str)); // ["a", "b", "c"]

1.2扩展的方法

查找
find()：查找数组中符合条件的元素,若有多个符合条件的元素，则返回第一个元素。

let arr = Array.of(1, 2, 3, 4);
console.log(arr.find(item => item > 2)); // 3
 
console.log([, 1].find(n => true)); // undefined

数组空位处理为 undefined。

findIndex()：查找数组中符合条件的元素索引，若有多个符合条件的元素，则返回第一个元素索引。

let arr = Array.of(1, 2, 1, 3);
console.log(arr.findIndex(item => item = 1)); // 0
 
console.log([, 1].findIndex(n => true)); //0

数组空位处理为0。

填充
fill()：将一定范围索引的数组元素内容填充为单个指定的值。

let arr = Array.of(1, 2, 3, 4);
console.log(arr.fill(0,1,3)); // [1, 0, 0, 4]

参数1：用来填充的值，参数2：被填充的起始索引，参数3(可选)：被填充的结束索引，默认为数组末尾。

copyWithin()：将一定范围索引的数组元素修改为此数组另一指定范围索引的元素。

console.log([1, 2, 3, 4].copyWithin(0,2,4)); // [3, 4, 3, 4]

console.log([1, 2, 3, 4].copyWithin(-2, 0)); // [1, 2, 1, 2]
 
console.log([1, 2, ,4].copyWithin(0, 2, 4)); // [, 4, , 4]

参数1：被修改的起始索引，参数2：被用来覆盖的数据的起始索引，参数3(可选)：被用来覆盖的数据的结束索引，默认为数组末尾。
如果参数1为负数表示倒数。

遍历
entries()：遍历键值对。

let entries = ['a', 'b'].entries();
console.log(entries.next().value); // [0, "a"]
console.log(entries.next().value); // [1, "b"]

console.log([...[,'a'].entries()]); // [[0, undefined], [1, "a"]]

不使用 for… of 循环，如果数组含空位就返回undefined。

keys()：遍历键名。

console.log([...[,'a'].keys()]); // [0, 1]

如果素组有空位就会返回0。

values()：遍历键值。

console.log([...[,'a'].values()]); // [undefined, "a"]

如果数组含空位就返回undefined。

包含
includes()：数组是否包含指定值。

参数1：包含的指定值，参数2：可选，搜索的起始索引，默认为0.

嵌套数组转一维数组
flat()

flat(2)：指定转换的嵌套层数。
flat(Infinity)：不管嵌套多少层。
flat()：自动跳过空位。

flatMap()：先对数组中每个元素进行了的处理，再对数组执行 flat() 方法。

console.log([1, 2, 3].flatMap(n => [n * 2])); // [2, 4, 6]

参数1：遍历函数，该遍历函数可接受3个参数：当前元素、当前元素索引、原数组，参数2：指定遍历函数中 this 的指向。

1.3扩展运算符

复制数组

let arr = [1, 2],
arr1 = [...arr];
console.log(arr1); // [1, 2]
 
let arr2 = [1, , 3],
    arr3 = [...arr2];
console.log(arr3);	// [1, undefined, 3]	

数组内有空位就会返回undefined。

合并数组

console.log([...[1, 2],...[3, 4]]); // [1, 2, 3, 4]

2.函数

2.1函数参数的扩展

默认参数

基本用法

function fn(name,age=17){
 console.log(name+","+age);
}
fn("Amy",18);  // Amy,18
fn("Amy","");  // Amy,
fn("Amy");     // Amy,17

使用函数默认参数时，不允许有同名参数否则就会报SyntaxError: Duplicate parameter name not allowed in this context错误。

函数参数默认值存在暂时性死区，在函数参数默认值表达式中，还未初始化赋值的参数值无法作为其他参数的默认值。

不定参数
不定参数用来表示不确定参数个数，形如，…变量名，由…加上一个具名参数标识符组成。具名参数只能放在参数组的最后，并且有且只有一个不定参数。

基本用法

function f(...values){
console.log(values.length);
}
f(1,2);      //2
f(1,2,3,4);  //4

2.2箭头函数

箭头函数提供了一种更加简洁的函数书写方式。基本语法是：参数 => 函数体

基本用法：

var f = v => v;
//等价于
var f = function(a){
 return a;
}
f(1);  //1

var f = (a,b) => a+b;
f(6,2);

当箭头函数没有参数或者有多个参数，要用 () 括起来。

var f = (a,b) => {
 let result = a+b;
 return result;
}
f(6,2);  // 8

当箭头函数函数体有多行语句，用 {} 包裹起来，表示代码块，当只有一行语句，并且需要返回结果时，可以省略 {} , 结果会自动返回。

当箭头函数要返回对象的时候，为了区分于代码块，要用 () 将对象包裹起来，否则就会报错：SyntaxError: Unexpected token :。

没有 this、super、arguments 和 new.target 绑定。
箭头函数体中的 this 对象，是定义函数时的对象，而不是使用函数时的对象。

3.迭代器

3.1Iterator

迭代过程

上面的例子，首先创建一个数组，然后通过 Symbol.iterator 方法创建一个迭代器，之后不断的调用 next 方法对数组内部项进行访问，当属性 done 为 true 时访问结束。

可迭代的数据结构
Array：数组 ( Array ) 和类型数组 ( TypedArray ) 他们是可迭代的。

for (let item of ["zero", "one", "two"]) {
  console.log(item);
}
// zero
// one
// two

String：字符串是可迭代的，单他们遍历的是 Unicode 码，每个码可能包含一个到两个的 Javascript 字符。

Map：Map 主要是迭代它们的 entries ，每个 entry 都会被编码为 [key, value] 的项， entries 是以确定的形势进行迭代，其顺序是与添加的顺序相同。

const map = new Map();
map.set(0, "zero");
map.set(1, "one");
 
for (let item of map) {
  console.log(item);
}
// [0, "zero"]
// [1, "one"]

Set：Set 是对其元素进行迭代，迭代的顺序与其添加的顺序相同。

const set = new Set();
set.add("zero");
set.add("one");
 
for (let item of set) {
  console.log(item);
}
// zero
// one

arguments：arguments 目前在 ES6 中使用越来越少，但也是可遍历的。

function args() {
  for (let item of arguments) {
    console.log(item);
  }
}
args("zero", "one");
// zero
// one

3.2for…of循环

for…of 是 ES6 新引入的循环，用于替代 for…in 和 forEach() ，并且支持新的迭代协议。它可用于迭代常规的数据类型，如 Array 、 String 、 Map 和 Set 等等。

迭代常规数据类型

Array

const nums = ["zero", "one", "two"];

for (let num of nums) {
  console.log(num);
}
TypedArray
const typedArray1 = new Int8Array(6);
typedArray1[0] = 10;
typedArray1[1] = 11;
 
for (let item of typedArray1) {
  console.log(item);
}

String

const str = "zero";

for (let item of str) {
  console.log(item);
}

Map

let myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
myMap.set(2, "two");
 
// 遍历 key 和 value
for (let [key, value] of myMap) {
  console.log(key + " = " + value);
}
for (let [key, value] of myMap.entries()) {
  console.log(key + " = " + value);
}
 
// 只遍历 key
for (let key of myMap.keys()) {
  console.log(key);
}
 
// 只遍历 value
for (let value of myMap.values()) {
  console.log(value);
}

Set

let mySet = new Set();
mySet.add("zero");
mySet.add("one");
mySet.add("two");
 
// 遍历整个 set
for (let item of mySet) {
  console.log(item);
}
 
// 只遍历 key 值
for (let key of mySet.keys()) {
  console.log(key);
}
 
// 只遍历 value
for (let value of mySet.values()) {
  console.log(value);
}
 
// 遍历 key 和 value ，两者会相等
for (let [key, value] of mySet.entries()) {
  console.log(key + " = " + value);
}

可迭代的数据结构
let 、const 和 var 用于 for…of

const nums = ["zero", "one", "two"];

for (const num of nums) {
  console.log(num);
}
// 报 ReferenceError
console.log(num);

从上面的例子我们看到，最后一句会报异常，原因 num 的作用域只在循环体内部，外部无效，具体可查阅 let 与 const 章节。使用 var 则不会出现上述情况，因为 var 会作用于全局，迭代将不会每次都创建一个新的存储空间。

const nums = ["zero", "one", "two"];

forv (var num of nums) {
  console.log(num);
}
// output: two
console.log(num);