JavaScript if(x) vs if(x==true) - javascript

In JavaScript , in which cases the following statements won't be logically equal ?
if(x){}
and
if(x==true){}
Thanks

They are not at all equal.
if (x)
checks if x is Truthy where as the later checks if the Boolean value of x is true.
For example,
var x = {};
if (x) {
console.log("Truthy");
}
if (x == true) {
console.log("Equal to true");
}
Not only an object, any string (except an empty string), any number (except 0 (because 0 is Falsy) and 1) will be considered as Truthy, but they will not be equal to true.
As per ECMA 5.1 Standards, in if (x), Truthiness of x will be decided, as per the following table
+-----------------------------------------------------------------------+
| Argument Type | Result |
|:--------------|------------------------------------------------------:|
| Undefined | false |
|---------------|-------------------------------------------------------|
| Null | false |
|---------------|-------------------------------------------------------|
| Boolean | The result equals the input argument (no conversion). |
|---------------|-------------------------------------------------------|
| Number | The result is false if the argument is +0, −0, or NaN;|
| | otherwise the result is true. |
|---------------|-------------------------------------------------------|
| String | The result is false if the argument is the empty |
| | String (its length is zero); otherwise the result is |
| | true. |
|---------------|-------------------------------------------------------|
| Object | true |
+-----------------------------------------------------------------------+
Note: The last line object, which includes both objects and Arrays.
But in the later case, as per The Abstract Equality Comparison Algorithm,
If Type(x) is Boolean, return the result of the comparison ToNumber(x) == y.
If Type(y) is Boolean, return the result of the comparison x == ToNumber(y).
value of x will be converted to a number and that number will be checked against true.
Note:
In JavaScript, true is 1 and false is 0.
console.log(1 == true);
# true
console.log(0 == false);
# true

Several cases evaluate to false in the first form, such as empty string, 0, undefined, null.
If you want to be a bit more semantic about it, try the bang bang in front of the expression:
if(!!x){...}
this will convert the expression result to a truthy representing the same semantically. This is closer to an analogue to the expression you describe (x == true)
Also be aware that == is value comparions with type coercion, eg "3" == 3, whereas === asserts equal typing too.
So they are not the same, but often logically represent the same test, thanks to the semantics of the language and the !! you can use

Related

"+" before variable in node.js / nuxt [duplicate]

What does the +d in
function addMonths(d, n, keepTime) {
if (+d) {
mean?
The + operator returns the numeric representation of the object. So in your particular case, it would appear to be predicating the if on whether or not d is a non-zero number.
Reference here. And, as pointed out in comments, here.
Operator + is a unary operator which converts the value to a number. Below is a table with corresponding results of using this operator for different values.
+----------------------------+-----------+
| Value | + (Value) |
+----------------------------+-----------+
| 1 | 1 |
| '-1' | -1 |
| '3.14' | 3.14 |
| '3' | 3 |
| '0xAA' | 170 |
| true | 1 |
| false | 0 |
| null | 0 |
| 'Infinity' | Infinity |
| 'infinity' | NaN |
| '10a' | NaN |
| undefined | NaN |
| ['Apple'] | NaN |
| function(val){ return val }| NaN |
+----------------------------+-----------+
Operator + returns a value for objects which have implemented method valueOf.
let something = {
valueOf: function () {
return 25;
}
};
console.log(+something);
It is a unary "+" operator which yields a numeric expression. It would be the same as d*1, I believe.
As explained in other answers it converts the variable to a number. Specially useful when d can be either a number or a string that evaluates to a number.
Example (using the addMonths function in the question):
addMonths(34,1,true);
addMonths("34",1,true);
then the +d will evaluate to a number in all cases. Thus avoiding the need to check for the type and take different code paths depending on whether d is a number, a function or a string that can be converted to a number.

javascript why is (true)^2 = 3, (true)^3=2 [duplicate]

What are XAND and XOR? Also is there an XNot
XOR is short for exclusive or. It is a logical, binary operator that requires that one of the two operands be true but not both.
So these statements are true:
TRUE XOR FALSE
FALSE XOR TRUE
And these statements are false:
FALSE XOR FALSE
TRUE XOR TRUE
There really isn't such a thing as an"exclusive and" (or XAND) since in theory it would have the same exact requirements as XOR. There also isn't an XNOT since NOT is a unary operator that negates its single operand (basically it just flips a boolean value to its opposite) and as such it cannot support any notion of exclusivity.
Guys, don´t scare the crap out of others (hey! just kidding), but it´s really all a question of equivalences and synonyms:
firstly:
"XAND" doesn´t exist logically, neither does "XNAND", however "XAND" is normally thought-up by a studious but confused initiating logic student.(wow!). It com from the thought that, if there´s a XOR(exclusive OR) it´s logical to exist a "XAND"("exclusive" AND). The rational suggestion would be an "IAND"("inclusive" AND), which isn´t used or recognised as well. So:
XNOR <=> !XOR <=> EQV
And all this just discribes a unique operator, called the equivalency operator(<=>, EQV) so:
A | B | A <=> B | A XAND B | A XNOR B | A !XOR B | ((NOT(A) AND B)AND(A AND NOT(B)))
---------------------------------------------------------------------------------------
T | T | T | T | T | T | T
T | F | F | F | F | F | F
F | T | F | F | F | F | F
F | F | T | T | T | T | T
And just a closing comment: The 'X' prefix is only possible if and only if the base operator isn´t unary. So, XNOR <=> NOT XOR <=/=> X NOR.
Peace.
XOR is Exclusive Or. It means "One of the two items being XOR'd is true, but not both of them."
TRUE XOR TRUE : FALSE
TRUE XOR FALSE : TRUE
FALSE XOR TRUE : TRUE
FALSE XOR FALSE: FALSE
Wikipedia's XOR Article
XAND I have not heard of.
In the book written by Charles Petzold titled "Code" he says there are 6 gates. There is the AND logical gate, the OR gate, the NOR gate, the NAND gate, and the XOR gate. He also mentions the 6th gate briefly calling it the "coincidence gate" and implies it's not used very often. He says it has the opposite output of a XOR gate because a XOR gate has the output of "false" when it has two true or two false sides of the equation and the only way for a XOR gate to have its output be true is for one of the sides of the equation to be true and the other to be false, it doesn't matter which. The coincidence is the exact opposite of this because with the coincidence gate if one is true and the other is false (doesn't matter which is which) then it will have its output be "false" in both those cases. And the way for a coincidence gate to have its output be "true" is for both sides to be either false or true. If both are false the coincidence gate will evaluate as true. If both are true then the coincidence gate will also output "true" in that case as well.
So in the cases where the XOR gate outputs "false", the coincidence gate will output "true". And in the cases where the XOR gate will output "true", the coincidence gate will output "false".
Hmm.. well I know about XOR (exclusive or) and NAND and NOR. These are logic gates and have their software analogs.
Essentially they behave like so:
XOR is true only when one of the two arguments is true, but not both.
F XOR F = F
F XOR T = T
T XOR F = T
T XOR T = F
NAND is true as long as both arguments are not true.
F NAND F = T
F NAND T = T
T NAND F = T
T NAND T = F
NOR is true only when neither argument is true.
F NOR F = T
F NOR T = F
T NOR F = F
T NOR T = F
There is no such thing as Xand or Xnot. There is Nand, which is the opposite of and
TRUE and TRUE : TRUE
TRUE and FALSE : FALSE
FALSE and TRUE : FALSE
FALSE and FALSE : FALSE
TRUE nand TRUE : FALSE
TRUE nand FALSE : TRUE
FALSE nand TRUE : TRUE
FALSE nand FALSE : TRUE
To add to this, since I was just dealing with it, if you are looking for an "equivalence gate" or a "coincedence gate" as your XAND, what you really have is just "equals".
If you think about it, given XOR from above:
F XOR F = F
F XOR T = T
T XOR F = T
T XOR T = F
And we expect XAND should be:
F XAND F = T
F XAND T = F
T XAND F = F
T XAND T = T
And isn't this exactly the same?
F == F = T
F == T = F
T == F = F
T == T = T
There's a simple argument to see where the binary logic gates come from, using truth tables, which have come up already.
There are six that represent commutative operations, in which a op b == b op a. Each binary operator has an associated three column truth table that defines it. The first two columns can be fixed for the defining tables for all the operators.
Consider the third column. It's a sequence of four binary digits. There are sixteen combinations, but the constraint of commutativity effectively removes one row from the truth tables, so it's only eight. Two more get knocked off because all truths or all falses isn't a useful gate. These are the familiar or, and, and xor, plus their negations.
This is what you are looking for:
https://en.wikipedia.org/wiki/XNOR_gate
Here is the logic table:
A B XOR XNOR
0 0 0 1
0 1 1 0
1 0 1 0
1 1 0 1
XNOR sometimes is called XAND.
In most cases you won't find an Xand, Xor, nor, nand Logical operator in programming, but fear not in most cases you can simulate it with the other operators.
Since you didn't state any particular language. I won't do any specific language either. For my examples we'll use the following variables.
A = 3
B = 5
C = 7
and for code I'll put it in the code tag to make it easier to see what I did, I'll also follow the logic through the process to show what the end result will be.
NAND
Also known as Not And, can easily be simulated by using a Not operator, (normally indicated as ! )
You can do the following
if(!((A>B) && (B<C)))
if (!(F&&T))
if(!(F))
If(T)
In our example above it will be true, since both sides were not true. Thus giving us the desired result
NOR
Also known as Not OR, just like NAND we can simulate it with the not operator.
if(!((A>B) || (B<C)))
if (!(F||T))
if(!(T))
if(F)
Again this will give us the desired outcomes
XOR
Xor or Exlcusive OR only will be true when one is TRUE but the Other is FALSE
If (!(A > C && B > A) && (A > C || B > A) )
If (!(F && T) && (F || T) )
If (!(F) && (T) )
If (T && T )
If (T)
So that is an example of it working for just 1 or the other being true, I'll show if both are true it will be false.
If ( !(A < C && B > A) && (A < C || B > A) )
If ( !(T && T) && (T ||T) )
If ( !(T) && (T) )
If ( F && T )
If (F)
And both false
If (!(A > C && B < A) && (A > C || B < A) )
If (!(F && F) && (F || F) )
If (!(F) && (F) )
If (T && F )
If (F)
And the picture to help
XAND
And finally our Exclusive And, this will only return true if both are sides are false, or if both are true. Of course You could just call this a Not XOR (NXOR)
Both True
If ( (A < C && B > A) || !(A < C || B > A) )
If ((T&&T) || !(T||T))
IF (T || !T)
If (T || F)
IF (T)
Both False
If ( (A > C && B < A) || !(A > C || B < A) )
If ( (F && F) || !(F ||F))
If ( F || !F)
If ( F || T)
If (T)
And lastly 1 true and the other one false.
If ((A > C && B > A) || !(A > C || B > A) )
If ((F && T) || ! (F || T) )
If (F||!(T))
If (F||F)
If (F)
Or if you want to go the NXOR route...
If (!(!(A > C && B > A) && (A > C || B > A)))
If (!(!(F && T) && (F || T)) )
If (!(!(F) && (T)) )
If (!(T && T) )
If (!(T))
If (F)
Of course everyone else's solutions probably state this as well, I am putting my own answer in here because the top answer didn't seem to understand that not all languages support XOR or XAND for example C uses ^ for XOR and XAND isn't even supported.
So I provided some examples of how to simulate it with the basic operators in the event your language doesn't support XOR or XAND as their own operators like Php if ($a XOR $B).
As for Xnot what is that? Exclusive not? so not not? I don't know how that would look in a logic gate, I think it doesn't exist. Since Not just inverts the output from a 1 to a 0 and 0 to a 1.
Anyway hope that helps.
The truth tables on Wiki clarify http://en.wikipedia.org/wiki/Logic_gate
There is no XAND, and that is the end of part 1 of the questions legitimacy.
[The point is you can always make do without it.]
I personally have mistaken XNOT (which also doesn't exist) for NAND and NOR which are theoretically the only thing you need to make all the other gates link
I believe the confusion stems from the fact that you can use either NAND or NOR (to create everything else [but they are not needed together]), so it's thought of as one thing that's both NAND and NOR together, which basically leaves the mind to supplant the remaining name XNOT which isn't used so it's what I wrongly call XNOT meaning it's either NAND or NOR.
I suppose one could also wrongly in quick discussion try to use the XAND like I do XNOT, to refer to the "a single gate (copied in various arrangements) makes all other gates" logical reality.
XOR (not neither and not both) B'0110' is the inverse
(dual) of IFF (if and only if) B'1001'.
XOR behaves like Austin explained, as an exclusive OR, either A or B but not both and neither yields false.
There are 16 possible logical operators for two inputs since the truth table consists of 4 combinations there are 16 possible ways to arrange two boolean parameters and the corresponding output.
They all have names according to this wikipedia article
The XOR definition is well known to be the odd-parity function.
For two inputs:
A XOR B = (A AND NOT B) OR (B AND NOT A)
The complement of XOR is XNOR
A XNOR B = (A AND B) OR (NOT A AND NOT B)
Henceforth, the normal two-input XAND defined as
A XAND B = A AND NOT B
The complement is XNAND:
A XNAND B = B OR NOT A
A nice result from this XAND definition is that any dual-input binary function can be expressed concisely using no more than one logical function or gate.
+---+---+---+---+
If A is: | 1 | 0 | 1 | 0 |
and B is: | 1 | 1 | 0 | 0 |
+---+---+---+---+
Then: yields:
+-----------+---+---+---+---+
| FALSE | 0 | 0 | 0 | 0 |
| A NOR B | 0 | 0 | 0 | 1 |
| A XAND B | 0 | 0 | 1 | 0 |
| NOT B | 0 | 0 | 1 | 1 |
| B XAND A | 0 | 1 | 0 | 0 |
| NOT A | 0 | 1 | 0 | 1 |
| A XOR B | 0 | 1 | 1 | 0 |
| A NAND B | 0 | 1 | 1 | 1 |
| A AND B | 1 | 0 | 0 | 0 |
| A XNOR B | 1 | 0 | 0 | 1 |
| A | 1 | 0 | 1 | 0 |
| B XNAND A | 1 | 0 | 1 | 1 |
| B | 1 | 1 | 0 | 0 |
| A XNAND B | 1 | 1 | 0 | 1 |
| A OR B | 1 | 1 | 1 | 0 |
| TRUE | 1 | 1 | 1 | 1 |
+-----------+---+---+---+---+
Note that XAND and XNAND lack reflexivity.
This XNAND definition is extensible if we add numbered kinds of exclusive-ANDs to correspond to their corresponding minterms. Then XAND must have ceil(lg(n)) or more inputs, with the unused msbs all zeroes. The normal kind of XAND is written without a number unless used in the context of other kinds.
The various kinds of XAND or XNAND gates are useful for decoding.
XOR is also extensible to any number of bits. The result is one if the number of ones is odd, and zero if even. If you complement any input or output bit of an XOR, the function becomes XNOR, and vice versa.
I have seen no definition for XNOT, I will propose a definition:
Let it to relate to high-impedance (Z, no signal, or perhaps null valued Boolean type Object).
0xnot 0 = Z
0xnot 1 = Z
1xnot 0 = 1
1xnot 1 = 0
Have a look
x y A B C D E F G H I J K L M N
· · T · T · T · T · T · T · T ·
· T · T T · · T T · · T T · · T
T · · · · T T T T · · · · T T T
T T · · · · · · · T T T T T T T
A) !(x OR y)
B) !(x) AND y
C) !(x)
D) x AND !(y)
E) !(y)
F) x XOR y
G) !(x AND y)
H) x AND y
I) !(x XOR y)
J) y
K) !(x) OR y
L) x
M) x OR !(y)
N) x OR y
OMG, a XAND gate does exist. My dad is taking a technological class for a job and there IS an XAND gate. People are saying that both OR and AND are complete opposites, so they expand that to the exclusive-gate logic:
XOR: One or another, but not both.
Xand: One and another, but not both.
This is incorrect. If you're going to change from XOR to XAND, you have to flip every instance of 'AND' and 'OR':
XOR: One or another, but not both.
XAND: One and another, but not one.
So, XAND is true when and only when both inputs are equal, either if the inputs are 0/0 or 1/1
First comes the logic, then the name, possibly patterned on previous naming.
Thus 0+0=0; 0+1=1; 1+0=1; 1+1=1 - for some reason this is called OR.
Then 0-0=0; 0-1=1; 1-0=1; 1-1=0 - it looks like OR except ... let's call it XOR.
Also 0*0=0; 0*1=0; 1*0=0; 1*1=1 - for some reason this is called AND.
Then 0~0=0; 0~1=0; 1~0=0; 1~1=0 - it looks like AND except ... let's call it XAND.

Write Shortage of if-else statement with two cases in one line

There is a javascript expression that assigns name variable to renamed variable.
It is always the same with one exclusion:
renamed = name == 'John' ? 'Johnny' : name;
However, I want two exclusions:
rename John to Johny
rename Alex to Alexander
All other names are assigned with no changes.
Is it possible to write this expression in one string?
renamed = (name == 'John' || name == 'Alex') ? <____> : name;
I need it to be done in one string.
Thank you.
(name === 'John' && 'Johny') || (name === 'Alex' && 'Alexander') || name;
If name is John, then it goes to the next part in the && expression and returns Johny.
If name is Alex, then the like in the first case returns Alexander.
If neither of them is true, then return the name as it is.
Demo
This solution works because, in JavaScript, && operator evaluates the expression in the left and if it is falsy then the value will be returned and the right hand side expression will not be evaluated at all.
If the expression in the left evaluates to be Truthy, then the expression on the right side will be evaluated and the result will be returned as it is. For example
console.log(1 && 2);
# 2
console.log(0 && 2);
# 0
It first evaluates 1, it is Truthy so it 2 is evaluated and the value is returned. That is why it prints 2.
In the second case, 0 is evaluated to be Falsy. So, it is returned immediately. That is why it prints 0.
The same way
console.log("John" && "Johny");
# Johny
John will be evaluated to be Truthy and so Johny will also be evaluated and returned. That is why we get Johny.
As per ECMA 5.1 Standard, Truthiness of an object will be decided, as per the following table
+-----------------------------------------------------------------------+
| Argument Type | Result |
|:--------------|------------------------------------------------------:|
| Undefined | false |
|---------------|-------------------------------------------------------|
| Null | false |
|---------------|-------------------------------------------------------|
| Boolean | The result equals the input argument (no conversion). |
|---------------|-------------------------------------------------------|
| Number | The result is false if the argument is +0, −0, or NaN;|
| | otherwise the result is true. |
|---------------|-------------------------------------------------------|
| String | The result is false if the argument is the empty |
| | String (its length is zero); otherwise the result is |
| | true. |
|---------------|-------------------------------------------------------|
| Object | true |
+-----------------------------------------------------------------------+
Note: The last line, Object, which includes both objects and Arrays.
renamed = (name == 'john') ? 'johney': (name == 'alex'? 'alexander' : name);
you can try this:
renamed = (name == 'John' ? 'Johnny' : (name == 'Alex' ? 'Alexander' : name));

What is the purpose of a plus symbol before a variable?

What does the +d in
function addMonths(d, n, keepTime) {
if (+d) {
mean?
The + operator returns the numeric representation of the object. So in your particular case, it would appear to be predicating the if on whether or not d is a non-zero number.
Reference here. And, as pointed out in comments, here.
Operator + is a unary operator which converts the value to a number. Below is a table with corresponding results of using this operator for different values.
+----------------------------+-----------+
| Value | + (Value) |
+----------------------------+-----------+
| 1 | 1 |
| '-1' | -1 |
| '3.14' | 3.14 |
| '3' | 3 |
| '0xAA' | 170 |
| true | 1 |
| false | 0 |
| null | 0 |
| 'Infinity' | Infinity |
| 'infinity' | NaN |
| '10a' | NaN |
| undefined | NaN |
| ['Apple'] | NaN |
| function(val){ return val }| NaN |
+----------------------------+-----------+
Operator + returns a value for objects which have implemented method valueOf.
let something = {
valueOf: function () {
return 25;
}
};
console.log(+something);
It is a unary "+" operator which yields a numeric expression. It would be the same as d*1, I believe.
As explained in other answers it converts the variable to a number. Specially useful when d can be either a number or a string that evaluates to a number.
Example (using the addMonths function in the question):
addMonths(34,1,true);
addMonths("34",1,true);
then the +d will evaluate to a number in all cases. Thus avoiding the need to check for the type and take different code paths depending on whether d is a number, a function or a string that can be converted to a number.

What's the difference between ( | ) and ( || )?

What's the difference between | and || in Javascript?
Furthermore, 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).
& is the bitwise AND operator
| is the bitwise OR operator
&& is the logical AND operator
|| is the logical OR operator
The difference is that logical operators only consider each input at face value, treating them as whole, while bitwise operators work at the bit level:
var thetruth = false;
var therest = true;
var theuniverse = thetruth && therest; //false
var theparallel = thetruth && thetruth; //true
var theindifferent = thetruth || therest; //true
var theideal = thetruth || thetruth; // false
var thematrix = 5346908590;
var mrsmith = 2354656767;
var theoracle = thematrix & mrsmith; //202445230
var theone = thematrix | mrsmith; //7499120127
Another difference is that || uses shortcut evaluation. That is, it only evaluates the right side if the left side is false (or gets converted to false in a boolean context, e.g. 0, "", null, etc.). Similarly, && only evaluates the right side if the left side is true (or non-zero, non-empty string, an object, etc.). | and & always evaluate both sides because the result depends on the exact bits in each value.
The reasoning is that for ||, if either side is true, the whole expression is true, so there's no need to evaluate any further. && is the same but reversed.
The exact logic for || is that if the left hand side is "truthy", return that value (note that it is not converted to a boolean), otherwise, evaluate and return the right hand side. For &&, if the left hand side is "falsey", return it, otherwise evaluate and return the right hand side.
Here are some examples:
false && console.log("Nothing happens here");
true || console.log("Or here");
false || console.log("This DOES get logged");
"foo" && console.log("So does this");
if (obj && obj.property) // make sure obj is not null before accessing a property
To explain a little more in layman's terms:
&& and || are logical operators. This means they're used for logical comparison;
if (a == 4 && b == 5)
This means "If a equals to four AND b equals to five"
| and & are bitwise operators. They operate on bits in a specific fashion which the wiki article explains in detail:
http://en.wikipedia.org/wiki/Bitwise_operation
In Javascript perspective, there is more to it.
var a = 42;
var b = "abc";
var c = null;
a || b; // 42
a && b; // "abc"
c || b; // "abc"
c && b; // null
Both || and && operators perform a boolean test on the first operand (a or c). If the operand is not already boolean (as it's not, here), a normal ToBoolean coercion occurs, so that the test can be performed.
For the || operator, if the test is true, the || expression results in the value of the first operand (a or c). If the test is false, the || expression results in the value of the second operand (b).
Inversely, for the && operator, if the test is true, the && expression results in the value of the second operand (b). If the test is false, the && expression results in the value of the first operand (a or c).
The result of a || or && expression is always the underlying value of one of the operands, not the (possibly coerced) result of the test. In c && b, c is null, and thus falsy. But the && expression itself results in null (the value in c), not in the coerced false used in the test.
Single | is bit wise OR operator .
If you do 2 | 3 , it converts to binary and performs OR operation.
01
11
Results in 11 equal to 3.
Where as || operator checks if first argument is true, if it is true it returns else it goes to other operator.
2 || 3 returns 2 since 2 is true.
one more point i want to add is || operator is used to assign default value in case the value you are assigning is undefined. So for Exapmle you are assigning a obj to some object test and if you dont want test to be undefined then you can do the following to ensure that value of test wont be undefined.
var test = obj || {};
so in case obj is undefined then test's value will be empty object.
So it is also being used for assigning default value to your object.

Categories