• 去重操作，无序状态，效率最高
• @param target
• @returns {Array}
  */
  function unique1(target) {
  let obj = {};
  for (let i = 0,n = target.length; i < n;i++) {
  obj[target[i]] = true;
  }
  return Object.keys(obj);
  }

/**

• ES6写法,有序状态
• @param target
• @returns {Array}
  */
  function unique2(target) {
  return Array.from(new Set(target));
  }

function unique3(target) {
return [...new Set(target)];
}

• 返回数组中的最大值，用于数字数组
• @param target
• @returns {}
  /
  function max(target) {
  return Math.max.apply(0,target);
  }

/**

• 从数组中随机抽选一个元素出来
• @param target
• @returns {}
  /
  function random(target) {
  return target[Math.floor(Math.random() * target.length)];
  }

/**

• 移除数组中第一个匹配传参的那个元素，返回布尔表示成功与否
• @param target
• @param item
• @returns {boolean}
  */
  function remove(target,item) {
  const index = target.indexOf(item);
  if (~index) {
  return removeAt(target,index);
  }
  return false;
  }

/**

• 对数组进行洗牌

• @param array

• @returns {array}
  /
  function shuffle(array) {
  let m = array.length,t,i;
  // While there remain elements to shuffle…
  while (m) {
  // Pick a remaining element…
  i = Math.floor(Math.random() m--);

  // And swap it with the current element.
  t = array[m];
  array[m] = array[i];
  array[i] = t;
  }
  return array;
  }

/**

• 对数组进行平坦化处理，返回一个一维的新数组
• @param target
• @returns {Array}
  */
  function flatten (target) {
  let result = [];
  target.forEach(function(item) {
  if(Array.isArray(item)) {
  result = result.concat(flatten(item));
  } else {
  result.push(item);
  }
  });
  return result;
  }

/**

• 过滤属性中的null和undefined,但不影响原数组
• @param target
• @returns {Array.|}
  /
  function compat(target) {
  return target.filter(function(el) {
  return el != null;
  })
  }

// 例子
function iterator(value) {
if (value > 10) {
return 'a';
} else if (value > 5) {
return 'b';
}
return 'c';
}
var target = [6,2,3,4,5,65,7,6,8,34,8];
console.log(groupBy(target,iterator));

/**

• 获取对象数组的每个元素的指定属性，组成数组返回
• @param target
• @param name
• @returns {Array}
  */
  function pluck(target,name) {
  let result = [],prop;
  target.forEach(function(item) {
  prop = item[name];
  if (prop != null) {
  result.push(prop);
  }
  });
  return result;
  }

/**

• 根据指定条件进行排序，通常用于对象数组
• @param target
• @param fn
• @param scope
• @returns {Array}
  */
  function sortBy(target,fn,scope) {
  let array = target.map(function(item,index) {
  return {
  el: item,re: fn.call(scope,item,index)
  };
  }).sort(function(left,right) {
  let a = left.re,b = right.re;
  return a < b ? -1 : a > b ? 1 : 0;
  });
  return pluck(array,'el');
  }

/**

• ES6的并集
• @param target
• @param array
• @returns {Array}
  */
  function union1(target,array) {
  return Array.from(new Set([...target,...array]));
  }

/**

• 对两个数组取交集
• @param target
• @param array
• @returns {Array.|}
  /
  function intersect(target,array) {
  return target.filter(function(n) {
  return ~array.indexOf(n);
  })
  }

/**

• ES6 交集
• @param target
• @param array
• @returns {Array}
  */
  function intersect1(target,array) {
  array = new Set(array);
  return Array.from(new Set([...target].filter(value => array.has(value))));
  }

/**

• 差集
• @param target
• @param array
• @returns {ArrayBuffer|Blob|Array.|string}
  */
  function diff(target,array) {
  var result = target.slice();
  for (var i = 0;i < result.length;i++) {
  for (var j = 0; j < array.length;j++) {
  if (result[i] === array[j]) {
  result.splice(i,1);
  i--;
  break;
  }
  }
  }
  return result;
  }

/**

• ES6 差集
• @param target
• @param array
• @returns {Array}
  */
  function diff1(target,array) {
  array = new Set(array);
  return Array.from(new Set([...target].filter(value => !array.has(value))));
  }