What is the difference between the | and || or operators?
Just like the &
and &&
operator, the double Operator is a "short-circuit" operator.
For example:
if(condition1 || condition2 || condition3)
If condition1 is true, condition 2 and 3 will NOT be checked.
if(condition1 | condition2 | condition3)
This will check conditions 2 and 3, even if 1 is already true. As your conditions can be quite expensive functions, you can get a good performance boost by using them.
There is one big caveat, NullReferences or similar problems. For example:
if(class != null && class.someVar < 20)
If class is null, the if-statement will stop after class != null
is false. If you only use &, it will try to check class.someVar
and you get a nice NullReferenceException
. With the Or-Operator that may not be that much of a trap as it's unlikely that you trigger something bad, but it's something to keep in mind.
No one ever uses the single &
or |
operators though, unless you have a design where each condition is a function that HAS to be executed. Sounds like a design smell, but sometimes (rarely) it's a clean way to do stuff. The &
operator does "run these 3 functions, and if one of them returns false, execute the else block", while the |
does "only run the else block if none return false" - can be useful, but as said, often it's a design smell.
There is a Second use of the |
and &
operator though: Bitwise Operations.
Difference between || and ?? operators
The main difference is that nullish coalescing(??)
operator will only give the result as the right operand only if the left operand is either null
or undefined
.
Whereas the OR(||)
operator will give the result as right operand for all the falsy values of the left operand.
Below are some examples
- Snippet 1: With
0
as input
const a = 0;
// a || 10 --> Will result in 10, as || operator considers 0 as falsy value and resulting the right side operand
console.log(`a || 10 = ${a || 10}`);
// a ?? 10 --> Will result in 0, as ?? operator considers 0 as truthy value and resulting the left side operand
console.log(`a ?? 10 = ${a ?? 10}`);
Difference between OR operator || and | in Java?
This is simple. http://www.roseindia.net/help/java/o/java-operator.shtml says:
OR operator is a kind of a conditional operators, which is represented
by | symbol. It returns either true or false value based on the state
of the variables i.e. the operations using conditional operators are
performed between the two boolean expressions.The OR operator (|) is similar to the Conditional-OR operator (||) and
returns true, if one or another of its operand is true.
Note: In ||
operator if have more than one condition and if first condition return true
then other conditions ignored but in |
operator all condition examin.
There are more information on http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html
What is the difference between the | and || operators?
|
is a bitwise or, ||
is a boolean or.
What's the difference between ( | ) and ( || )?
|
is a bitwise or, ||
is a logical or.
A bitwise or takes the two numbers and compares them on a bit-by-bit basis, producing a new integer which combines the 1 bits from both inputs. So 0101 | 1010
would produce 1111
.
A logical or ||
checks for the "truthiness" of a value (depends on the type, for integers 0 is false and non-zero is true). It evaluates the statement left to right, and returns the first value which is truthy. So 0101 || 1010
would return 0101
which is truthy, therefore the whole statement is said to be true.
The same type of logic applies for &
vs &&
. 0101 & 1010
= 0000
. However 0101 && 1010
evaluates to 1010
(&&
returns the last truthy value so long as both operands are truthy).
What is difference between logical OR and short circuit OR operator?
The difference is that the short circuit operator doesn't evaluate the second operand if the first operand is true, which the logical OR without short circuit always evaluates both operands.
You wouldn't see any difference in your simple test, since both should give the same output assuming no exception is thrown, but if you try something like this :
String s = null;
System.out.println("a || b = " + s==null || s.length() == 0 );
System.out.println("a | b = " + s==null | s.length() == 0 );
The first operator will give you true, while the second operator will give you NullPointerException
, since only the |
operator will attempt to evaluate s.length() == 0
.
Difference between | and || , or & and &&
The operators |
, &
, and ~
act on individual bits in parallel. They can be used only on integer types. a | b
does an independent OR operation of each bit of a
with the corresponding bit of b
to generate that bit of the result.
The operators ||
, &&
, and !
act on each entire operand as a single true
/false
value. Any data type can be used that implicitly converts to bool
. Many data types, including float
implicitly convert to bool with an implied !=0
operation.
||
and &&
also "short circuit". That means whenever the value of the result can be determined by just the first operand, the second is not evaluated. Example:
ptr && (*ptr==7)
If ptr
is zero, the result is false without any risk of seg faulting by dereferencing zero.
You could contrast that with (int)ptr & (*ptr)
. Ignoring the fact that this would be a bizarre operation to even want, if (int)ptr
were zero, the entire result would be zero, so a human might think you don't need the second operand in that case. But the program will likely compute both anyway.
Difference between | and || or & and && for comparison
in C (and other languages probably) a single |
or &
is a bitwise comparison.
The double ||
or &&
is a logical comparison.
Edit: Be sure to read Mehrdad's comment below regarding "without short-circuiting"
In practice, since true
is often equivalent to 1
and false
is often equivalent to 0
, the bitwise comparisons can sometimes be valid and return exactly the same result.
There was once a mission critical software component I ran a static code analyzer on and it pointed out that a bitwise comparison was being used where a logical comparison should have been. Since it was written in C and due to the arrangement of logical comparisons, the software worked just fine with either. Example:
if ( (altitide > 10000) & (knots > 100) )
...
What's the difference between or and | in ruby?
The |
operator is a binary mathematical operator, that is it does a binary OR and works on a numerical level:
1 | 2
# => 3
4 | 3
# => 7
1 | 2 | 3
# => 3
This is because it's manipulating individual values as if they were binary:
0b01 | 0b10
# => 3 (0b11)
The ||
operator is a logical one, that is it returns the first value that's logically true. In Ruby only literal nil
and false
values evaluates as logically false, everything else, including 0
, empty strings and arrays, is true.
So:
1 || 2
# => 1
0 || 1
# => 0
The or
operator works almost exactly the same as ||
except it's at a much lower precedence. That means other operators are evaluated first which can lead to some problems if you're not anticipating this:
a = false || true
# => true
a
# => true
a = false or true
# => true
a
# => false
This is because it's actually interpreted as:
(a = false) or true
This is because =
has a higher precedence when being evaluated.
Related Topics
Calling a Function from a String in C#
How to Strip HTML Tags from a String in Asp.Net
How to Remove All HTML Tags from a String Without Knowing Which Tags Are in It
Convert Webpage to Image from Asp.Net
Html Agility Pack - Parsing Tables
How to Find the Text Within a Div in the Source of a Web Page Using C#
How to Convert HTML to Text in C#
Generating HTML Email Body in C#
How to Convert HTML to Plain Text
Does Page Reload Ever Cause Post
C# Json.Net Convention That Follows Ruby Property Naming Conventions
Parse Email Content from Quoted Reply