19

While reading through javascript codes I've been seeing the ! operator used for non boolean variables. Here is an example of code not used in.

/** * loads a resource from a url * @param {string} url the url of the resource to load * @param {string} relativeTo the url to load relative to * @param {function} callback thefunction to call once the file is loaded * @private */ GLGE.Wavefront.prototype.loadFile=function(url,relativeTo,callback){ if(this.relativeTo && !relativeTo) relativeTo=this.relativeTo; //<-- used on a string? else this.relativeTo=url; if(!callback) callback=this.loaded; //<-- used on a function? var req = new XMLHttpRequest(); if(req) { // request handling code } }; req.open("GET", url, true); req.send(""); } }

In this library I've seen many uses of this operator in this manner.

Can someone explain how/if the 'not' function of a string, object or function can be determined when it isn't one half of a Boolean set like the set; true and false?

Improve this question

5 Answers 5

Reset to default
20

Any falsy value will satisfy the if(!insert_variable_here) condition, including:

  • false
  • null
  • undefined
  • The empty string ''
  • The number 0
  • NaN

If callback return evaluates any of those values, the condition will be satisfied.

Even though null != false, the following will give you an alert:

x = null; if(!x) { alert('"!null" does evaluate to true'); }

Regardless of whether or not null != false makes sense to you or anyone else, the point is that in JavaScript null is a falsy value, and thus a value that would satisfy the condition in my first bit of code listed above. This, it seems, is the question you have asked--not, rather, if null should or should not == false.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

check my answer, interesting edge case on null.
11

In JavaScript, the unary negation operator (!) will convert its operand into a boolean based on the (somewhat confusing) rules of the language (e.g., ECMA-262 5th Edition). This article on JavaScript syntax shows some examples of how the type conversion happens.

Basically, it's an easy way to test for non-"truthiness"; seemingly false values (e.g. false, null, 0, NaN, the empty string, etc.) will be converted to false before being logically negated, and vice versa. You can test for "truthiness" explicitly by using the Boolean constructor:

Boolean(null); // => false Boolean(NaN); // => false Boolean(""); // => false Boolean(0); // => false Boolean(1); // = >true Boolean("123"); // => true Boolean(new Object()); // => true Boolean(function(){}); // => true
Improve this answer

Comments

3 
!object

will return false when the object is undefined, equals to null or 0, true otherwise.

Improve this answer

1 Comment

You forgot some falsy values.
0

Every variable and object can be equated to true or false. In the case of objects, undefined is false, anything else is true.

This actually gives some interesting edge cases http://www.ejball.com/EdAtWork/2005/02/15/JavaScriptWhatIsTrue.aspx

One that kinda blows my mind null != false evaluates to true

UPDATE

Note for all those people bashing me in the comments the ECMAScript specification on page 43 defines the toBoolean conversion of null as false. As we're only using a == and not doing a type check with === I find it very reasonably that I would expect null == false to evaluate to true.

That specification was published June this year so maybe this is a change, but it appears the specification writers come down on my side of the table in this debate.

Improve this answer

30 Comments

Yes, but null is still a falsy value in JavaScript.
@GarlicFries clearly only in some situations. null == false evaluates to false but !null does indeed evaluate to true.
Doesn't blow my mind at all... null does not equal false. This fact has been hammered into my brain since college.
But @Endophage, we're not talking about how it should work, rather about how it does work. ;)
May I suggest taking any further discussion to Stack Overflow Chat?
|
-3

It means NOT or false.

It is simply an alternative to:

if (callback != null) { //callback is not null } if (callback) { //callback is not null }

OR 

if (this.relativeTo && relativeTo == false) { //some code }
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.