Is there a better way of writing v = (v == 0 ? 1 : 0); [closed]

Answer 1

Since this is JavaScript, we can use the unary + to convert to int:

v = +!v;

This will logical NOT the value of v (giving true if v == 0 or false if v == 1). Then we convert the returned boolean value into its corresponding integer representation.

Answer 2

I would make it more explicit.

What does v mean?

For example when v is some state. Create an object Status. In DDD an value object.

Implement the logic in this value object. Then you can write your code in a more functional way which is more readable. Switching status can be done by creating a new Status based on the current status. Your if statement / logic is then encapsulated in your object, which you can unittest. An valueObject is always immutable, so it has no identity. So for changing it's value you have to create a new one.

Example:

public class Status
{
    private readonly int _actualValue;
    public Status(int value)
    {
        _actualValue = value;
    }
    public Status(Status status)
    {
        _actualValue = status._actualValue == 0 ? 1 : 0; 
    }

    //some equals method to compare two Status objects
}

var status = new Status(0);

Status = new Status(status);

Answer 3

You could do

v = Math.abs(--v);

The decrement sets the value to 0 or -1, and then the Math.abs converts -1 to +1.

Answer 4

To sum up another answer, a comment and my own opinion, I suggest combining two things:

1. Use a function for the toggle
2. Inside this function use a more readable implementation

Here is the function which you could place in a library or maybe wrap it in a Plugin for another Javascript Framework.

function inv(i) {
  if (i == 0) {
    return 1
  } else {
    return 0;
  }
}

And the usage is simply:

v = inv(v);

The advantages are:

1. No code Duplication
2. If you or anybody read this again in the future, you will understand your code in a minimum of time.

Answer 5

This is missing:

v = [1, 0][v];

It works as round robin as well:

v = [2, 0, 1][v]; // 0 2 1 0 ...
v = [1, 2, 0][v]; // 0 1 2 0 ...
v = [1, 2, 3, 4, 5, 0][v]; // 0 1 2 3 4 5 ...
v = [5, 0, 1, 2, 3, 4][v]; // 0 5 4 3 2 1 0 ...

Or

v = {0: 1, 1: 0}[v];

The charme of the last solution, it works with all other values as well.

v = {777: 'seven', 'seven': 777}[v];

For a very special case, like to get a (changing) value and undefined, this pattern may be helpful:

v = { undefined: someValue }[v]; // undefined someValue undefined someValue undefined ...

Answer 6

If there are just two values, as in this case(0, 1), i believe it's wasteful to use int. Rather go for boolean and work in bits. I know I'm assuming but in case of toggle between two states boolean seems to be ideal choice.