_.merge array-index merging in lodash 4.17.x and object-assignment compatibility boundary

In Lodash 4.17.x, _.merge performs index-based merging for arrays by default. This means that when two arrays exist at the same path, Lodash iterates through the source array and overwrites the destination array elements at the corresponding numeric indices.

Array Merging Behavior

Array index merging is the documented default. It does not preserve the destination array length as a constant; instead, it behaves as follows:

• Source is shorter: Destination elements beyond the source's length remain untouched.
• Source is longer: The destination array is extended to match the source's length.
• Sparse results: If the source array contains holes (sparse indices), the corresponding indices in the destination array are preserved, which can lead to unexpected mixed-state arrays.

Inherited Properties and Prototype Boundary

Unlike Object.assign, which only copies own enumerable properties, _.merge recursively merges both own and inherited enumerable string-keyed properties. If your configuration objects are prototype-based, any enumerable property on the prototype chain of a source object will be merged into the destination. This creates a significant compatibility boundary if you expect the behavior of standard object assignment.

Preserving Array Atomicity

To move from index-based merging to array atomicity (where a source array completely replaces a destination array), you must use _.mergeWith. This allows you to provide a customizer function to override the default recursive logic.

Implementation for Atomic Arrays:

const _ = require('lodash');

function atomicArrays(objValue, srcValue) {
  if (Array.isArray(objValue) && Array.isArray(srcValue)) {
    return srcValue;
  }
}

const destination = { config: [1, 2, 3] };
const source = { config: [4, 5] };

_.mergeWith(destination, source, atomicArrays);
// Result: { config: [4, 5] } instead of [4, 5, 3]

Verification Steps

To verify these behaviors in your environment, run the following tests:

1. Index Test: Merge {a: [1, 2]} into {a: [3, 4, 5]}. If the result is [1, 2, 5], index-merging is active.
2. Prototype Test: Create an object using Object.create({ inherited: true }) and merge it into an empty object. If inherited appears in the result, prototype merging is active.

Diagnostic Detail Needed: Are your source configuration objects generated via Object.create() or classes with enumerable getters? This determines if the inherited property behavior will introduce unintended keys into your final config.