Easiest Way to Flip a Boolean Value

Easiest way to flip a boolean value?

You can flip a value like so:

myVal = !myVal;

so your code would shorten down to:

switch(wParam) {
    case VK_F11:
    flipVal = !flipVal;
    break;

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

Flip a boolean value in a simple way javascript

Assuming you declared variable with let or var, so that you can reassign the value :

completed = !completed

What is the quickest way to flip a Java boolean?

I measured with the following code.

public static void main(String[] args)
{

    boolean myVariable = true;
    long startTime = 0;
    long endTime = 0;
    long duration1 = 0;
    long duration2 = 0;

    for(int i=0; i<1000; i++) {
        startTime = System.nanoTime();
        myVariable = !myVariable;
        endTime = System.nanoTime();

        duration1 += (endTime - startTime);

        startTime = System.nanoTime();
        myVariable ^= myVariable;
        endTime = System.nanoTime();

        duration2 += (endTime - startTime);

    }

        System.out.println("The duration for the first operation is :" + (duration1/1000));
        System.out.println("The duration for second operation is :" + (duration2/1000));
}

and the results are (in nanoseconds)

The duration for the first operation is :140

The duration for the second operation is :123

Based on this analysis, the boolean ^= boolean is quicker than the boolean = !boolean.

How to toggle a boolean?

bool = !bool;

This holds true in most languages.

Flip a boolean value without referencing it twice

You can use xor operator (^):

x = True
x ^= True
print(x) # False
x ^= True
print(x) # True

Edit: As suggested by Guimoute in the comments, you can even shorten this by using x ^= 1 but it will change the type of x to an integer which might not be what you are looking for, although it will work without any problem where you use it as a condition directly, if x: or while x: etc.

Cleanest way to toggle a boolean variable in Java?

theBoolean = !theBoolean;

C: flip integer value as a boolean

I posted one answer, but I may have misread the question. If you have an integer variable -- it might be int, short int, or char -- and you want to have it cycle back and forth 0, 1, 0, 1 (which you can interpret as false, true, false, true), there are two about equally good ways to do it. You could do:

i = !a;

This first way emphasize the "Boolean" nature of the variable.
Or, you could do:

i = 1 - i;

This second way is purely numeric.

But either way will work perfectly well. In either case, i is guaranteed to alternate 0, 1, 0, 1, ...

You could also use

i = i ? 0 : 1;

or

i = (i == 0) ? 1 : 0;

Both of these will work, too, but they're basically equivalent to i = !i.

In your question you suggested

i = (i == 1) ? 0 : 1;

This would mostly work, but it looks weird to my eye. Also it would do the wrong thing if i ever ended up containing 2 (or any value other than 0 or 1).

Is there a better way to invert the value of a boolean on a loop?

std::cout << (switch = !switch) << std::endl;

Or

std::cout << !switch << std::endl << switch << std::endl;

What's the most concise way to get the inverse of a Java boolean value?

Just assign using the logical NOT operator ! like you tend to do in your condition statements (if, for, while...). You're working with a boolean value already, so it'll flip true to false (and vice versa):

myBool = !myBool;

How to flip the boolean value in a nested function

You are modifying the local value x in not isChange this function:

def change(x):
    x = [False]

You need to return the desired value:

def change(x):
    return [False]

Or better yet if you want to flip the value:

def change(x):
    return [not x[0]]

Then in printChange you need to assign the return value to isChange:

def printChange():
    isChange = [True]
    isChange = change(isChange)
    print(isChange)

---

Related Topics