1. 数组去重

let arr = [
  false,
  false,
  undefined,
  undefined,
  null,
  null,
  NaN,
  NaN,
  1,
  "1",
  {},
  {},
  "a",
  "a"
];

1-1、利用 ES6 Set 集合成员具有唯一值的特性

let res = Array.from(new Set(arr));

1-2、利用数组的 indexOf 方法和 ES5 数组的 filter 方法

Array.prototype.uniq = function() {
  let flag = true;
  return this.filter((ele, index, array) => {
    if (flag && ele !== ele) {
      flag = false;
      return true;
    }
    return index === array.indexOf(ele);
  });
};

1-3、利用对象的键值对(有缺陷，由于普通的对象的键为字符串，所以不能正确过滤数字 1 和字符串 1，以及引用类型等)

Array.prototype.uniq_second = function() {
  let hash = {};
  let data = [];
  this.forEach(ele => {
    if (!hash[ele]) {
      hash[ele] = true;
      data.push(ele);
    }
  });
  return data;
};

// 基于3的优化方案：在对象键值对的基础上改用map集合存储，解决普通对象存储的缺陷
Array.prototype.uniq_third = function() {
  let map = new Map();
  let data = [];
  this.forEach(ele => {
    if (!map.get(ele)) {
      map.set(ele, true);
      data.push(ele);
    }
  });
  return data;
};

1-4、利用数组排序后，比较相邻元素的方法

// Object.is() 可以用 === 来替换，但是需要注意NaN，Object.is()与严格比较运算符（===）的行为基本一致。不同之处只有两个：一是+0不等于-0，二是NaN等于自身。
// 根据如下方案，数组最后一个元素必然是唯一值，所以在循环后把末尾的元素添加进去
Array.prototype.uniq = function() {
  let res = [];
  let arr = this.sort();
  for (let i = 0; i < arr.length - 2; i++) {
    if (!Object.is(arr[i], arr[i + 1])) {
      res.push(arr[i]);
    }
  }
  res.push(arr.pop());
  return res;
};

2. 如何判断一个空对象

var data = {};

var b = JSON.stringify(data) == "{}";

var c = function() {
  for (var key in data) {
    return false;
  }
  return true;
};

var d = function(obj) {
  return Object.keys(obj).length === 0;
}
console.log(b); //true
console.log(c()); //true
console.log(d(data)); //true

3. 生成概率相等的随机数

// 1、生成 [n,m)，包含n但不包含m的正整数：
parseInt(Math.random() * (m - n) + n);
// 2、生成(n,m]，不包含n但包含m的正整数：
parseInt(Math.random() * (m - n) + n) + 1;
// 3、生成[n,m]，包含n和m的随机数：
parseInt(Math.random() * (m - n + 1) + n);
// 4、生成 (n,m)，不包含n和m的正整数：
parseInt(Math.random() * (m - n - 1) + n + 1);

4. 数组对象(Array(Object))去重

let person = [
  { id: 0, name: "小明" },
  { id: 1, name: "小张" },
  { id: 2, name: "小李" },
  { id: 3, name: "小孙" },
  { id: 1, name: "小周" },
  { id: 2, name: "小陈" }
];

let obj = {};

person = person.reduce((cur, next) => {
  obj[next.id] ? "" : (obj[next.id] = true && cur.push(next));
  return cur;
}, []); //设置cur默认类型为数组，并且初始值为空的数组
log(person);

5. 查找某个字符在字符串中出现的次数

var url = "http://localhost:8080/#/dmpManage/dataAccess";
url.match(new RegExp("/", "g")).length;
url.split("/").length - 1;

6. 获取数组最后一个元素的方法

let arr = [3, 5, 7];
let method1 = arr.pop(); // 修改原数组
let method2 = arr.splice(-1); // 修改原数组
let method3 = arr.slice(-1); // 不修改原数组
let method4 = arr[arr.length - 1]; // 不修改原数组

7. 检查数组某个数值出现的次数

const countOccurrences = (arr, val) =>
  arr.reduce((a, v) => (v === val ? a + 1 : a), 0);
countOccurrences([1, 1, 2, 1, 2, 3], 1); // 3

8. 购物车金额的计算

对于购物车，存放的类型一般都是 Array(Object)

const shopCart = [
  { name: "Uncle Bobby", price: 500 },
  { name: "Suzie Q", price: 1500 },
  { name: "Jimmy Gosling", price: 150 },
  { name: "Gracie Hopper", price: 1000 }
];

在需要计算价格总额的时候，我们一般会这样做，以下这样的代码不推荐，更加推荐函数式编程

// bad
let totalPrice = 0;

for (let i = 0; i < shopCart.length; i++) {
  totalPrice += shopCart[i].price;
}

// good
const INIT_VALUE = 0; // 初始价格
let totalPrice = shopCart
  .map(item => item.price)
  .reduce((total, item) => total + item, INIT_VALUE);

9. 购物车批量删除商品

const shopCart = [
    { id: 1, name: 'Uncle Bobby', price: 500 },
    { id: 2, name: 'Suzie Q', price: 1500 },
    { id: 3, name: 'Jimmy Gosling', price: 150 },
    { id: 4, name: 'Gracie Hopper', price: 1000 }
]
idArr = [2, 3] // 删除id为2和3

deleteGood(idArr) {
    shopCart.filter((item, index) => {
    	return !idArr.inculde(item.id)
    })
}

10. ES6 for in 循环 获取索引

for (let [index, item] of arr.entries()) {
}

11. 数组遍历获取指定键拼装成数组(利用 reduce)

const data = [
  {
    day_time: "2019-10-16",
    value: "1.08"
  },
  {
    day_time: "2019-10-17",
    value: "19.35"
  }
];

const dayTimeData = value.reduce((cur, next) => {
  cur.push(next.day_time);
  return cur;
}, []);

12-1. 数组取并集

/**
 * 数组并集,只支持一维数组
 * @param {Array} arrOne
 * @param {Array} arrTwo
 */
export const arrAndSet = (arrOne, arrTwo) => {
  return arrOne.concat(arrTwo.filter(v => !arrOne.includes(v)));
};

12-2.数组取交集

/**
 * 数组交集,只支持一维数组
 * @param {Array} arrOne
 * @param {Array} arrTwo
 */
export const arrIntersection = (arrOne, arrTwo) => {
  return arrOne.filter(v => arrTwo.includes(v));
};

12-3.数组取差集

/**
 * 数组差集,只支持一维数组
 * @param {Array} arrOne
 * @param {Array} arrTwo
 * eg: [1, 2, 3] [2, 4, 5] 差集为[1,3,4,5]
 */
export const arrDifference = (arrOne, arrTwo) => {
  return arrOne
    .concat(arrTwo)
    .filter(v => !arrOne.includes(v) || !arrTwo.includes(v));
};