如何在RequireJS的method_Two.function_Two中调用method_One.function_One？

嘿，我来帮你捋捋这个问题～你当前写的this.method_One().function_One()是行不通的，因为在function_Two内部的this并不是指向你模块返回的那个对象，直接这么写会报this.method_One is not a function的错误。下面给你几种可行的实现方式：

方案一：缓存模块自身的引用 #

在模块内部提前把整个返回对象存起来，这样不管内部方法的上下文怎么变，都能稳定访问到目标方法：

define(function (require) { 
  var language = require('../language.config'); 
  // 先定义变量存储模块自身
  var module = { 
    method_One: function(){ 
      function function_One(data){ 
        return true; 
      } 
      return { function_One : function_One } 
    }, 
    method_Two: function(){ 
      // 提前获取function_One的引用
      var functionOne = module.method_One().function_One;
      function function_Two(data){ 
        var getValueOfFunctionOne = functionOne(data);
        // 这里可以处理拿到的结果
        return getValueOfFunctionOne; 
      } 
      return { function_Two : function_Two } 
    }, 
  };
  return module;
});

方案二：把function_One提升到模块外层（推荐） #

如果function_One不需要依赖method_One内部的局部变量，直接把它放到模块最外层是最简洁的方式，让两个方法都能直接访问：

define(function (require) { 
  var language = require('../language.config'); 

  // 把function_One移到模块外层，让所有内部方法都能访问
  function function_One(data){ 
    return true; 
  }

  return { 
    method_One: function(){ 
      return { function_One : function_One } 
    }, 
    method_Two: function(){ 
      function function_Two(data){ 
        var getValueOfFunctionOne = function_One(data);
        // 处理结果逻辑
        return getValueOfFunctionOne; 
      } 
      return { function_Two : function_Two } 
    }, 
  };
});

方案三：保存method_Two执行时的上下文 #

如果你一定要保留原有的嵌套结构，可以在method_Two内部用变量缓存当前的this（也就是模块对象），避免上下文丢失：

define(function (require) { 
  var language = require('../language.config'); 
  var module = { 
    method_One: function(){ 
      function function_One(data){ 
        return true; 
      } 
      return { function_One : function_One } 
    }, 
    method_Two: function(){ 
      var self = this; // 缓存method_Two执行时的上下文
      function function_Two(data){ 
        var getValueOfFunctionOne = self.method_One().function_One(data);
        // 处理结果逻辑
        return getValueOfFunctionOne; 
      } 
      return { function_Two : function_Two } 
    }, 
  };
  return module;
});

简单总结下：如果function_One不需要依赖method_One的局部变量，优先选方案二；如果必须保留function_One在method_One内部，方案一和三都能解决问题，其中方案一的可读性更强。

内容的提问来源于stack exchange，提问作者Joao Belem Jr.