用数学思维写出更好的JavaScript代码

很多程序员觉得数学和编程关系不大，但实际上，数学思想能帮助我们写出更清晰、更高效的代码。下面来看看怎么用数学思维改善JavaScript编程。

1. 集合论：处理数据集合

数学中的集合是不重复元素的组合。在JavaScript里，我们可以用Set对象来实现集合操作。

比如删除数组中的重复项：

const numbers = [1, 2, 2, 3, 4, 4, 5];
const unique = [...new Set(numbers)];
console.log(unique); // [1, 2, 3, 4, 5]

还可以进行集合运算：

const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);

// 求交集
const intersection = [...setA].filter(x => setB.has(x));
console.log(intersection); // [3]

// 求并集
const union = new Set([...setA, ...setB]);
console.log([...union]); // [1, 2, 3, 4, 5]

// 求差集
const difference = [...setA].filter(x => !setB.has(x));
console.log(difference); // [1, 2]

用集合思维处理数据，代码会更简洁，逻辑也更清楚。

2. 布尔逻辑：简化条件判断

每个if语句都涉及布尔运算。用好布尔逻辑能让代码更易读。

不好的写法：

if (isLoggedIn === true && hasPaid === true) {
  access = true;
} else {
  access = false;
}

好的写法：

const access = isLoggedIn && hasPaid;

再比如处理多个条件：

// 复杂的判断
if ((role === 'admin' || role === 'editor') && isActive) {
  // 执行操作
}

// 可以改成
const canEdit = (role === 'admin' || role === 'editor') && isActive;
if (canEdit) {
  // 执行操作
}

3. 递归：解决分层问题

递归在数学中很常见，在编程里也很实用。

计算阶乘：

const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);
console.log(factorial(5)); // 120

处理嵌套数组：

// 展开多层嵌套的数组
const flatten = arr => 
  arr.reduce((result, item) => 
    Array.isArray(item) ? 
    result.concat(flatten(item)) : 
    result.concat(item), 
  []);

console.log(flatten([1, [2, [3, [4]]]])); // [1, 2, 3, 4]

遍历树形结构：

const tree = {
  value: 1,
  children: [
    {
      value: 2,
      children: [
        { value: 3, children: [] }
      ]
    },
    { value: 4, children: [] }
  ]
};

function traverse(node) {
  console.log(node.value);
  node.children.forEach(child => traverse(child));
}

traverse(tree); // 1, 2, 3, 4

4. 图论：处理连接关系

现代应用充满各种关系：社交网络的朋友关系、网页链接、模块依赖等。

深度优先搜索：

const graph = {
  'A': ['B', 'C'],
  'B': ['D'],
  'C': ['E'],
  'D': ['F'],
  'E': [],
  'F': []
};

function dfs(startNode) {
  const visited = new Set();
  const stack = [startNode];
  
  while (stack.length > 0) {
    const node = stack.pop();
    if (!visited.has(node)) {
      console.log(node);
      visited.add(node);
      // 将邻居节点加入栈中
      graph[node].forEach(neighbor => {
        if (!visited.has(neighbor)) {
          stack.push(neighbor);
        }
      });
    }
  }
}

dfs('A'); // A, C, E, B, D, F

5. 概率：处理随机性

游戏、测试、负载均衡都需要随机性。

加权随机选择：

function weightedRandom(choices) {
  const totalWeight = Object.values(choices).reduce((sum, weight) => sum + weight, 0);
  let random = Math.random() * totalWeight;
  
  for (const [item, weight] of Object.entries(choices)) {
    random -= weight;
    if (random <= 0) {
      return item;
    }
  }
}

// 苹果概率30%，香蕉10%，樱桃60%
console.log(weightedRandom({ apple: 3, banana: 1, cherry: 6 }));

随机抽样：

function randomSample(array, count) {
  const shuffled = [...array];
  for (let i = shuffled.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
  }
  return shuffled.slice(0, count);
}

console.log(randomSample([1, 2, 3, 4, 5, 6, 7, 8], 3));

6. 复杂度分析：理解性能

了解算法复杂度能帮助我们选择更好的解决方案。

不同数据结构的查找效率：

const arr = [1, 2, 3, 4, 5];
const set = new Set([1, 2, 3, 4, 5]);
const map = new Map([['a', 1], ['b', 2], ['c', 3]]);

// 数组查找 - O(n)
console.log(arr.includes(5));

// Set查找 - O(1)
console.log(set.has(5));

// Map查找 - O(1)
console.log(map.has('a'));

选择合适的数据结构很重要：

// 需要频繁查找时，用Set或Map
function findDuplicates(arr) {
  const seen = new Set();
  const duplicates = new Set();
  
  arr.forEach(item => {
    if (seen.has(item)) {
      duplicates.add(item);
    } else {
      seen.add(item);
    }
  });
  
  return [...duplicates];
}

7. 函数组合：构建复杂功能

把小函数组合成复杂功能，就像搭积木一样。

基础组合：

const add = x => x + 2;
const multiply = x => x * 3;
const square = x => x * x;

// 组合函数
const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);

const complexOperation = compose(square, multiply, add);
console.log(complexOperation(3)); // ((3 + 2) * 3) ^ 2 = 225

管道操作：

const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);

const processData = pipe(
  x => x * 2,
  x => x + 1,
  x => x * x
);

console.log(processData(3)); // ((3*2)+1)^2 = 49

实际应用建议

开始可以用这些简单的方法：

用Set处理去重问题
用布尔变量简化复杂条件
用递归处理嵌套数据
了解常用数据结构的性能特点

慢慢培养数学思维，你会发现写代码时思路更清晰，解决问题的办法也更多。数学不是要我们记住复杂公式，而是学会结构化思考问题的方法。这种思维方式对编程很有帮助，能让代码质量明显提升。

本文内容仅供个人学习/研究/参考使用，不构成任何决策建议或专业指导。分享/转载时请标明原文来源，同时请勿将内容用于商业售卖、虚假宣传等非学习用途哦～感谢您的理解与支持！

链接: https://fly63.com/article/detial/13106