This creates an empty jQuery-object:

$([])

Update: In newer versions of jQuery (1.4+), you can use:

$()

to create an empty container use $([]) edit: Took a look at your code. Even if you create the empty object correctly, once you append to it nothing will happen. You either need to create a container for them (span, div, whatever) or you need to add to the object like so: $foo = $('#foo'); $bar = $([]); $bar=$bar.add('

text1

'); $bar=$bar.add('

text2

'); $foo.append($bar); Note: Just running .add() on an object does not change that object, just adds to the current "chain". To make it permanent you need to assign the new "chain" to the original variable.

you can do this by jQuery.isEmptyObject()

Check to see if an object is empty (contains no properties).

jQuery.isEmptyObject( object )

Example:

jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false

from Jquery

Your problem here is that there aren't "null" jQuery objects that can't be appended to and "empty" ones that can be. You've already identified several ways to create an empty one, and while there may be more, it doesn't matter - what you're trying to do simply won't do what you expect it to, no matter how you start off, because...

...append() modifies the DOM, not the jQuery object. And an empty jQuery object has no DOM! Tomalak had the right idea, though you may not have understood it.

I'm going to make three observations about jQuery that you're probably already aware of, but which are useful in understanding the remainder of this answer and therefore may benefit future readers:

1. A jQuery object is fundamentally a set of DOM elements.
2. Some jQuery methods operate on the set, and some operate on the nodes in the set.
3. Some jQuery methods operate only on (or retrieve information only from) the first node added to the set.

With these three observations in mind, let's consider your example:

// 1. create an empty set somehow (doesn't matter how)
var $new = $();

// 2. iterate over something
$.each( ..., function( ... )
{
  // 3. construct a DOM fragment from HTML, and append it
  $new.append("<sometag>"); 
});

// 4. try to display HTML corresponding to the jQuery object
alert($new.html());  

In this example, step #3 will fail to do anything useful because the purpose of append() is to take whatever DOM elements it is given and append them as children to each DOM element in the set. Since $new is an empty set, there are no elements to append to, and... nothing happens. Step #1 is working just fine - but by creating a set without any DOM elements in it, you've set yourself up to fail when you try to use methods that exist to modify the DOM! Reference Observation #2... to modify the set, you need to call a method that actually operates on the set.

Ok, so let's say we use the set modification method add() instead:

  $new = $new.add("<sometag>");

Now we're good, right? Each pass through the loop will create a new jQuery object consisting of the previous set + a newly-created element. Well...

...this will just cause step #4 to do something odd. See, html() is one of those methods I mentioned in Observation #3 - it operates only on the first element in the set. So instead of a sequence ("<sometag><sometag><sometag>...") you're only gonna get a HTML representation of the element created on the first pass through the loop ("<sometag>"). Except... You're not even going to get that, because html() creates a representation of the element's children - so what you're really going to end up with is ""...

This was all just a big disappointment: you started off working with the set (Step #1), then tried to operate on the DOM (Step #3), and finished up by trying to pull data from one DOM element (that didn't exist) (and wouldn't have had any data if it did) (Step #4).

The solution you finally came up with isn't terrible - you're essentially opting to add one root element to the set starting out, and operate entirely on this DOM fragment until you're done adding new elements and are ready to operate on them. You've omitted it from your revised example, but html() would work too, since it would simply dump the contents of your root element.

But just to be complete, I'll give you a final example that works on the set, starting with an empty jQuery object:

var $new = $();
$.each( [1, 2, 3, 4], function(i, v)
{
  $new = $new.add("<div>");
});

alert($new.length == 4); // true

// alerts: <div></div><div></div><div></div><div></div>
alert($("<div>").append($new).html()); 

If you meant $([]), that's something from the old days where calling $() was actually equivalent to $(document) (which was an undocumented feature). So to get an empty set, you'd have to call $([]). This was changed in jQuery 1.4; the documented functionality of $() is now to return an empty set.

Passing objects to the jQuery constructor is an entirely different beast. $({}) doesn't create an empty jQuery object. It creates a jQuery object with a length of 1; the selected item is the object itself.

Passing JS objects to the jQuery constructor lets you take advantage of a more esoteric feature of jQuery: binding and triggering events on (non-DOM) objects.

For example:

var obj = { some: 'stuff' };

$(obj).on('someevent', function() { ... });

$(obj).trigger('someevent');

Either way, if your goal is to instantiate a new, empty jQuery object, use $().