## 前端面试题 ---（数组扁平化）
[RUNOOB--->ES6数组方法flat()](https://www.runoob.com/w3cnote/es6-array.html)
**数组扁平化（又称数组降维）**
MET：flat（）方法会按照一个**可指定**的深度递归遍历数组，并将所有的元素与遍历出来的数组中的元素合并为一个**新数组**返回；
```javascript
var test = ['a', ['b', 'c'], ['d', ['e', ['f']], 'g']]
// flat不传参数时，默认扁平化一层
test.flat()
// ["a", "b", "c", "d", ["e", ["f"]], "g"]
// flat传入一个整数参数，整数即扁平化的层数
test.flat(2)
// ["a", "b", "c", "d", "e", ["f"], "g"]
// Infinity 关键字作为参数时，无论多少层嵌套，都会转为一维数组
test.flat(Infinity)
// ["a", "b", "c", "d", "e", "f", "g"]
// 传入 <=0 的整数将返回原数组，不扁平化
test.flat(0)
test.flat(-1)
// ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]
// 如果原数组有空位，flat()方法会跳过空位。
["a", "b", "c", "d",,].flat()
// ["a", "b", "c", "d"]
```
```javascript
Array.prototype.flat()总结：
- Array.prototype.flat()用于将前天的数组扁平化，称为一维数组。此方法返回一个新的数组，对元数据没有影响；
- 不传参数时，默认扁平化一层；传入一个整数时，这个整数代码表示想要扁平化的层数；
- 传入<=0的整数将不进行扁平化，返回原数组；
- Infinity关键字作为参数时，无论是多少层嵌套，都会转为一维数组；
- 如果原数组有空位，Array.prototype.flat()会跳过空位，进行转换；
```
**方法一：使用 reduce 方法**
```javascript
function flattenDeep(arr) {
return Array.isArray(arr)
? arr.reduce( (acc, cur) => [...acc, ...flattenDeep(cur)] , [])
: [arr]
}
// 测试
var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]
flattenDeep(test)
// ["a", "b", "c", "d", "e", "f", "g"]
```
**实现 flat 函数**
```javascript
function flat(arr, depth = 1) {
return depth > 0
? arr.reduce((acc, cur) => {
if(Array.isArray(cur)) {
return [...acc, ...flat(cur, depth-1)]
}
return [...acc, cur]
} , [])
: arr
}
// 测试
var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]
// 不传参数时，默认扁平化一层
flat(test)
// ["a", "b", "c", "d", ["e", ["f"]], "g"]
// 传入一个整数参数，整数即扁平化的层数
flat(test, 2)
// ["a", "b", "c", "d", "e", ["f"], "g"]
// Infinity 关键字作为参数时，无论多少层嵌套，都会转为一维数组
flat(test, Infinity)
// ["a", "b", "c", "d", "e", "f", "g"]
// 传入 <=0 的整数将返回原数组，不扁平化
flat(test, 0)
flat(test, -10)
// ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]];
// 如果原数组有空位，flat()方法会跳过空位。
var arr = ["a", "b", "c", "d",,]
flat(arr)
// ["a", "b", "c", "d"]
```
**方法二：栈**
```javascript
function flattenDeep(arr) {
const result = []
// 将数组元素拷贝至栈，直接赋值会改变原数组
const stack = [...arr]
// 如果栈不为空，则循环遍历
while (stack.length !== 0) {
const val = stack.pop()
if (Array.isArray(val)) {
// 如果是数组再次入栈，并且展开了一层
stack.push(...val)
} else {
// 如果不是数组，就用头插法插入到结果数组中
result.unshift(val)
}
}
return result
}
// 测试
var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]
// ["a", "b", "c", "d", "e", "f", "g"]
```
**数组去重**
**方式一：Set（ES6）**
```javascript
function unique(arr) {
return Array.from(new Set(arr))
}
// 或者
var unique = arr => [...new Set(arr)]
// 测试
var arr = [1, 2, 2, 3]
unique(arr); // [1, 2, 3]
```
**方式二：reduce**
```javascript
function unique(arr) {
return arr.filter( (element, index, array) => {
return array.indexOf(element) === index
})
}
// 测试
var arr = [1, 2, 2, 3]
unique(arr); // [1, 2, 3]
```
**方法三：filter**
```javascript
function unique(arr) {
return arr.filter( (element, index, array) => {
return array.indexOf(element) === index
})
}
// 测试
var arr = [1, 2, 2, 3]
unique(arr); // [1, 2, 3]
```