JavaScript 一些 Array 函数实现

JavaScript 一些 Array 函数实现 concatfindflatforEach & mapincludesjoinpoppushreducereverseshiftslicesomesortspliceunshift

只是一些比较简单的实现，这里按照字母排序了。

Github 链接：js impl

CSDN下载：csdn

concat

因为 concat 可以参数中可以接受多个数组，所以用了 rest operator 去接受多个数组。

const concat = (arr, arr2) => {
  const newArr = [...arr];
  for (let i = 0; i < arrs.length; i++) {
    const arr2 = arrs[i];
    for (let j = 0; j < arr2.length; j++) {
      push(newArr, arr2[j]);
    }
  }
  return newArr;
};

find

for (let i = 0; i < arr.length; i++) {
  const element = arr[i];
  if (cb(element)) return element;
}

return undefined;

flat

flat 是通过递归的方式完成，不过 flat 应该是需要修改原本的数组，那个在递归的 *** 作比较麻烦，这里就直接使用返回一个新的数组的方式了。

const flat = (arr, depth = 1) => {
  const newArr = [];
  for (let i = 0; i < arr.length; i++) {
    const element = arr[i];
    if (element instanceof Array && depth > 0) {
      push(newArr, ...flat(element, depth - 1));
    } else {
      push(newArr, element);
    }
  }

  return newArr;
};

forEach & map

在 JavaScript 的 foreach 用不了 break/continue？同样写法下 for 循环也不行 里面大致实现过了，这里就不继续了。

includes

indexOf, lastIndexOf 和 includes 的实现差不多，这里就不重新实现了。

const includes = (arr, val) => {
  for (let i = 0; i < arr.length; i++) {
    const element = arr[i];
    if (element == val) return true;
  }

  return false;
};

join

const join = (arr, separator = ",") => {
  let str = "";
  for (let i = 0; i < arr.length - 1; i++) {
    str += arr[i] + separator;
  }
  str += arr[arr.length - 1];
  return str;
};

pop

const pop = (arr) => {
  const popped = arr[arr.length - 1];
  arr.length--;
  return popped;
};

push

const push = (arr, ...values) => {
  for (let i = 0; i < values.length; i++) {
    arr[arr.length] = values[i];
  }
};

reduce

const reduce = (arr, reducer, initialValue) => {
  let accum = initialValue,
    counter = 0;
  if (!initialValue) {
    accum = arr[0];
    counter++;
  }
  for (let i = counter; i < arr.length; i++) {
    accum = reducer(accum, arr[i], i, arr);
  }

  return accum;
};

reverse

const reverse = (arr) => {
  for (let i = 0; i < arr.length / 2; i++) {
    [arr[i], arr[arr.length - i - 1]] = [arr[arr.length - 1 - i], arr[i]];
  }
};

shift

const shift = (arr) => {
  const shifted = arr[0];
  for (let i = 1; i < arr.length; i++) {
    arr[i - 1] = arr[i];
  }
  arr.length--;
  return shifted;
};

slice

slice 可以接受负值作为参数，这里对此也做了简单的处理。

const slice = (arr, start = 0, end = arr.length) => {
  const arrCopy = [];

  if (start < 0) start = arr.length + start;

  if (end < 0) end = arr.length + end;

  for (let i = start; i < end; i++) {
    push(arrCopy, arr[i]);
  }

  return arrCopy;
};

some

every 和 some 实现的方法也差不多，这里就不重新 cv 了。

const some = (arr, cb) => {
  for (let i = 0; i < arr.length; i++) {
    if (cb(arr[i], i, arr)) return true;
  }

  return false;
};

sort

sort 原生排序实现根据 runtime 和数组类型不同而有差异，这里就是用最基础的冒泡排序了。

function swap(arr, i, j) {
  [arr[i], arr[j]] = [arr[j], arr[i]];
}

function bubbleSort(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 1; j < arr.length - i; j++) {
      if (arr[j - 1] > arr[j]) {
        swap(arr, j, j - 1);
      }
    }
  }
}

const sort = (arr, comparator = bubbleSort) => {
  comparator(arr);
};

splice

splice 也是一个相对而言比较复杂的方法了，大概实现内容如下：

const subArr = (arr, start, end = arr.length) => {
  const subArray = [];
  for (let i = start; i < end; i++) {
    subArray.push(arr[i]);
  }

  return subArray;
};

const splice = (arr, start = 0, deleteCount = 0, ...items) => {
  let subArray = null;

  const deleted = [];

  if (items.length > 0 || deleteCount > 0) {
    subArray = subArr(arr, start);
    arr.length -= arr.length - start;
  }

  while (deleteCount > 0) {
    push(deleted, shift(subArray));
    deleteCount--;
  }

  if (items.length > 0) {
    for (let i = 0; i < items.length; i++) {
      push(arr, items[i]);
    }
  }

  if (subArray && subArray.length > 0) {
    for (let i = 0; i < subArray.length; i++) {
      push(arr, subArray[i]);
    }
  }

  return deleted;
};

实现思路就是截取一个 sub array，如果需要删除的话，直接 shift(移除 sub array 头部的内容)，随后将 items 和 sub array 中的内容加回原数组即可——splice 会修改原数组。

unshift

const unshift = (arr, val) => {
  for (let i = arr.length; i > 0; i--) {
    arr[i] = arr[i - 1];
  }
  arr[0] = val;
};