如何重复调用同一函数？

Question

I want to call a function twice but not through the traditional way. A quick example of what I would be looking to do is below:

    var myfunc = {
        copy: function(message){
            console.log(message);
        }
    }

    myfunc.copy('hello').copy('world');

    // result 'hello'
    // result 'world'

Is this even possible?

Answer 1

Yes, but you should return the correct object:

var myfunc = {
    copy: function(message){
        console.log(message);
        return this;
    }
};
myfunc.copy('hello').copy('world'); 
// hello
// world

This technique is also known as Method chaining .

Answer 2

No, this will fail because .copy() doesn't return anything, so the second .copy() would throw an undefined error.

Try this:

var myfunc = {
    copy: function(message){
        console.log(message); 
        return this;
    }
}

Answer 3

It's called method chaining. Here's a blog that talks about this that you should be able to read and use to answer your question.

Basically you will need to use return this; to return the current object so the next method can use it.

// define the class
var Kitten = function() {
  this.name = 'Garfield';
  this.color = 'brown';
  this.gender = 'male';
};

Kitten.prototype.setName = function(name) {
  this.name = name;
  return this;
};

Method chaining in JavaScript

Answer 4

You need to chain this, You can also look up to jquerys $.fn how they create method chaining simply return this as this object is your myFunc variable and is used again by the next function

var myfunc = {
   copy: function(message){
       console.log(message);
       return this; 
   }
};
myfunc.copy('hello').copy('world');

Answer 5

As other answers have pointed out, you need to return this in order to be able to call the same or additional functions on the same object.

You can do this a bit more easily (?) via a higher-order function which we will call "chainify", which takes care of returning this for you:

function chainify(fn) {
  return function() {
    fn.apply(this, arguments);
    return this;
  };
}

You can chainify your object methods in various ways, but here's one:

var myfunc = {
  init: function() {
    this.copy = chainify(this.copy);
    return this;
  },

  copy: function(message){
      console.log(message);
  }
}.init();

This has the minor advantage that each and every method does not need to be cluttered with the return this at the end, and you don't run the risk of forgetting to do so.

Answer 6

This is known a Builder design pattern where in you cascade methods. Google it if it helps.