When is jQuery .map useful without .get?

The first thing to note, jQuery.fn.map is not the same as jQuery.map, which returns a plain array even if you apply it to a jQuery object.

In jQuery itself they sometimes chain jQuery.fn.map and jQuery.fn.filter. So map over a jQuery collection returns another jQuery collection, and they can call jQuery.filter on it without having to extend the result of map.

I thought it's just a side-effect of the implementation, but no, they do it on purpose, jQuery.fn.map internally calls jQuery.map and pushes the result onto the stack of matched elements.

Off of the top of my head, I can't see a really good use case for this feature. But you can, for example, return 0 or many nodes at once in your map function, and all these node will be put in a nice linear collection:

$elements.map(function() {
    return [document.createElement('div'),
            document.createElement('span')];
});

Map is useful when you must retrieve some property of a set of selected elements as an [].

For example, lets say I wanted to get the hrefs of the following a elements:

<a href="something1">Something</a>
<a href="something2">Something</a>
<a href="something3">Something</a>
<a href="something4">Something</a>

I would need to use map in this situation:

var arr = $("a").map(function(i,e){
    return e.href;
});

I may be confused (as evidenced by multiple edits), but my current understanding is that .map() returns a jQuery Object, which wraps a simple array, and provides other "helper" jQuery methods. It sounds like these helper functions are only really useful if the wrapped array is an array of DOM nodes. $.fn.get() will essentially unrwap the array for you. Therefore, I would think that you would NOT use get(), if your map function retuned actual DOM nodes rather other value types.

An (untested and probably a bit incorrect) example:

var $example = $('#foo').map(function() {
    if ($(this).innerHTML == "bar") {
        return this;
    }
});

From: http://ajpiano.com/when-to-use-jquerys-map-methods/

When you use jQuery.fn.map, the result is a jQuery object - an array of values with a set of functions made available by jQuery. Usually the array contains DOM nodes, but after using $.fn.map, it’s just an array of arbitrary values. Most people are familiar with using .get(index) to access the DOM node at a selected index, but when .get() is called with no arguments, it returns the entire underlying array. This means you can’t call jQuery methods on it anymore, but you can call Array.join, or any other Array method, which was probably the reason you wanted an array to begin with. So go out and .get() it!

The fact that .map() returns a jQuery object rather than a plain array may be useful when you want to keep using jQuery methods over the new collection. Here is an example (try it in your browser console) :

var $collection = $('#qinfo p:even').map(function () {
    return $(this).text();
});

var ucfirst = $collection.map(function () {
    return this.replace(/^./, function (fst) {
        return fst.toUpperCase();
    });
}).get();

var prefixed = $collection.map(function () {
    return 'prefix-' + this;
}).get();

console.log($collection.get());
console.log(ucfirst);
console.log(prefixed);

However, as mentionned in the comments, I assume that it's mainly a matter of code presentation. That said, .map() allows you to take advantage of function chaining. For that matter, we could go even further by wrapping .map() into a plugin. This way make things more readable and easily reusable :

$.fn.ucfirst = function () {
    return this.map(function () {
        return this.replace(/^./, function (fst) {
            return fst.toUpperCase();
        });
    });
};

$collection.ucfirst().each(function () {
    console.log(this.toString());
});

A thing to note though, .ucfirst() is intended to work with collections of strings, which is out of the scope of the original purpose of jQuery.