The structure you're trying to achieve is already there for you:

You want:

myLoadFunction("myurlblabla", function() {..if success...});

But You already have it in:

myLoadFunction("myurlblabla").done(...) // nicer right ?

Using the deferred object, it already provides this:

Change the structure to return a deferred obj: ( or better see my edit)

myLoadFunction(url) 
{
 return $.post(url, function(data) {
 //something generic
 });
}
var R = myLoadFunction("myurlblabla");
R.done(function (){ do whatever}); // here is your actual question.
R.fail(function (){ do whatever});

Also don't mix responsibilites !

myLoadFunction should do load nothing more.

With the result of the load you can do other thing outside of this load factory function.

don't put logic there

edit

Regarding your comment :

but on this, would I allow to preserve the same answers for fail and the generic load? I just dont want to repeat the fail case nor the case when data is empty

You could set a function ( one time) which you will reference each time : ( don't put this on global scope. an object which contains these function would be great).

function myGENERICCallback(){ something I don't want to repeat}
function mydoneCallback(){ something I don't want to repeat}
function myfailCallback(){ something I don't want to repeat}
function myAlwaysCallback(){ something I don't want to repeat}

Now - you can do this :

var R = myLoadFunction("myurlblabla");
R.done(mydoneCallback); 
R.fail(myfailCallback);

And so your load function would look like :

myLoadFunction(url) 
{
 return $.post(url, myGENERICCallback); 
}

• myGENERICCallback would always be called
• you load function does not contain any logic
• you can have specific callbacks for each case
• you keep single responsibility principle.
• you don't repeat your code
• you only need to change in one place
• Other can subscribe to your deferred also.

You aren't far off, you just need to call the function you pass in:

myLoadFunction(url, callback) { 
 $.post(url, function( data ) {
 //something generic
 })
 .done(function(data) {
 callback(data);
 })
 .fail(function(data) {
 //something generic
 }); 
 }

Or you can pass it directly to the done function:

myLoadFunction(url, callback) { 
 $.post(url, function( data ) {
 //something generic
 })
 .done(callback)
 .fail(function(data) {
 //something generic
 }); 
 }

Just don't call it 'function' as that is a protected keyword in JavaScript so won't work.

I think you mean that you want to have standard calls to $.post and fail but use a different function for done each time.

Your code isn't too far out. One thing you can't do, though, is use function as a variable name: it's a protected word in Javascript. It's common to use fn instead.

You can then pass the function to done:

 myLoadFunction(url, fn) {
 $.post(url, function( data ) {
 //something generic
 })
 .done(fn)
 .fail(function(data) {
 //something generic
 });
 }

I'd do it this way (having control on both success and error handlers):

Snippet:

myLoadFunction(url, successCallback, errorCallback) {
 $.post(url, function( data ) {
 //something generic
 })
 .done(function(data) {
 //what I want to put on my caller function
 successCallback();
 })
 .fail(function(data) {
 //something generic
 errorCallback();
 });
}

Call:

var successHandlerHere = function() {
 console.log('success', arguments);
 },
 errorHandlerHere = function() {
 console.log('error', arguments);
 };
myLoadFunction("myurlblabla", successHandlerHere, errorHandlerHere);

• javascript