Question

编辑
这是试图让我的问题更简单。

return this.someFunc(); == return { XXX:this.someFunc() };

我需要为XXX提供什么才能使此声明成立？

<小时/> 我正在尝试创建一个可以链接的函数。让我写一些假设的代码。（任何语法错误都会忽略，我正在快速输入，这只是概念代码。）假设所有函数都是本地定义的，也可以是全局定义的。：）

test = function(){
  this.someFunc = function(){
    this.retest = function(){
      //...code
    }
    //...code
  }
  this.someFunc2 = function(){
    //...code
  }
  return this.someFunc();
}

此功能允许我链接：test().retest();
但我想做的是返回多个项目。

test = function(){
  this.someFunc = function(){
    this.retest = function(){
      //...code
    }
    //...code
  }
  this.someFunc2 = function(){
    //...code
  }
  return { XXX:this.someFunc(), //What do I put for XXX
           next:this };
}

我想这样做是为了访问test（）提供的另一个函数：test().next.someFunc2();

所以我的问题是：
我仍然希望能够像这样链：test().retest();
但我必须这样做：test().XXX.retest();

在我的代码中，我可以用什么名字代替XXX来完成这个？这甚至可能吗？我已经尝试了0和default。谢谢你的帮助。

Answer 1

你可以制作这样的可链接函数：

var test = function(){

    var self = {};
    console.log('test called')

    function someFunc() {
        console.log('someFunc')
        return self;
    }

    function someOtherFunc() {
        console.log('someOtherFunc')
        return self;
    }   

    self.someFunc = someFunc;
    self.someOtherFunc = someOtherFunc;
    return self;

}

test().someFunc().someOtherFunc();

希望这有帮助

Answer 2

function test() {
   // when test() is called as a regular function
   // it's `this` will be `undefined` (in strict mode) or will refer to a global object
   // when test() is called with `new` operator
   // it's `this` will be an instance of `test` object
   if(!(this instanceof test)) {
      // create a new object
      return new test();
   }
   else {
      // this is a `new object` creation              
      console.log('new Test created');
   }
}

// declare functions which will be accessible on test object
test.prototype.someFunc = function() {
    console.log('someFunc');
    return this;
};

test.prototype.someFunc2 = function() {
    console.log('someFunc2');
    return this;
};

// declare a `chaining` function - will create a new `test` object
test.prototype.test = function() {
    return new test(); // new instance will be created
};

使用此代码，您现在可以运行以下代码

test().someFunc().someFunc2().test().someFunc().someFunc().test().test()

以下字符串将写在控制台

new Test created
someFunc
someFunc2
new Test created
someFunc
someFunc
new Test created
new Test created

Answer 3

你有一个范围问题 - 你不能在函数中引用 _NAME “test”，因为你不知道它是如何调用的。

如果你静态地这样做，你就可以这样做：

test = function(){

    this.someFunc = function(){ // blaaa
    };

    //...code 
    return { 
        OUTPUT: this.someFunc(), //What do I put for XXX
        test: this
    };
}

将导致：

test().test().test().test().OUTPUT (or something like this)

Answer 4

test = function(){

  var someFunc = function(){
      //...code
  }

  return {
      someFunc:someFunc,
      next:this
  }
}

编辑 - 为了清晰起见，已更新以反映您的问题更新。

Answer 5

这样做

test = function(){
  this.someFunc = function(){
    this.retest = function(){
      //...code
    }
    //...code
  }
  this.someFunc2 = function(){
    //...code
  }

  var ret = this.somefunc();
  ret.next = this;

  return ret;
}

编辑：这是一个更好，更有效的版本

test = function(){
  var ret;

  var func = function() {
    console.log("test func");
  }

  ret = function(){
    func();
    return ret;
  }

  ret.test = ret;
  ret.next = ret; // You can define an arbitrary number of members here
  ret.XXX = func(); // Like this, and you can still chain it like your question

  return ret;
}

Answer 6

不确定您的意图是什么，但这将是一个可链接的Test函数：

function Test(){
  Test.retest = Test.retest || function(){console.log('retested'); return Test;}
  return Test;
}
Test().retest().retest().retest().retest();
/* => result
 retested
 retested
 retested 
 retested
*/
// and
log(Test() === Test); //=> true

Answer 7

好吧，所以我觉得我理解你的问题，但我不确定（这里晚上很晚，所以给我一些信任）。我想你想要这样的行为：

test(); //is ["result1"]
test().retest(); //is ["result1", "result2"]
test().retest().retest(); //is ["result1", "result2", "result3"]

您可能希望返回对象而不是字符串，但这是一般的想法。而且代码变得非常简单：

var test = (function() {
    var results = ["result1"], 
        i = 1;

    results.retest = (function() {
        results.push("result" + (++i));
        return results;
    });

    return results;
});

test(); //is ["result1"]
test().retest(); //is ["result1", "result2"]
test().retest().retest(); //is ["result1", "result2", "result3"]

不确定这是不是您正在寻找的东西，但也许它会让您走上正轨。

Answer 8

由于您的示例不按您发布的方式工作，我认为您的意思是：

test = function(){
  this.someFunc = function(){
    this.retest = function(){
      //...code
    }
    //...code
  }
  this.someFunc2 = function(){
    //...code
  }
  return new this.someFunc();
}

在回复中注意新。现在，为了仍然能够链接你的功能，你必须返回：

return {retest: new this.someFunc().retest, next:this};

这样做可以让您拨打test().retest(); 我希望这会有所帮助。

JavaScript - 创建可链接函数时最好的方法是什么？

8 个答案: