Javascript 如何求长度可变的数和数组的和

我相信另外，左手边和右手边可以互换，对吗？这条规则似乎不适用于多模态逻辑

基本概念：
[1,2,3]+[4,5,6]=[5,7,9]

添加不同的长度：
[1,2,3]+[4,5]=[5,7,7]或[[5,7]，7]
[1,2]+[3,4,5]=[9,6]或[10,6]或[4,6,6]或[4,6,6]
在上面，您可以看到不同的输出，这取决于您如何查看逻辑。当较小的数组超过其最大索引时，它将恢复到起始位置。我还假设在这种情况下LHS的长度优先。但它也可以坚持更大的长度，甚至添加另一个模块。

多模态和奇异组合：
[1,2,3]+1=[2,3,4]
1+[1,2,3]=7或9或[2,3,4]
同样，既然已经介绍了其他想法，您可以看到有不同的方法来看待这一点。

我找不到任何关于这种逻辑类型的既定文档，所以任何帮助都会很好。我在底部添加了当前脚本，它当前优先于LHS。我很容易在LHS的优先级和长度之间切换，只是不确定哪条路是正确的。

根据要求，我在下面的示例后面添加了逻辑。每个示例遵循的主要规则是，较小的数组将始终循环回到开头。

已建立添加长度相同的组：
[a，b，c]+[1,2,3]=[a+1，b+2，c+3]

以下是不同长度的可能计算：
[a，b，c]+[1,2]=[a+2，b+2，c+1]或[[1+a，1+c]，2+b]
[a，b]+[1,2,3]=[a+1+3，b+2]或[（a+1）+（a+3），b+2]或[a+1，b+2，a+3]或[[a+1，a+3]，b+2]
[a，b，c]+1=[a+1，b+1，c+1]
1+[a，b，c]=（1+a+b+c）或（1+a）+（1+b）+（1+c）或[1+a，1+b，1+c]

JavaScript:

var MMMath=Math；
//多式联运
MMMath.add=函数（）{
开关（arguments.length）{
案例0：
返回NaN；
案例1：
返回参数[0]；
违约：
var值=Array.prototype.slice.call（参数）；
var arg1=值[0]；
var arg2=值[1]；
var length=arg1.length2）{
values=[sum].concat（values.slice（2，values.length））；
返回MMMath.add.apply（null，值）；
}否则{
回报金额；
}
}否则{
var lhsIsMulti=arg1.length！==未定义；
var rhsIsMulti=arg2.length！==未定义；
对于（变量i=0；i2）{
values=[arg1].concat（values.slice（2，values.length））；
返回MMMath.add.apply（null，值）；
}否则{
返回arg1；
}
}
}
};

仍然包含冗余，但下面是我提出的支持数组的脚本

MMMath.add = function () {
    switch (arguments.length) {
        case 0:
            return NaN;
        case 1:
            return arguments[0];
        default:
            var values = Array.prototype.slice.call(arguments);
            var arg1 = values[0];
            var arg2 = values[1];
            var lhsIsSingular = arg1.length === undefined;
            var rhsIsSingular = arg2.length === undefined;
            var length = arg1.length < arg2.length || lhsIsSingular ? arg2.length : arg1.length;
            if (length === undefined) { // lhs is singular & rhs is singular
                var sum = arg1 + arg2;
                if (values.length > 2) {
                    values = [sum].concat(values.slice(2, values.length));
                    return MMMath.add.apply(null, values);
                } else {
                    return sum;
                }
            } else {
                var lhs = [arg1];
                var rhs = [arg2];
                if (!lhsIsSingular) {
                    lhs = arg1;
                    arg1 = 0;
                }
                if (!rhsIsSingular) {
                    rhs = arg2;
                    arg2 = 0;
                }
                for (var i = lhs.length; i < length; i++) {
                    lhs.push(arg1);
                }
                for (var i = rhs.length; i < length; i++) {
                    rhs.push(arg2);
                }
                for (var i = 0; i < length; i++) {
                    lhs[i] = MMMath.add(lhs[i], rhs[i]);

                }
                if (values.length > 2) {
                    values = [lhs].concat(values.slice(2, values.length));
                    return MMMath.add.apply(null, values);
                } else {
                    return lhs;
                }
            }
    }
};

MMMath.add=函数（）{
开关（arguments.length）{
案例0：
返回NaN；
案例1：
返回参数[0]；
违约：
var值=Array.prototype.slice.call（参数）；
var arg1=值[0]；
var arg2=值[1]；
var lhsIsSingular=arg1.length==未定义；
var rhsIsSingular=arg2.length==未定义；
var length=arg1.length2）{
values=[sum].concat（values.slice（2，values.length））；
返回MMMath.add.apply（null，值）；
}否则{
回报金额；
}
}否则{
var lhs=[arg1]；
var rhs=[arg2]；
如果（！lhsIsSingular）{
lhs=arg1；
arg1=0；
}
if（！rhsIsSingular）{
rhs=arg2；
arg2=0；
}
对于（var i=lhs.length；i2）{
MMMath.add = function () {
    switch (arguments.length) {
        case 0:
            return NaN;
        case 1:
            return arguments[0];
        default:
            var values = Array.prototype.slice.call(arguments);
            var arg1 = values[0];
            var arg2 = values[1];
            var lhsIsSingular = arg1.length === undefined;
            var rhsIsSingular = arg2.length === undefined;
            var length = arg1.length < arg2.length || lhsIsSingular ? arg2.length : arg1.length;
            if (length === undefined) { // lhs is singular & rhs is singular
                var sum = arg1 + arg2;
                if (values.length > 2) {
                    values = [sum].concat(values.slice(2, values.length));
                    return MMMath.add.apply(null, values);
                } else {
                    return sum;
                }
            } else {
                var lhs = [arg1];
                var rhs = [arg2];
                if (!lhsIsSingular) {
                    lhs = arg1;
                    arg1 = 0;
                }
                if (!rhsIsSingular) {
                    rhs = arg2;
                    arg2 = 0;
                }
                for (var i = lhs.length; i < length; i++) {
                    lhs.push(arg1);
                }
                for (var i = rhs.length; i < length; i++) {
                    rhs.push(arg2);
                }
                for (var i = 0; i < length; i++) {
                    lhs[i] = MMMath.add(lhs[i], rhs[i]);

                }
                if (values.length > 2) {
                    values = [lhs].concat(values.slice(2, values.length));
                    return MMMath.add.apply(null, values);
                } else {
                    return lhs;
                }
            }
    }
};