Krdytkyu

function handleDirection(src) {

   var i = 1;

   if(src === 'left')

     i = -1;



   if(inverse)

     tracker += i;

   else

     tracker -= i;

}

You can even do it with just one line of Code:

function getDirectionOffset(src) {

  tracker += (src === 'left' ? 1 : -1) * (inverse ? -1 : 1);

}

This could be simplified to a ternary expression which returns 1 or -1 depending on the state. Then you can just add that to the tracker.

function handleDirection(src) {

  var delta = (src === 'left' && inverse) || (src !== 'left' && !inverse) ? -1 : 1;

  tracker += delta;

}

This could then be simplified further using the logic which @NinaScholz pointed out in her answer:

function handleDirection(src) {

  var delta = (src === 'left') === inverse ? -1 : 1;

  tracker += delta;

}

You want to increase the tracker if one of src == left or inverse is true but not the other, and decrease it otherwise, which is what the "XOR" ^ operator does :

function handleDirection(src) {

    if (src === 'left' ^ inverse) {

        tracker++;

    } else {

        tracker--;

    }

}

You can reduce that further by using a ternary expression :

function handleDirection(src) {

    tracker += src === 'left' ^ inverse ? 1 : -1;

}

Or if you want to avoid any kind of conditionnal, with implicit casts and "clever" arithmetics :

function handleDirection(src) {

    tracker += 1 - 2 * (src === 'right' ^ inverse);

}

Assuming inverse is a flag you'd set once, then you don't need to take it into account every time, you can calculate its impact once and just use it as it is, which will cut down your code branches and logic. If you want to change it as you go along, then you might need to separate the logic for the calculation, in order to re-use it.

You can also then extract the movement direction into a self-contained function and your handleDirection becomes very simple - you calculate the direction you want to go based on src and the invert.

let tracker = 0;



//extract logic for the movement offset based on direction

function getDirectionOffset(src) {

  return src === 'left' ? 1 : -1;

}



//have a setter for the invert property

function setInverse(isInverse) {

  movementModifier = isInverse ? -1 : 1

}



//declare the variable dependent on the inverse property

let movementModifier;



//initialise movementModifier variable

setInverse(false);



function handleDirection(src) {

  const offset = getDirectionOffset(src) * movementModifier;

  

  tracker += offset;

}





// usage

setInverse(true);



handleDirection("left");

handleDirection("left");

handleDirection("right");



console.log(tracker);

With that said, all this suggests you shouldn't be using a function, or you should be using it differently. You can collect all that functionality in a class or instead have all the information passed around functions, so you don't have globals. Here is a sample object oriented implementation of the concept:

class TrackerMover {

  constructor(inverse) {

    this.tracker = 0;

    this.movementModifier = inverse ? 1 : -1

  }

  

  handleDirection(src) {

   const offset = this.getDirectionOffset(src) * this.movementModifier;



    this.tracker += offset;

  }

  

  getDirectionOffset(src) {

    return src === 'left' ? -1 : 1;

  }

  

  getPosition() {

    return this.tracker;

  }

}





//usage

const mover = new TrackerMover(true);



mover.handleDirection("left");

mover.handleDirection("left");

mover.handleDirection("right");



console.log(mover.getPosition())

By the way, another alternative is to NOT compute the movement every time. You actually know what is happening every time - in effect, you have a truth table where your inputs are src === left and inverse and the outputs are how you modify your tracking.

+--------+------------+--------+

| isLeft | isInverted | Offset |

+--------+------------+--------+

| true   | true       |     -1 |

| true   | false      |      1 |

| false  | true       |      1 |

| false  | false      |     -1 |

+--------+------------+--------+

So, you can just put that table in.

let tracker = 0;

let invert = false;



const movementLookupTable = {

  "true": { },

  "false": { },

}



//it can be initialised as part of the above expression but this is more readable

movementLookupTable[true ][true ] = -1;

movementLookupTable[true ][false] = 1;

movementLookupTable[false][true ] = 1;

movementLookupTable[false][false] = -1;



function handleDirection(src) {

  const offset = movementLookupTable[src === "left"][invert];



  tracker += offset;

}





// usage

invert = true;



handleDirection("left");

handleDirection("left");

handleDirection("right");



console.log(tracker);

In this case it might be an overkill but this approach might be useful if there are more flags (including more values for the flags) and/or end states. For example, maybe you want to introduce four directions, but you don't modify the tracker value if it's up or down.

+-----------+------------+--------+

| direction | isInverted | Offset |

+-----------+------------+--------+

| left      | true       |     -1 |

| left      | false      |      1 |

| right     | true       |      1 |

| right     | false      |     -1 |

| up        | false      |      0 |

| up        | true       |      0 |

| down      | false      |      0 |

| down      | true       |      0 |

+-----------+------------+--------+

As you can see, now it's not just booleans, you can handle any value. Using a table, you also then change invert to be something like windDirection, so if the movement is left and the windDirection is right, the result is like what it is now, but you could have direction of left and wind going left, so you move further. Or you can move up and the wind direction is left so tracker (at this point the X coordinates) is going to actually be modified.

+-----------+---------------+---------+

| direction | windDirection | OffsetX |

+-----------+---------------+---------+

| left      | right         |      -1 |

| left      | up            |       1 |

| left      | down          |       1 |

| left      | left          |       2 |

| right     | up            |      -1 |

| right     | down          |      -1 |

| right     | right         |      -2 |

| right     | left          |       1 |

| up        | up            |       0 |

| up        | down          |       0 |

| up        | left          |       1 |

| up        | right         |      -1 |

| down      | up            |       0 |

| down      | down          |       0 |

| down      | left          |       1 |

| down      | right         |      -1 |

+-----------+---------------+---------+

With four directions and four wind directions to take into account the logic can be quite annoying to both read and maintain in the future, while if you only have a lookup table, it's easy and you can easily extend this to even handle diagonals (let's assume they change the value by 0.5 instead of 1) and your algorithm would not really care as long as you just fetch the values from the table.

Right now you are comparing on strings, which I wouldn't advise. If for example you use 'Left' instead of 'left' it will fail the first if statement. Perhaps a boolean could be of use here, since you can guarantee it only has two states.

The if statements inside can be compressed via conditional operators.

Perhaps something like this is what you are looking for:

function handleDirection(src) {

  if (src) {

    inverse ? tracker-- : tracker++;

  } else {

    inverse ? tracker-- : tracker++;

  }

}

See: https://jsfiddle.net/9zr4f3nv/

You can use short circuiting syntax or ternary operators

// by using short circuiting

    function handleDirection(src) {

       if (src == 'left') tracker = inverse && tracker-1 || tracker +1

       else  tracker = inverse && tracker+1 || tracker -1

    }

// by using ternary operator

 function handleDirection(src) {

       if (src == 'left') tracker = inverse ? tracker-1 : tracker +1

       else  tracker = inverse ? tracker+1 : tracker -1

    }

Not the shortest possible, but hopefully clear:

const LEFT = 'left'

const RIGHT = 'right'





function handleMovement(src) {

    tracker += movementIncrement(src, inverse)

}



function movementIncrement(direction, inverse) {

    if (inverse) {

        direction = inverseDirection(direction)

    }

    return LEFT ? -1 : +1

} 



function inverseDirection(direction) {

    return direction === LEFT ? RIGHT : LEFT

}

This has only one conditional, and I find it reads more intuitively than the other answers:

function handleDirection(src) {

    if (

        ((src === 'left') && !inverse) ||

        ((src === 'right') && inverse)

    ) {

        tracker++;

    }

    else {

        tracker--;

    }

}

I dislike elses and try to avoid nesting if possible. I think this conveys the idea of inverse in a more natural way:

function handleDirection(src) 

{

    let change = 1;



    if ('right' == src)

        change = -1;



    if (inverse)

        change = -change;



    tracker += change;

}

You could use an 2 dimensional array type data structure from js and store the desired outcomes at index sec and inverse. Or JSON.