Can I use chained comparison operator syntax?

Question

In one JS library I saw such syntax:

if (val > 5 == t) { ... }

I tested this in console:

1 == 1 == 2 // false
2 > 1 == 1  // true
1 == 2 == 1 // false
1 == 1 == 1 // true
1 < 2 < 3   // true
1 > 2 > 3   // false

At first glance all correct. Can this be used?

Answer 1

1 == 1 == 2  // this
true == 2    // becomes this
1 == 2       // which becomes this, and is false

2 > 1 == 1  // this
true == 1   // becomes this
1 == 1      // which becomes this, and is true

...and so on.

If you're wondering about the conversion, you should do a search on the == operator, which uses the Abstract Equality Comparison Algorithm.

Answer 2

You not really comparing what you think you are comparing:

(1 == 1) == 2 // actually true == 2 which is false

(1 == 2) == 1 // actually false == 1 which is false

Which is why strict equality === will fail in all cases

Answer 3

Javascript does not support the chained comparison syntax used in mathematics:

1 < 2 < 3 // 1 is less than 2 which is less than 3.

Instead, it evaluates each comparison left to right, which can sometimes yield the same results as mathematical chained comparison, as do all your examples, but the process is different:

1 < 2 < 3 // "1 is less than 2" is true, true is 1, "1 is less than 3" is true.
          // Javascript returns true.

3 < 2 < 1 // "3 is less than 2" is false, false is 0, "0 is less than 1" is true.
          // Javascript returns true.

For this reason, it should be discouraged.

To answer your question, however, yes it can be used.

Answer 4

It's a correct syntax but not one I would recommend. What's happening, is probably:

if ((val > 5) == t) { ... }

I tested this in console:

(1 == 1) == 2 // false
(2 > 1) == 1  // true
(1 == 2) == 1 // false
(1 == 1) == 1 // true
(1 < 2) < 3   // true
(1 > 2) > 3   // false

With the boolean on the left implicitly converted to an int.

Answer 5

There is nothing to stop you from using such an adventurous syntax however do keep in mind that one of the most frequent reasons for having bugs inside JavaScript code is messing up operator precedence.

Therefore its strongly advised to explicitly define precedence by adding brackets to precedence groups in case they consist of more than simple mathematical expressions for which the precedence is clearly determinable.

Answer 6

Another concern is type coercion.
jslint output:

Error: Problem at line 2 character 13: Expected '===' and instead saw '=='.

if (val > 5 == t) { }