помощь в нахождении шаблона в операторах if, содержащих оператор модуля - PullRequest
Новая
       36

помощь в нахождении шаблона в операторах if, содержащих оператор модуля

0 голосов
/ 09 октября 2018

Я работаю в личном проекте и обнаружил, что повторяю много кода: 

// 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, но я просто потерян.

Опять же, больше всего это становится загадкой, поэтому я надеюсь, что это, по крайней мере, весело для вас, знатоков кодирования :)1014 *

Редактировать

Код уже работает, он просто повторяется, и я надеялся найти более краткое решение.Все значения являются числами, 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)

Комментарии наконец каждой строки show input => output, где (k, dir) => output, а выходным значением является индекс, заданный для array.

array - это массив вне области действия функции.

Edit2 

    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
    }

1 Ответ

0 голосов
/ 09 октября 2018

Возможно, что-то не так с этим кодом.Вопрос изменился с тех пор, как я начал его писать, и я, вероятно, не поспевал за ним.Но я думаю, что это может, по крайней мере, показать технику, чтобы избежать повторения: 

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, b, x и y.Но я думаю, что это обеспечивает баланс читабельности.

...