这是不好的做法：getMyObject（）。method（）

Question

Suppose I have a function which returns an object :

getMyObject(){
   //do stuff here
   return object;
}

Is it bad practice to call a method (that doesn't return anything) on the function name itself:

getMyObject().method();

instead of assigning a variable to the return object and then calling the method on that variable :

var returnedObject = getMyObject();
returnedObject.method();

I am working with an html page that has many nested frames, and I have access to a function that returns one of these frames. The frame might be used several times within other functions in my script, and I was wondering if it would be ok for me to access the frame in the way asked above, or if it would be better to declare a global variable.

* EDIT: * Ahh I haven't gotten a chance to use jQuery. Good to know!

Answer 1

Yes, this is perfectly OK. jQuery for example uses this as well. It returns objects on which you can call methods immediatley. This is called chaining.

Answer 2

In your example, method chaining is the better practice IMHO. If a function returns an object, upon which you want to call a method, but you do not need to reference that object after calling that method, don't assign it to a variable.

Also, jQuery code does this all the time (1):

$('#foo').on('click',function(){});
    /\      \\
    ||       \\  
    ||        \\
function call returns jQ object <============|
                  \\                        ||
                   \\call method "on" upon _||

(1)To clarify: I do not claim that all jQ methods return an object .attr() or .prop() don't. What I mean by "all the time" is actually that the scenario the OP describes is very common in jQ code (function call, invoke method on returned object):

var someString = $($('.foo').get(0)).attr('id');//tricky little bugger, this :)
var aBool = $('#foo').prop('checked');

Answer 3

Usually, no. Chaining method calls like that is usually simpler, more elegant, and easier to read. However, there are a few cases when it's better to use a variable.

1. If you use a method (or chain of methods) a lot of times, you can use a variable if it makes the code cleaner.
2. If the method takes a long time to process, it's better to cache the result. For example, if you have some method called calculateResults() , and it pulls data from a database, that takes some time. If the data doesn't change, you'll be incurring that cost for each call to the method. Better to store it in a variable and reuse it.
3. If the method has side effects, you should be careful about calling it more than once. Those side-effects will be inflicted each time you call it. Again, as an example, if you have a function like nextItem() that advances to the next item and returns it (a la Java iterators), then calling it more than intended will actually change the result. In this case, you have no choice but store the result, since calling it more than once will produce incorrect behavior.

Otherwise, chain away!