协助在包含模数运算符的 if 语句中查找模式

Question

我在个人项目中工作，发现自己重复了很多代码：

// this code is in a function with params k & dir

// where i equals a number from 0-2 inclusive
// j = (i + 1) % 2
// k = (j + 1) % 2
// The objective is to change a.x, a.y, b.x, & b.y



1.  if(k === 0 && dir === -1) { a.x = dir *  array[k].x; a.y = dir * array[k].y; b.x = dir * -array[i].x; b.y = dir * -array[i].y; }
2.  if(k === 0 && dir ===  1) { a.x = dir *  array[i].x; a.y = dir * array[i].y; b.x = dir * -array[k].x; b.y = dir * -array[k].y; }
3.
4.  if(k === 1 && dir === -1) { a.x = dir * -array[i].x; a.y = dir * array[i].y; b.x = dir * -array[i].x; b.y = dir * -array[i].y; }
5.  if(k === 1 && dir ===  1) { a.x = dir * -array[i].x; a.y = dir * array[i].y; b.x = dir * -array[i].x; b.y = dir * -array[i].y; }
6.  
7.  if(k === 2 && dir === -1) { a.x = dir * -array[j].x; a.y = dir * array[j].y; b.x = dir *  array[i].x; b.y = dir * -array[i].y; }
8.  if(k === 2 && dir ===  1) { a.x = dir * -array[i].x; a.y = dir * array[i].y; b.x = dir *  array[j].x; b.y = dir * -array[j].y; }

两天来我一直在尝试减少代码，但没有成功，坦率地说，我相信一定有一种方法可以不使用所有这些 if 语句。

我只是想在正确的方向上引起轰动，尽管非常欢迎完整的解决方案。

到目前为止，我尝试再次使用模数运算符，但问题出现在行 7 & 8 等部分，因为数组索引因对象是否不同而不同是 a 或 b。所以我相信至少必须有两个 if 语句，但我只是迷路了。

同样，这正在成为一个难题，所以我希望它至少对编码专家来说很有趣 :)

编辑

代码已经可以运行了，只是重复了一遍，希望能找到更简洁的解决方案。所有值都是数字，a和b都是包含{ x: undefined, y: undefined }的对象。

为了清楚起见，分为两个对象：

    // for a
    if(k === 0 && dir === -1) { a.x = dir *  array[k].x; a.y = dir *  array[k].y; } // (0, -1) => (0)
    if(k === 0 && dir ===  1) { a.x = dir *  array[i].x; a.y = dir *  array[i].y; } // (0,  1) => (1)

    if(k === 1 && dir === -1) { a.x = dir * -array[i].x; a.y = dir *  array[i].y; } // (1, -1) => (2)
    if(k === 1 && dir ===  1) { a.x = dir * -array[i].x; a.y = dir *  array[i].y; } // (1,  1) => (2)

    if(k === 2 && dir === -1) { a.x = dir * -array[j].x; a.y = dir *  array[j].y; } // (2, -1) => (1)
    if(k === 2 && dir ===  1) { a.x = dir * -array[i].x; a.y = dir *  array[i].y; } // (2,  1) => (0)


    // for b
    if(k === 0 && dir === -1) { b.x = dir * -array[i].x; b.y = dir * -array[i].y; } // (0, -1) => (1)
    if(k === 0 && dir ===  1) { b.x = dir * -array[k].x; b.y = dir * -array[k].y; } // (0,  1) => (0)

    if(k === 1 && dir === -1) { b.x = dir * -array[i].x; b.y = dir * -array[i].y; } // (1, -1) => (2)
    if(k === 1 && dir ===  1) { b.x = dir * -array[i].x; b.y = dir * -array[i].y; } // (1,  1) => (2)

    if(k === 2 && dir === -1) { b.x = dir *  array[i].x; b.y = dir * -array[i].y; } // (2, -1) => (0)
    if(k === 2 && dir ===  1) { b.x = dir *  array[j].x; b.y = dir * -array[j].y; } // (2,  1) => (1)

每行末尾的注释显示input => output，其中(k, dir) => output，输出值是给array.

的索引

array是函数范围外的数组。

编辑2

    for(let i = 0; i < 3; i++) {
        // list has arrays inside containing coordinates in a 2d plane, following a triangular grid. Each value looks like this [0, 2, -1]
        // j = next modulus value in base 3 given i
        // k = next modulus value in base 3 given j
        let j = (i + 1) % 3;
        let k = (i + 2) % 3;

        list[i] = [...old_list].sort((a, b) => { // sort list
            // This provides 3 sorted lists which are sorted by xy, yz, and zx
            if(a[i] === b[i]) {
                if( a[j] === b[j] && Math.abs(a[k] - b[k]) ) {
                    my_function(a, b, i, j, k);
                }
                return a[j] - b[j];
            }
            return a[i] - b[i];
        });
    }

    my_function(a, b, i, j, k) {
        let modules = universe.modules;
        let dir = b[k] - a[k];

        a = {x: undefined, y: undefined};
        b = {x: undefined, y: undefined};

        if(k === 0 && dir === -1) { a.x = dir *  module.constraints[k].x; a.y = dir *  module.constraints[k].y; } // (0, -1) => (0)
        if(k === 0 && dir ===  1) { a.x = dir *  module.constraints[i].x; a.y = dir *  module.constraints[i].y; } // (0,  1) => (1)

        if(k === 1 && dir === -1) { a.x = dir * -module.constraints[i].x; a.y = dir *  module.constraints[i].y; } // (1, -1) => (2)
        if(k === 1 && dir ===  1) { a.x = dir * -module.constraints[i].x; a.y = dir *  module.constraints[i].y; } // (1,  1) => (2)

        if(k === 2 && dir === -1) { a.x = dir * -module.constraints[j].x; a.y = dir *  module.constraints[j].y; } // (2, -1) => (1)
        if(k === 2 && dir ===  1) { a.x = dir * -module.constraints[i].x; a.y = dir *  module.constraints[i].y; } // (2,  1) => (0)



        if(k === 0 && dir === -1) { b.x = dir * -module.constraints[i].x; b.y = dir * -module.constraints[i].y; } // (0, -1) => (1)
        if(k === 0 && dir ===  1) { b.x = dir * -module.constraints[k].x; b.y = dir * -module.constraints[k].y; } // (0,  1) => (0)

        if(k === 1 && dir === -1) { b.x = dir * -module.constraints[i].x; b.y = dir * -module.constraints[i].y; } // (1, -1) => (2)
        if(k === 1 && dir ===  1) { b.x = dir * -module.constraints[i].x; b.y = dir * -module.constraints[i].y; } // (1,  1) => (2)

        if(k === 2 && dir === -1) { b.x = dir *  module.constraints[i].x; b.y = dir * -module.constraints[i].y; } // (2, -1) => (0)
        if(k === 2 && dir ===  1) { b.x = dir *  module.constraints[j].x; b.y = dir * -module.constraints[j].y; } // (2,  1) => (1)

        // doing some stuff with Matter.js(physics library) to decide where to add constraints between two bodies
    }

Answer 1

这段代码可能有问题。自从我开始写这个问题以来，这个问题已经改变了，我可能没有跟上。但我认为这至少可以展示一种避免重复的技术：

const rules = [[0, -1, 'k', 'k', 'i', 'i'], [0, 1, 'i', 'i', 'k', 'k'], /* ... */]

const foo = (i, j, k, dir, array) => {
    const idxs = {i, j, k}
    const a = {}, b = {}
    const [,, ax, ay, bx, by] = rules.find(([rk, rd, ..._]) => rk === k && rd === dir)
    a.x = dir *  array[idxs[ax]].x
    a.y = dir *  array[idxs[ay]].y
    b.x = dir * -array[idxs[bx]].x 
    b.y = dir * -array[idxs[by]].y
    return {a, b}
}

console.log(foo(0, 1, 0, -1, [{x: 1, y: 2}]))

重要的部分是规则列表，它实际上捕获了您的逻辑，idxs 对象允许将这些规则转换为实际值。可能有一种方法可以更进一步，对 a's、b's、x's 和 y's 做类似的事情。但我认为这达到了可读性的平衡。

协助在包含模数运算符的 if 语句中查找模式

assistance in finding pattern in if statements containing modulus operator

javascript

function

modulus

编辑

编辑2