半山烟雨的博客

Appearance

将[ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10]做扁平化处理并最终得到一个升序的不重复数组 ​

查看详情
javascript
const arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10]

// 1
Array.from(new Set(arr.flat(Infinity))).sort((a, b) => a - b)

// 2
Array.from(new Set(arr.toString().split(",").map(Number))).sort((a, b) => a - b)

// 3
[...(new Set(arr.flat(Infinity)))].sort((a, b) => a - b)

将数组[5,1,3,4,2]按升序排列 ​

查看详情
javascript
const arr = [5, 1, 3, 4, 2];
// 轮数
for (let i = 0; i < arr.length - 1; i++) {
  // 次数
  for (let j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] > arr[j + 1]) {
      [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
    }
  }
}

实现数组的 reverse 方法 ​

查看详情
javascript
function reverse(arr) {
  const len = arr.length;
  const middleItemIndex = Math.floor(arr.length / 2);
  for (let i = 0; i < middleItemIndex; i++) {
    [arr[i], arr[len - 1 - i]] = [arr[len - 1 - i], arr[i]];
  }
  return arr;
}

将字符串'12345'反转 ​

查看详情
javascript
const str = '12345';
const str1 = [...str].reverse().join('');

有一个数组，取出里边能组成三角形最长的三根 ​

查看详情
javascript
function longestTrianglePerimeter(arr) {
  // 降序排序
  arr.sort((a, b) => b - a);

  // 查找能组成三角形的最长周长的三根边
  for (let i = 0; i < arr.length - 2; i++) {
    if (arr[i] < arr[i + 1] + arr[i + 2]) {
      // 找到能组成三角形的边
      return [arr[i], arr[i + 1], arr[i + 2]];
    }
  }

  // 如果没有找到能组成三角形的边，返回一个空数组
  return [];
}

递归求斐波那契数列的第 n 项 ​

查看详情
javascript
function fibonacci(n, memo = {}) {
  // 检查是否在记忆表中
  if (memo[n] !== undefined) {
    return memo[n];
  }

  // 基本情况
  if (n === 0) {
    return 0;
  } else if (n === 1) {
    return 1;
  } else {
    // 递归情况并存储结果到记忆表中
    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
    return memo[n];
  }
}

获取100以内的质数 ​

查看详情
javascript
function getPrimes(limit = 100) {
  const arr = [];

  for (let i = 2; i <= limit; i++) {
    let isPrimes = true;

    for (let j = 2; j * j <= i; j++) {
      if (i % j === 0) {
        isPrimes = false;
        break;
      }
    }

    if (isPrimes) arr.push(i);
  }

  return arr;
}

数组随机排序 ​

查看详情
javascript
// 1
function randomSort(arr) {
  for (let i = arr.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1)); // 0 ~ i 随机整数
      [arr[i], arr[j]] = [arr[j], arr[i]]; // 交换
  }
  return arr;
}

// 2
function randomSort(arr) {
  arr.sort(() => Math.random() - 0.5);

  return arr;
}

数据排序 ​

查看详情
  • sort
javascript
// 升序
[5, 4, 9, 2, 7, 3, 1]
  .sort((a, b) => a - b)

// 降序
[5, 4, 9, 2, 7, 3, 1].sort((a, b) => b - a);
  • 冒泡排序
javascript
// 升序
function bubbleSort(data) {
  var temp = 0;
  for (var i = data.length; i > 0; i--) {
    for (var j = 0; j < i - 1; j++) {
      // 降序改为小于号
      if (data[j] > data[j + 1]) {
        temp = data[j];
        data[j] = data[j + 1];
        data[j + 1] = temp;
      }
    }
  }
  return data;
}

如何自定义实现一个unshift方法 ​

查看详情
javascript
Array.prototype.myUnshift = function () {
  const length = arguments.length;

  for (let i = length - 1; i >= 0; i--) {
    const element = arguments[i];

    this.splice(0, 0, element);
  }

  return this.length;
}

如何实现一个数组去重方法 ​

查看详情
javascript
function deepEqual(a, b) {
  if (a === b) {
    return true;
  }

  if (typeof a !== typeof b) {
    return false;
  }

  if (a === null || b === null) {
    return a === b;
  }

  // 判断NaN
  if (typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b)) {
    return true;
  }

  // 判断数组
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) {
      return false;
    }

    return a.every((val, i) => deepEqual(val, b[i]));
  }

  // 判断对象
  if (typeof a === 'object' && typeof b === 'object') {
    const aKeys = Object.keys(a);
    const bKeys = Object.keys(b);

    if (aKeys.length !== bKeys.length) {
      return false;
    }

    return aKeys.every((key, i) => {
      if (key === bKeys[i]) {
        return deepEqual(a[key], b[key]);
      } else {
        return false;
      }
    });
  }

  return false;
}

Array.prototype.myUnique = function () {
  const arr = [];
  const len = this.length;

  for (let i = 0; i <= len - 1; i++) {
    if (!arr.some((existing) => deepEqual(existing, this[i]))) {
      arr.push(this[i]);
    }
  }

  return arr;
};

获取指定范围内的随机数 ​

查看详情
javascript
function fn(min, max) {
  if (min >= max) return;
  
  // (min, max)
  // return Math.round(Math.random() * (max - min - 2) + min + 1);
  
  // [min, max]
  // return Math.round(Math.random() * (max - min) + min);
  
  // (min, max]
  // return Math.ceil(Math.random() * (max - min) + min);
  
  // [min, max)
  // return Math.floor(Math.random() * (max - min) + min);
}

获取URL中的参数并返回一个由参数组成的数组 ​

查看详情
javascript
function getURLSearchParams(url) {
  const params = {};
  const [base] = url.split('#');
  const searchString = base.split('?')[1];
  if (!searchString) return;

  searchString.split('&').forEach((param) => {
    const [key, value] = param.split('=');

    params[decodeURIComponent(key)] = decodeURIComponent(value);
  });

  return params;
}

实现flatten方法 ​

查看详情
javascript
const list = [1,2,[3,4,[5,6], 7], [8]];
// 1
function flatten(arr) {
  while(arr.some((item) => Array.isArray(item))) {
    arr = [].concat(...arr);
  }

  return arr;
}

// 2
function flatten(arr) {
  return [].concat(...arr.map(item => Array.isArray(item) ? flatten(item) : item));
}

// 3
function flatten(arr) {
  return arr.flat(Infinity)
}

// 4（推荐）
function flattenModern(arr) {
  const stack = [...arr]; // 克隆数组，避免修改原数组
  const result = [];

  while (stack.length) {
      const item = stack.pop(); // 取最后一个元素
      if (Array.isArray(item)) {
          stack.push(...item); // 压栈展开
      } else {
          result.push(item);
      }
  }

  return result.reverse(); // 栈是后进先出，需要反转
}

两数之和 ​

查看详情
javascript
function fn(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    const targetIndex = arr.indexOf(target - arr[i]);

    if (targetIndex > -1) {
      return [i, targetIndex]
    }
  }
}