手写 ​

Array.prototype.myForEach = function (callback) {
  for (let i = 0; i < this.length; i++) {
    callback(this[i], i, this);
  }
};

Array.prototype.myMap = function (callback) {
  const res = [];
  for (let i = 0; i < this.length; i++) {
    res.push(callback(this[i], i, this));
  }
  return res;
};

Array.prototype.myFilter = function (callback) {
  const res = [];
  for (let i = 0; i < this.length; i++) {
    callback(this[i], i, this) && res.push(this[i]);
  }
  return res;
};

Array.prototype.mySome = function (callback) {
  for (let i = 0; i < this.length; i++) {
    const ok = callback(this[i], i, this);
    if (ok) {
      return true;
    }
  }
  return false;
};

Array.prototype.myEvery = function (callback) {
  for (let i = 0; i < this.length; i++) {
    const ok = callback(this[i], i, this);
    if (!ok) {
      return false;
    }
  }
  return true;
};

Array.prototype.myReduce = function (callback, ...args) {
  let start = 0;
  let res = 0;
  if (args.length) {
    res = args[0];
  } else {
    start = 1;
    res = this[0];
  }
  for (let i = start; i < this.length; i++) {
    res = callback(res, this[i], i, this);
  }
  return res;
};

Array.prototype.myFindIndex = function (callback) {
  for (let i = 0; i < this.length; i++) {
    let ok = callback(this[i], i, this);
    if (ok) {
      return i;
    }
  }
  return -1;
};

Array.prototype.myIncludes = function (target, fromIndex = 0) {
  if (fromIndex < 0) {
    fromIndex += this.length;
  }
  for (let i = fromIndex; i < this.length; i++) {
    if (
      target === this[i] ||
      (Number.isNaN(target) && Number.isNaN(this[i]))
    ) {
      return true;
    }
  }
  return false;
};

function myFlat(arr) {
  return arr.reduce(
    (prev, cur) => prev.concat(Array.isArray(cur) ? myFlat(cur) : cur),
    []
  );
}

function myFlat(arr) {
  return arr.toString().split(",").map(Number);
}

function myFlat(arr) {
  while (arr.some((item) => Array.isArray(item))) {
    arr = [].concat(...arr);
  }
  return arr;
}

const arr = [1, 1, "1", "1", NaN, NaN, {}, {}, true, true];

function myUnique(arr) {
  return Array.from(new Set(arr)); // [1, '1', NaN, {}, {}, true]
}

function myUnique(arr) {
  const res = [];
  for (const x of arr) {
    if (res.indexOf(x) === -1) {
      res.push(x);
    }
  }
  return res; // [1, '1', NaN, NaN, {}, {}, true]
}

function myUnique(arr) {
  const res = [];
  for (const x of arr) {
    if (!res.includes(x)) {
      res.push(x);
    }
  }
  return res; // [1, '1', NaN, {}, {}, true]
}

function myUnique(arr) {
  return arr.reduce(
    (prev, cur) => (prev.includes(cur) ? prev : [...prev, cur]),
    []
  );
}

function myUnique(arr) {
  const obj = {};
  // typeof item + item 解决 '1' 和 1 无法去重问题
  return arr.filter((item) =>
    Object.hasOwn(obj, typeof item + item)
      ? false
      : (obj[typeof item + item] = true)
  );
}