CODEWITHSUNDEEP
javascriptoperators
Zeeno
Zeeno

Reputation: 2721

What does "!" operator mean in javascript when it is used with a non-boolean variable?

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?

Upvotes: 19

Views: 11475

Answers (5)

GarlicFries
GarlicFries

Reputation: 8323

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.

Upvotes: 20

Endophage
Endophage

Reputation: 21473

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.

Upvotes: 0

James Johnson
James Johnson

Reputation: 46047

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
}

Upvotes: -3

maerics
maerics

Reputation: 156414

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

Upvotes: 11

F-A
F-A

Reputation: 643

!object

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

Upvotes: 3

Related Questions