boolean operation trick

I've seen this before in code, but forgotten it. Basically it toggles a boolean variable. If it's true, it'll set to false and vice-versa. But unfortunately forgot the syntax.

It's basically a one liner for this:

if (myVar) {  
    myVar = false;  
} else {  
    myVar = true;  
}  

It's something like this, but don't know what it's called or the correct syntax of it:

开发者_如何学GomyVar = myVar : false ? true;

How about

myVar = !myVar

?

myVar = myVar ? false : true; is using the conditional operator.

You can just do this though

myVar = !myVar;

Another option is XOR:

myVar ^= true;

It's notable in that only the LHS of the assignment ever changes; the right side is constant and will toggle any boolean variable. Negation's more self-documenting IMO, though.

What you are thinking of is the conditional operator:

myVar = myVvar ? false : true;

(As you see, a lot of people call this "the ternary operator", but that only means that it is an operator with three operands. As it happens, there is only one operator with three operands in this language, but it still says nothing about what the operator does.)

It's of course easier to use the negation operator:

myVar = !myVar;

The smallest code I can think of at the moment. I don't know what its called (if it has a name, as you seem to suggest)

myVar = !myVar

What you're talking about is the "ternary" or "conditional" operator, which does an inline substitution as per a condition.

The syntax is:

condition ? trueValue : falseValue

I usually throw parentheses around my condition, sometimes around the whole conditional operator. Depends on how much I'm trying to delineate it from everything else.

So for example, suppose you want to return the larger of two numbers:

public int max(int a, int b)
{
  return (a > b) ? a : b;
}

Notice that it can be substituted into the middle of something else.

Okay, now let's tackle your actual question about toggling a boolean type.

myVar = (myVar) ? false : true;

is how you would do it with the conditional operator. (Again, parentheses aren't required, I just favor them.)

But there's a simpler way to toggle the boolean... using the logical NOT ("!") operator:

myVar = !myVar;

Keep it simple. :-)

if(myVar == true)
{
    myVar = false;
}
else if (myVar == false)
{
    myVar = true;
}
else
{
    myVar = FILE_NOT_FOUND
}

This also works :P

v=v?!v:!v;

There is a ternary operator (wikipedia). Which allows you to write a condensed if-else statement like in the second example.

In java:

myVar = (myVar) ? true : false;

There is also the NOT operator, which toggles a boolean variable. In java that is !. I believe that is what you want.

myVar = !myVar;

public boolean toggle(boolean bool)
{
  return !bool;
}

I recently (on my own) found a similar answer to one already stated here. However, the simplest and shortest (non-repeating variable name with least code) answer is:

formControl.disabled ^= 1;

This works best in JavaScript when wanting to toggle boolean, DOM-based attributes (for example, a form control/input's disabled property -- going from a non-editable to edit state). After much searching (with no result that I liked) and some trial and error, I found my solution to be the simplest (however, true instead of a 1 would be clearer -- as was previously posted).

Since this syntax isn't very clear, immediately, I would not advise using it very often (I believe it is appropriate when the variable or property makes the context obvious). I have posted this response (instead of making it a comment) because the context in which the XOR bitwise self-assignment should be used is very important. This "trick" should mostly be avoided when considering best practices.

As others have noted, there are two ways to negate something: "lvalue = !lvalue;" and "lvalue ^= 1;". It's important to recognize the differences.

Saying "lvalue = !lvalue" will cause lvalue to be set to 1 if it was zero, and 0 if it was set to anything else. The lvalue will be evaluated twice; this is not a factor for simple variables, but saying "someArray[index1][index2][index3][index4] = !someArray[index1][index2][index3][index4]" could slow things down.

Saying "lvalue ^= 1;" will cause lvalue to be set to 1 if it was 0, 0 if it was 1, and something else if it was neither zero nor 1. The lvalue need only be specified or evaluated once, and if the value is known to be either zero or 1, this form is likely to be faster.

Too bad there's no auto-negate operator; there are times such a thing would be handy.

You can also use the binary form of negation as shown here.

if ((v == true) && !(v = false)) {
    v != true;   /* negate with true if true. */
} else {
    v =! false;  /* negate with false if false. */
}