Welcome to the Treehouse Community

Want to collaborate on code errors? Have bugs you need feedback on? Looking for an extra set of eyes on your latest project? Get support with fellow developers, designers, and programmers of all backgrounds and skill levels here with the Treehouse Community! While you're at it, check out some resources Treehouse students have shared here.

Looking to learn something new?

Treehouse offers a seven day free trial for new students. Get access to thousands of hours of content and join thousands of Treehouse students and alumni in the community today.

Start your free trial

JavaScript JavaScript Foundations Variables Null and Undefined

I'm Not getting it

The challenge question is "The identical() method is being called but the variables are not identical. See if you can fix the code."

This is what is in the code"

var myUndefinedVariable;
var myNullVariable= null;

if(myNullVariable == myUndefinedVariable) { 
identical ();
}

I'm not really understanding this at all.

5 Answers

Ken Alger
STAFF
Ken Alger
Treehouse Teacher

Gary;

The other somewhat difficult concept to grasp in this challenge, and topic overall, is the difference between undefined and null in JavaScript. The myNullVariable, in this example, was given a value of "null", so when JavaScript goes to look for a value it finds one. The myUndefinedVariable is not given a value, so when JavaScript goes to look for a value for it it cannot find one, therefore it should be expected to give a "not found exception" or some other way of presenting a state of "not foundness." In JavaScript that is equivalent to undefined.

The identity (===) operator behaves identically to the equality (==) operator except no type conversion is done, and the types must be the same to be considered equal.

Reference: Javascript Tutorial: Comparison Operators

The == operator will compare for equality after doing any necessary type conversions. The === operator will not do the conversion, so if two values are not the same type === will simply return false. It's this case where === will be faster, and may return a different result than ==. In all other cases performance will be the same.

Hopefully that helps.

Ken

The problem lies with the key difference between == and ===. Javascript does automatic type conversion when comparing to things using ==. This means something like:

var one = "1";
if (one == 1){
   //do something
}

would be true, and the code would execute. Values like undefined, null, 0 and I believe false, are consider equal when using the == comparison operator. It's actually a good idea to always use === which is what the challenge wants. This is one of those things in Javascript that you should definitely note, or else you may experience some bugs down the road.

if(myNullVariable === myUndefinedVariable) {
    identical();
}
Chris Shaw
Chris Shaw
26,676 Points

Values like undefined, null, 0 and I believe false, are consider equal when using the == comparison operator.

That's partially correct, null and undefined are the same as well as 0 and false but they they all don't with equal one another with the exception of null and undefined, 0 and false when using the double equals. See the below

null == false // false
null == undefined // true
undefined == false // false
false == 0 // true
0 == undefined // false
0 == null // false

However when using the strict type and value comparison operator all of the above changes to false.

null === false // false
null === undefined // false
undefined === false // false
false === 0 // false
0 === undefined // false
0 === null // false

Yeah, I was iffy about 0 and false when comparing them to undefined and null, since undefined and null work on objects, while 0 and false are usually used for values or data types. Thanks for clearing that up.

Chris Shaw
Chris Shaw
26,676 Points

since undefined and null work on objects

I think you're confusing JavaScript with another language as both undefined and null can't be compared to an Array nor an Object.

({}) == null // false
({}) == undefined // false
[] == null // false
[] == undefined // false

Looks like I need to go pick up a Javascript book again.

Chris Shaw
Chris Shaw
26,676 Points

The === operator will not do the conversion, so if two values are not the same type === will simply return false

You're almost there, the triple equals does both a type and value comparison, there would be no point to just comparing the two types as then we could put any values on the left and right side of the operator of the same type and get a pass.

Ken Alger
Ken Alger
Treehouse Teacher

Chris;

Right, it compares both type and value. What I was saying is that as it is checking if the types aren't the same, it doesn't care what the values are. If the types are the same, then it checks the values. Not sure what the last part of your statement is referring to.

Ken, the way you answered my question seems like I'm suppose to get it. I think I'm just tired or something. Its just not registering to me. I'm looking at Chris and Ricardo's conversation and its making realize I'm completely lost. I'm going to watch the video like 10 more times

Chris Shaw
Chris Shaw
26,676 Points

The most simple way I can answer the question is by the following.

  • == will always match two variables together regardless of whether they have the same type
  • === will never match two variables unless they both have the same type and value

I think I get you Chris. == would give two vars that are falsey's a True outcome, and === will give two vars that are falsey's a false outcome because the === knows that there are two different vars although they are both falsey's.such as undefined vs a null. I hope that made sense to you.