在javascript中对字符串数组和子数组求和而不连接它们

Question

我正在尝试将项目从一个数组“求和”到另一个数组，同时保留它们的子数组（子数组）：

array1 = [         array2 = [         array3 = [
 [                  [                  [
  "A",               "1",               "A",
  "B",               "2",               "B",
  [                  [                  "1",
   "C"      +         "3"      =        "2",
  ]                  ]                  [
 ],                 ],                  "C",
 "D"                "4"                 "3"
]                  ]                    ]
                                       ],
                                       "D",
                                       "4"
                                      ]

编辑：理想情况下，最长的数组将被视为“主”数组（其值将位于最短数组之前）。 如果数组的元素个数相同，则第一个数组为主。

["a", ["b", "c"], "d"]
          +
["x", ["v", "w"], "y"]
          =
["a" "x", ["b", "c", "v", "w"], "d", "y"]


["a", "b", ["c", "d", ["e", "f"]]]
          +
[["1", ["2"]]]
          =
["a", "b", ["c", "d", "1", ["e", "f", "2"]]]

这可能吗？到目前为止，我发现的唯一建议与 .concat() 的使用有关，但是它将一个数组连接到另一个数组的末尾，并且不会合并两者：

var array1 = [["A", "B", ["C"]], "D"];
var array2 = [["1", "2", ["3"]], "4"];
console.log(array1.concat(array2)) // returns [["A", "B", ["C"]], "D", ["1", "2", ["3"]], "4"]

编辑 2： 我现在一直在以不同的方式思考这个问题，并意识到一个简单的可视化方法是这样的：

target = [
 "A",
 "B",
 [
  "C",
  "D",
  [
   "E"
  ],
 "J"
 ]
]

我想在“E”之后添加以下元素：

newelement = [
 [
  [
   "F",
   [
    "G",
    "H",
    "I"
   ]
  ]
 ]
]

结果是：

result = [
 "A",
 "B",
 [
  "C",
  "D",
  [
   "E",
   "F",
   [
    "G",
    "H",
    "I"
   ]
  ],
 "J"
 ]
]

基本上就是这样，将一个数组与另一个数组合并。

Answer 1

如果我理解正确，你想连接两个数组的子部分，它们只包含非数组（元素的数量可能不同），然后递归地合并两个数组的下一个数组，然后再次将第一个逻辑应用于下一个没有数组的小节......等等。

这是实现的想法：

function deepConcat(a, b) {
    if (a.length < b.length) return deepConcat(b, a);
    let i = 0, j = 0, result = [];
    while (true) {
        while (i < a.length && !Array.isArray(a[i])) result.push(a[i++])
        while (j < b.length && !Array.isArray(b[j])) result.push(b[j++])
        if (i >= a.length || j >= b.length) break;
        result.push(deepConcat(a[i++], b[j++]));
    }
    return [...result, ...a.slice(i), ...b.slice(j)];
}

const test = (a, b) => console.log(JSON.stringify(deepConcat(a, b)));

test([["A", "B", ["C"]], "D"], [["1", "2", ["3"]], "4"]);
test(["a", ["b", "c"], "d"], ["x", ["v", "w"], "y"]);
test(["a", "b", ["c", "d", ["e", "f"]]], [["1", ["2"]]]);
test(["A","B",["C","D",["E"],"J"]], [[["F",["G","H","I"]]]]);

Answer 2

这样的？

array1 = [
  ["A", "B", ["C"]], "D"
]
array2 = [
  ["1", "2", ["3"]], "4"
]

array3 = [
  ["A", "B", "1", "2", ["C", "3"]], "D", "4"
]

const findFirstNonPrimitiveIndex = arr => arr.findIndex(x => !isPrimitive(x))
const takePrimitives = (arr, pos = 0) => arr.slice(0, findFirstNonPrimitiveIndex(arr))
const isPrimitive = x => typeof x !== "object"

const merge = (arr1, arr2) => {
  const [head1, ...rest1] = arr1
  const [head2, ...rest2] = arr2
  // base case
  if (rest1.length === 0)
    if (isPrimitive(head1)) return [head1, head2];
    else return [merge(head1, head2)]
  // inductive step
  if (isPrimitive(head1)) {
    const cutPoint = findFirstNonPrimitiveIndex(rest1);
    return [
      ...takePrimitives(arr1), 
      ...takePrimitives(arr2), 
      ...merge(rest1.slice(cutPoint), rest2.slice(cutPoint))
    ]
  } else {
    return [merge(head1, head2), ...merge(rest1, rest2)];
  }
}

const result = merge(array1, array2);

console.log(result)

.as-console-wrapper {
  top: 0;
  max-height: 100% !important;
}