常用的数组和字符串 方法

// 借用Object原型上的toString方法
function type(parameter) {
  //call 修改this的指向
  return Object.prototype.toString.call(parameter)
}

//使用set数据去重  set里面不能存在同样的值
function unique1(arr) {
  return [...new Set(arr)]
}

//使用对象方式，filter会过滤出返回true的元素。
function unique2(arr) {
  var obj = {}
  return arr.filter(ele => {
    if (!obj[ele]) {//如果是第一次则设置为true 并且返回
      obj[ele] = true
      return obj[ele]
    }
  })
}

//通过indexOf 返回元素的下标
function unique3(arr) {
  var result = []
  arr.forEach(element => {
    if (result.indexOf(element) == -1) {
      result.push(element)
    }
  });
  return result
}

//字符去重  同样使用对象的方式
String.prototype.unique = function () {
  var obj = {},
    str = '',
    //this 调用者 字符串
    len = this.length;
  for (var i = 0; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = true
      str += this[i]
    }
  }
  return str;
}
//字符串去重
function uniq(str) {
  return str.replace(/(\w)\1+/g, '$1')
}

常用的数组方法

var brr = [1, 5, 7, 9, 8]
//封装forEach
Array.prototype.myForEach = function (func, obj) {
  var len = this.length;
  var _this = arguments[1] ? arguments[1] : window;
  for (var i = 0; i < len; i++) {
    func.call(_this, this[i], i, this)
  }
}
// brr.myForEach((ele, index, aa) => {
//   console.log(ele, index, aa)
// }, brr)


Array.prototype.myFilter = function (func, obj) {
  var len = this.length;
  var arr = [];
  var _this = arguments[1] || window
  for (var i = 0; i < len; i++) {
    func.call(_this, this[i], i, this) && arr.push(this[i])
  }
  return arr
}
// var arr = brr.myFilter((ele) => {
//   return ele == 9
// }, brr)


Array.prototype.myMap = function (func) {
  var arr = [];
  var len = this.length;
  var _this = arguments[1] || window;

  for (var i = 0; i < len; i++) {
    arr.push(func.call(_this, this[i], i, this));
  }
  return arr;
}

//一个返回false 则全部为false
Array.prototype.myEvery = function (func) {
  var flag = true;
  var len = this.length;
  var _this = arguments[1] || window;
  for (var i = 0; i < len; i++) {
    if (func.apply(_this, [this[i], i, this]) == false) {
      flag = false;
      break;
    }
  }
  return flag
}

//数组reduce方法
Array.prototype.myReduce = function (func, initialValue) {
  var len = this.length,
    nextValue,
    i;
  if (!initialValue) { // 没有传第二个参数
    initialValue = this[0];
    i = 1
  } else { // 传第二个参数
    nextValue = initialValue;
    i = 0
  }
  for (; i < len; i++) {
    nextValue = func(nextValue, this[i], i, this);
  }
  return nextValue;
}

//深拷贝
function deepClone(obj, result) {
  var result = result || {};
  for (var prop in obj) {
    //hasOwnProperty方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。
    if (obj.hasOwnProperty(prop)) {
      if (typeof obj[prop] == 'object' && obj[prop] !== null) {
        //检查对象类型
        if (Object.prototype.toString.call(obj[prop]) == '[object Object]') {
          result[prop] = {} //对象
        } else {
          result[prop] = [] //数组
        }
      }
      deepClone(obj[prop], result[prop])
    } else {
      result[prop] = obj[prop]
    }
  }
  return result
}

//浅拷贝
function deepClone2(target) {
  if (typeof (target) == 'object') {
    return target
  }
  var result;
  if (Object.prototype.toString.call(target) == '[object Array]') {
    result = []
  } else {
    result = {}
  }

  for (var prop in target) {
    if (target.hasOwnProperty(prop)) {
      result[prop] = deepClone2(target[porp])
    }
  }
  return result
}