0

Possible Duplicate:
JavaScript === vs == : Does it matter which “equal” operator I use?

When comparing two operands of the same type for equality in JavaScript, using == or === doesn't make any conceptual difference, so I'm wondering which operator is actually faster when, like in my case, a JavaScript file has to be downloaded from a remote Internet location.

While the strict equality operator === may perform faster on many user agents, it also requires 8 more bits of uncompressed information to be carried along the network with the JavaScript file.

As it happens, today's average CPUs are much faster in executing several hundred conditional jumps than Internet connections are in delivering one single bit, so I'd be keen to using == instead of === and != instead of !== when possible. Yet I'm confused by reading so many blogs that recommend doing the opposite.

Is there any important point I'm missing?

Community
  • 1
  • 1
GOTO 0
  • 42,323
  • 22
  • 125
  • 158
  • 2
    i think its make conceptual difference – Samir Mangroliya Apr 21 '12 at 14:28
  • 3
    "8 more bits of uncompressed information" does not mean 8 more bits to send down the wire. If the JS file is served gzipped, that 1 extra character will make very little difference. – Matt Ball Apr 21 '12 at 14:32
  • 1
    loose and strict have ***different*** purpose. you can't compare two things that operate differently. – Joseph Apr 21 '12 at 14:34
  • -1 A question looking to compare these operators from a performance point of view is a bad question IMO. They are totally different. – kapa Apr 21 '12 at 14:39
  • @bažmegakapa: No, they're identical in the case where both operands are guaranteed to be of the same type, which is mentioned in the question. – Tim Down Apr 21 '12 at 14:43
  • @TimDown How do you guarantee that in Javascript? – kapa Apr 21 '12 at 14:45
  • @bažmegakapa: There are many cases where operand types are guaranteed. One is `typeof` comparisons: `typeof foo == "undefined"`. I could pick any number of other examples. Here's a random one: `var str = "whatever"; str.substring(0, 1) == "foo";` – Tim Down Apr 21 '12 at 14:49
  • @TimDown Yes, `typeof` is a good example. Still, the question does not make sense to me. – kapa Apr 21 '12 at 14:51
  • Thanks @TimDown, in fact, my operands are both numeric. – GOTO 0 Apr 21 '12 at 16:49
  • @Joseph, do you know of a case where loose and strict (un)equality operators behave differently although both operands are the same type? – GOTO 0 Apr 21 '12 at 16:53
  • @ft1: There isn't one. Follow through the steps in http://ecma262-5.com/ELS5_HTML.htm#Section_11.9 where the operands are of the same type. – Tim Down Apr 21 '12 at 17:14

4 Answers4

1

As you say, for comparison where both operands are guaranteed to be of the same type, the two operators are specified to perform precisely the same steps and, barring compiler optimizations, are likely to perform near enough identically. Therefore there is a slight advantage in terms of file size in using == over === in those cases.

However, some people argue that consistency is more important: === is usually closer to what you intend when testing equality, and only using === and !== is something many people find helpful and readable. Personally, I have the opposite rule and only use === when there is uncertainty about the types of the operands, but I wouldn't recommend either way over the other.

If you understand the differences between strict and non-strict equality and you're confident that using == and != won't cause you or anyone else working your code any problems reading and understanding code in the future, go ahead and use them.

Tim Down
  • 318,141
  • 75
  • 454
  • 536
1

Presumably blogs that recommend one over the other are doing so for reasons of logical consistency with analogous operations and not for speed. Trying to trim your Javascript programs to point of shaving off individual characters from the script is unwise; running it through minify or another automated tool before serving is one thing, but hand-tuning Javascript for minimum file size or for execution speed on the level of individual operands is an endless, thankless task that will make your site harder to maintain.

Use whichever operand makes more logical sense to you, so you won't be confused when you don't remember this line of inquiry two years from now.

Andrew Gorcester
  • 19,595
  • 7
  • 57
  • 73
1
var test="1";
console.log(test==1); // true
console.log(test===1); // false

== checks whether test has 1 or not but === checks whether test has 1 and also checks it's data type. In that case 2nd expression is false because it's data type is string (test is string) but the right hand operand is not string. The following test is different

var test=1;
console.log(test==1); // true
console.log(test===1);​ // true

Because test contains Integer 1 that evaluates to Boolean true and right hand operand is also same. === also checks whether both operands type.

The Alpha
  • 143,660
  • 29
  • 287
  • 307
1

If I may quote from Douglas Crockford's Javascript: The Good Parts:

JavaScript has two sets of equality operators: === and !==, and their evil twins == and !=. The good ones work the way you would expect. If the two operands are of the same type and have the same value, then === produces true and !== produces false. The evil twins do the right thing when the operands are of the same type, but if they are of different types, they attempt to coerce the values. The rules by which they do that are complicated and unmemorable ... The lack of transitivity is alarming. My advice is to never use the evil twins. Instead, always use === and !==.

Whether there is a performance difference or not, it would be difficult to justify the use of the "evil twins".

Anna Brenden
  • 3,837
  • 2
  • 21
  • 19
  • That doesn't apply when the operands are guaranteed to be of the same type, as mentioned in the question. – Tim Down Apr 21 '12 at 14:50
  • Because Javascript is a dynamic language, it's not always clear that the logical comparisons being made are of two objects with the same type. It's better not to take that risk in my opinion. – Anna Brenden Apr 21 '12 at 14:54
  • That's a reasonable attitude. I only mentioned it because the question seems to be asking specifically about when the operand types are the same. – Tim Down Apr 21 '12 at 14:58