数组方法简化与透彻理解的最优方案，及掌握数组运算（加减乘除合并数组）问题解决技巧的最简路径

Great questions—let’s break this down clearly, since array methods are such a foundational part of JavaScript (and most programming languages) but can feel overwhelming at first.

The key here is to move beyond memorization and build intuitive knowledge:

• Group methods by what they do, not their names: Stop trying to cram every method into your head at once. Cluster them by purpose instead:
  • Add/remove elements: push(), pop(), unshift(), shift(), splice()
  • Transform/filter data: map(), filter(), flatMap()
  • Aggregate values: reduce(), every(), some()
  • Search/locate items: indexOf(), find(), includes()
    This way, when you face a problem, you think "what do I need to accomplish?" instead of "what method name do I remember?"
• Write your own simplified versions: There’s no better way to understand how a method works than to build a mini version of it. For example, here’s a basic take on map():

  function myMap(arr, callback) {
    const result = [];
    for (let i = 0; i < arr.length; i++) {
      result.push(callback(arr[i], i, arr));
    }
    return result;
  }
  

  Writing this forces you to grasp the input, iteration logic, and output—way more effective than just reading documentation.
• Bind methods to real-world scenarios: Practice with relatable examples instead of random numbers. For instance:
  • Use filter() to pull all active users from a user database array.
  • Use map() to convert an array of product objects into just their price values.
    Associating methods with actual problems makes them stick far better.
• Avoid overcomplicating: Don’t reach for reduce() just because it’s "powerful"—if forEach() or map() solves the problem more clearly, use that. Clarity beats cleverness every time.

Let’s split this into two parts: the simplest mastery path, and the math-based merging techniques you asked about.

The Simplest Mastery Path #

• Start with core methods first: Nail down the 8-10 most frequently used methods first: push, pop, map, filter, reduce, concat, includes, find. These cover 90% of everyday array tasks.
• Solve small, targeted problems: Skip the hard LeetCode problems at first. Start with basics like:
  • Merging two arrays.
  • Removing duplicates from an array.
  • Doubling every number in an array.
    After solving each, ask: "Could I have used a different method to make this cleaner?"
• Learn to spot patterns: After a handful of problems, you’ll start noticing repeating patterns:
  • Need to convert every element? Use map().
  • Need to keep only specific elements? Use filter().
  • Need to combine all elements into one value? Use reduce().
    These patterns become second nature with practice.
• Review and refactor: Go back to old solutions and see if you can make them shorter or more readable. For example, replacing a verbose forEach() with a concise reduce() if it tightens the logic.

Merging Arrays Using Addition/Subtraction/Multiplication/Division #

Note: These are clever tricks (not always the most readable or efficient) since standard methods like [...arr1, ...arr2] or arr1.concat(arr2) are usually better. But here’s how to use math operations for this:

Addition (+) #

Arrays get converted to strings when using the + operator, so we can leverage that to merge:

const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];

// Merge and convert back to numbers (works for numeric arrays)
const merged = (arr1 + arr2).split(',').map(Number);
// Result: [1, 2, 3, 4, 5, 6]

If your array has strings, skip the map(Number) step—but be careful if elements contain commas (this will break the split).

Subtraction (-) #

Subtraction doesn’t directly merge arrays, but you can use it to create a merged array with unique elements (a union):

const arr1 = [1, 2, 3];
const arr2 = [3, 4, 5];

// Merge and remove duplicates
const mergedUnique = arr1.concat(arr2.filter(item => !(arr1.includes(item) - 0)));
// Result: [1, 2, 3, 4, 5]

Here, arr1.includes(item) - 0 converts the boolean result to 0 or 1—so we filter out items already present in arr1.

Multiplication (*) #

Use multiplication to ensure elements are numeric before merging (useful for mixed-type arrays):

const arr1 = ['1', 2, '3'];
const arr2 = [4, '5', 6];

// Convert to numbers and merge
const mergedNumeric = arr1.map(x => x * 1).concat(arr2.map(x => x * 1));
// Result: [1, 2, 3, 4, 5, 6]

Multiplying by 1 forces string numbers to become actual numbers, making the merged array consistent in type.

Division (/) #

Similar to multiplication, division can normalize elements to numbers before merging:

const arr1 = ['10', 20, '30'];
const arr2 = [40, '50', 60];

// Convert to numbers and merge
const merged = arr1.map(x => x / 1).concat(arr2.map(x => x / 1));
// Result: [10, 20, 30, 40, 50, 60]

Dividing by 1 works the same as multiplying by 1 for type conversion—it’s just another way to achieve the same goal.

内容的提问来源于stack exchange，提问作者Ben Win