658

Is there a fast way of checking if an object is a jQuery object or a native JavaScript object?

example:

var o = {};
var e = $('#element');

function doStuff(o) {
    if (o.selector) {
        console.log('object is jQuery');
    }
}

doStuff(o);
doStuff(e);

obviously, the code above works but it's not safe. You could potentially add a selector key to the o object and get the same result. Is there a better way of making sure that the object actually is a jQuery object?

Something in line with (typeof obj == 'jquery')

Improve this question
1
  • 3
    As of jQuery 3.0 this is definitely not a correct way to check for an object being a jQuery object because the selector property was deprecated long ago and removed in 3.0. Even in earlier versions, a jQuery object can have an empty selector string, for example $(window) has no selector. Use instanceof instead. Commented Jul 18, 2016 at 15:43

9 Answers 9

Reset to default
957

You can use the instanceof operator:

if (obj instanceof jQuery){
    console.log('object is jQuery');
}

Explanation: the jQuery function (aka $) is implemented as a constructor function. Constructor functions are to be called with the new prefix.

When you call $(foo), internally jQuery translates this to new jQuery(foo)1. JavaScript proceeds to initialize this inside the constructor function to point to a new instance of jQuery, setting it's properties to those found on jQuery.prototype (aka jQuery.fn). Thus, you get a new object where instanceof jQuery is true.

1It's actually new jQuery.prototype.init(foo): the constructor logic has been offloaded to another constructor function called init, but the concept is the same.

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

9 Comments

So do you mean if (obj instanceof jQuery){...}?
@NigelAngel: Yup, that's what he means :)
This doesn't work in case of multiple jQuery instances on a page.
@CrescentFresh I mean if I have $ in my current namespace pointing to jQuery2 and I have an object from outer namespace (where $ is jQuery1) than I have no way to use instanceof for checking if this object is a jQuery object.
If you're not sure whether jQuery is loaded at the time of the if statement, you can extend the check to be typeof jQuery === 'function' && obj instanceof jQuery since jQuery does not have to be declared in order for the typeof operator to work without throwing an error.
|
117

You may also use the .jquery property as described here: http://api.jquery.com/jquery-2/

var a = { what: "A regular JS object" },
b = $('body');

if ( a.jquery ) { // falsy, since it's undefined
    alert(' a is a jQuery object! ');    
}

if ( b.jquery ) { // truthy, since it's a string
    alert(' b is a jQuery object! ');
}
Improve this answer

6 Comments

As David pointed out in the question, checking a property of a variable who's value could be null (i.e. if "a" or "b" were null) is not safe (it will throw a TypeError). Using "b instanceof jQuery" is better.
This way works if jQuery is not loaded, whereas b instanceof jQuery throws a ReferenceError if jQuery isn’t available on the page. Both approaches are useful in different cases.
More efficient maybe, but still not safe. It may require try ... catch, particularly in oldIE.
In cases where it's possible that jQuery is not loaded, you can use if ((typeof jQuery !== 'undefined') && (obj instanceof jQuery)) {...
Let's say you want to write a function that accepts both Element and jQuery objects to be passed. instanceof requires your library to take a dependency to jQuery while checking the jquery property doesn't. I prefer to check jquery and treat the object like any array-like type if it exists. This way you don't force the clients of your library to have jQuery as a dependency while allowing the ones that do to pass their jQuery objects and expect your function work.
|
32

Check out the instanceof operator.

var isJqueryObject = obj instanceof jQuery
Improve this answer

Comments

27

The best way to check the instance of an object is through instanceof operator or with the method isPrototypeOf() which inspects if the prototype of an object is in another object's prototype chain. 

obj instanceof jQuery;
jQuery.prototype.isPrototypeOf(obj);

But sometimes it might fail in the case of multiple jQuery instances on a document. As @Georgiy Ivankin mentioned:

if I have $ in my current namespace pointing to jQuery2 and I have an object from outer namespace (where $ is jQuery1) then I have no way to use instanceof for checking if that object is a jQuery object

One way to overcome that problem is by aliasing the jQuery object in a closure or IIFE

//aliases jQuery as $
(function($, undefined) {
    /*... your code */

    console.log(obj instanceof $);
    console.log($.prototype.isPrototypeOf(obj));

    /*... your code */
}(jQuery1));
//imports jQuery1

Other way to overcome that problem is by inquiring the jquery property in obj

'jquery' in obj

However, if you try to perform that checking with primitive values, it will throw an error, so you can modify the previous checking by ensuring obj to be an Object

'jquery' in Object(obj)

Although the previous way is not the safest (you can create the 'jquery' property in an object), we can improve the validation by working with both approaches:

if (obj instanceof jQuery || 'jquery' in Object(obj)) { }

The problem here is that any object can define a property jquery as own, so a better approach would be to ask in the prototype, and ensure that the object is not null or undefined 

if (obj && (obj instanceof jQuery || obj.constructor.prototype.jquery)) { }

Due to coercion, the if statement will make short circuit by evaluating the && operator when obj is any of the falsy values (null, undefined, false, 0, ""), and then proceeds to perform the other validations.

Finally we can write an utility function:

function isjQuery(obj) {
  return (obj && (obj instanceof jQuery || obj.constructor.prototype.jquery));
}

Let's take a look at: Logical Operators and truthy / falsy

Improve this answer

5 Comments

How does that improve safety, though? Non-jQuery objects with a jquery property would still be misdetected. I don't see what else using both approaches might "improve", either.
this is a easy way to check whether an object is a jQuery object, if for any reason you suspect that someone is creating objects with properties such as jquery, then you can create a validator more robust, i.e. checking for properties in the prototype: myObj.constructor.prototype.jquery or better yet, you can use the function Object.prototype.isPrototypeOf()
If you || any of that with a 'jquery' in Object(obj), though, it goes to drain, because it won't prevent non-jQuery objects with that property from passing the verification. I do believe checking for that property in the prototype improves the situation, though. Maybe you should add that to your answer! I don't think any other answer here mentions that possibility :)
isn't obj.__proto__.jquery instead of obj.constructor.prototype.jquery enough? just a bit short :)
@Axel yes, it works too :). I used constructor.prototype because obj is supposed to be an instance of the constructor, that is jQuery. On the other hand __proto__ is available for any kind of object.
5

For those who want to know if an object is a jQuery object without having jQuery installed, the following snippet should do the work :

function isJQuery(obj) {
  // All jQuery objects have an attribute that contains the jQuery version.
  return typeof obj === "object" && obj != null && obj.jquery != null;
}
Improve this answer

2 Comments

The && obj && is to check if obj is not null, because typeof null returns 'object' too. It could be obj !== null, but this is correct too.
@NunoRafaelFigueiredo Updated my seven years old answer, taking your remark in consideration, and improving comparison with obj != null which is better since it also excludes undefined.
4

However, There is one more way to check the object in jQuery.

jQuery.type(a); //this returns type of variable.

I have made example to understand things, jsfiddle link

Improve this answer

Comments

3 
return el instanceof jQuery ? el.size() > 0 : (el && el.tagName);
Improve this answer

1 Comment

To check for a DOM element, better use nodeType property, and to ensure a boolean value be returned, you can use double negation !!(el && el.nodeType)
2

You can check if the object is produced by JQuery with the jquery property:

myObject.jquery // 3.3.1

=> return the number of the JQuery version if the object produced by JQuery. => otherwise, it returns undefined

Improve this answer

Comments

-10 
var elArray = [];
var elObjeto = {};

elArray.constructor == Array //TRUE
elArray.constructor == Object//TALSE

elObjeto.constructor == Array//FALSE
elObjeto.constructor == Object//TRUE
Improve this answer

1 Comment

Code dumps without explanation are rarely useful. Please consider adding some context to your answer.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.