Why Does ('0' ? 'A':'B') Behave Different Than ('0' == True ? 'A':'B')

Why does ('0' ? 'a' : 'b') behave different than ('0' == true ? 'a' : 'b')

First, for completeness:

('0' ? 'a' : 'b') 

String: The result is false if the argument is the empty String (its length is zero);
otherwise the result is true.

Two type conversions will take place here. We can follow this in the specification, section 11.9.3, The Abstract Equality Comparison Algorithm.

The operands are denoted as x and y (x == y).

In our case, x is a string ('0') and y is a Boolean (true). Hence step 7 is executed:

If Type(y) is Boolean, return the result of the comparison x == ToNumber(y).

Boolean: The result is 1 if the argument is true. The result is +0 if the argument is false.

'0' == 1

If Type(x) is String and Type(y) is Number, return the result of the comparison ToNumber(x) == y.

So the final comparison is

0 == 1

In JavaScript, why is 0 equal to false, but when tested by 'if' it is not false by itself?

The reason is because when you explicitly do "0" == false, both sides are being converted to numbers, and then the comparison is performed.

When you do: if ("0") console.log("ha"), the string value is being tested. Any non-empty string is true, while an empty string is false.

Equal (==)

If the two operands are not of the same type, JavaScript converts the operands then applies strict comparison. If either operand is a number or a boolean, the operands are converted to numbers if possible; else if either operand is a string, the other operand is converted to a string if possible. If both operands are objects, then JavaScript compares internal references which are equal when operands refer to the same object in memory.

(From Comparison Operators in Mozilla Developer Network)

Why == 0 is false in javascript?

Why “” == “0” is false in javascript?

Related questions:

• Why does ('0' ? 'a' : 'b') behave different than ('0' == true ? 'a' : 'b')
• '\n\t\r' == 0 is true?

If "" evaluates to false and "0" evaluates to false the logic predicts that it is the same as i write false == false

"" == false is coerced to 0 == 0

"0" == false is coerced to 0 == 0

false == false: same data type, hence the values are directly compared

As you can see "0" doesn't "evaluate" to false, it is converted to an integer, and that value is compared. ("" does evaluate to false (empty string) but when converted to a number, it is 0).

There is a big difference between converting a value to a boolean and comparing a value to a boolean. Most obvious example: !!"0" (true) and "0" == false (true).

When you compare values of different datatypes with loose comparison (==), they are always coerced to numbers (or potentially strings, if you are comparing an object with a string).

Have a look at the specification for more information about the comparison algorithm.

How are iloc and loc different?

Label vs. Location

The main distinction between the two methods is:

• loc gets rows (and/or columns) with particular labels.

• iloc gets rows (and/or columns) at integer locations.

>>> s = pd.Series(list("abcdef"), index=[49, 48, 47, 0, 1, 2]) 
49    a
48    b
47    c
0     d
1     e
2     f

>>> s.loc[0]    # value at index label 0
'd'

>>> s.iloc[0]   # value at index location 0
'a'

>>> s.loc[0:1]  # rows at index labels between 0 and 1 (inclusive)
0    d
1    e

>>> s.iloc[0:1] # rows at index location between 0 and 1 (exclusive)
49    a

def f(x):
    match x:
        case 'a':
            return 1
        case 'b':
            return 2
        case _:
            return 0   # 0 is the default case if x is not found

def f(x):
    return {
        'a': 1,
        'b': 2,
    }[x]

"true" == true // false
"foo"  == true // false
"0"    == true // false
"1"    == true // true

+------------+---------+--------+
|            |  A      |  B     |
+------------+---------+---------
|      0     | 0.626386| 1.52325|----axis=1----->
+------------+---------+--------+
             |         |
             | axis=0  |
             ↓         ↓

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

df["somecolumn"] = df["somecolumn"].astype(int)

var testVar;
console.log(testVar); //shows undefined
console.log(typeof testVar); //shows undefined