Nodejs module.exports传递问题（突然发现的问题到现在还没找到原因，求解）

Nodejs module.exports传递问题（突然发现的问题到现在还没找到原因，求解）

分装了一个Obj对象（User.js）

User = function(){
	var pri = {
		id : null,
		name : null
	}
	var pub = {
		setId : function(id){
			pri.id = id;
		},
		getId : function(){
			return pri.id;
		},
		setName : function(name){
			pri.name = name;
		},
		getName : function(){
			return pri.name;
		}
		toData : function(){
			return pri;
		}
	}
	return pub;
}
module.exports = User;
\n```

### 外部引用这个Obj（UserT.js）
** 在这里直接require引用进来就ok了，
不需要使用定义var User = require("../modules/User"); 
var user = new User();
而是可以直接使用对象。why？
**
```js\n
require("../modules/User");
UserT = (function(){
	var user = new User();
	function UserT(){
	}
	UserT.prototype.init = function(){
		user.setName("Michael");
	}

	UserT.prototype.getName = function(){
		console.log("message");
	}
});
module.exports = UserT;
\n```

### 比较奇怪的是下面的问题（Test.js）
** 
在这边可以无需引用User就可以直接得到User对象？？？
Why？
**
```js\n
require("./UserT");
console.log(UserT);
console.log(User);
\n```

5 回复

您的问题是关于 Node.js 中 module.exports 的传递机制，特别是在模块导出和引入时的一些行为。让我们来详细分析一下这个问题。

首先，您创建了一个名为 User.js 的模块文件，其中定义了一个构造函数 User，并将其导出为模块：

// User.js
User = function() {
    var pri = {
        id: null,
        name: null
    }
    var pub = {
        setId: function(id) {
            pri.id = id;
        },
        getId: function() {
            return pri.id;
        },
        setName: function(name) {
            pri.name = name;
        },
        getName: function() {
            return pri.name;
        },
        toData: function() {
            return pri;
        }
    };
    return pub;
};

module.exports = User;

在这个文件中，User 是一个构造函数，它返回一个包含公共方法的对象 pub，这些方法用于操作私有变量 pri。

接下来，您在 UserT.js 文件中导入了 User.js 并创建了一个新的构造函数 UserT，然后尝试通过 UserT 来实例化 User：

// UserT.js
require("../modules/User");

UserT = (function() {
    var user = new User();
    function UserT() {}
    UserT.prototype.init = function() {
        user.setName("Michael");
    };

    UserT.prototype.getName = function() {
        console.log(user.getName());
    };
});

module.exports = UserT;

这里需要注意的是，虽然 require("../modules/User") 导入了 User 模块，但并没有将 User 赋值给任何变量。这意味着 User 只在当前模块的作用域内可用，而不会暴露给其他模块。

最后，在 Test.js 文件中，您试图直接访问 UserT 和 User，但由于 User 未被正确暴露，所以会导致错误或未定义的行为：

// Test.js
require("./UserT");
console.log(UserT); // 正确输出 UserT 构造函数
console.log(User);  // undefined

要解决这个问题，您需要确保 User 在 UserT.js 中被正确地暴露出来。可以通过修改 UserT.js 如下：

// UserT.js
const User = require("../modules/User");

UserT = (function() {
    var user = new User();
    function UserT() {}
    UserT.prototype.init = function() {
        user.setName("Michael");
    };

    UserT.prototype.getName = function() {
        console.log(user.getName());
    };
});

module.exports = UserT;

这样，User 将会在 UserT.js 中被正确导入，并且可以在其他模块中访问到 User 对象。

总结一下，关键点在于确保在需要使用 User 的地方正确导入它，并且在模块之间正确地传递和暴露所需的对象。


单require = 直接插入。

User.js定义的User函数没有var

// 由于var 被你吃了，所以User被定义到了global上
User = function(){.....}
// 这一行去掉也不会影响你的结果
// module.exports = User;

我去，换markdown引擎了？？原来的``` 哪去了？换成什么了

111

全局惹的祸

从你的描述来看，User.js 文件中的 module.exports 设置了 User 函数，而你在 UserT.js 中通过 require 引入了 User.js 文件，但实际上没有使用 User 函数的实例，而是直接创建了一个新的 UserT 构造函数。

在 Test.js 中，你引入了 UserT.js 文件，并且直接使用了 UserT 和 User 变量。由于 UserT.js 文件中并没有对 User 进行导出或赋值，所以这里的 User 是未定义的。

为了更好地理解这个问题，可以重新组织一下代码结构，确保每个模块都正确地导出和引入所需的对象。

修改后的 User.js 文件

// User.js
const User = function() {
    const pri = {
        id: null,
        name: null
    };

    const pub = {
        setId(id) {
            pri.id = id;
        },
        getId() {
            return pri.id;
        },
        setName(name) {
            pri.name = name;
        },
        getName() {
            return pri.name;
        },
        toData() {
            return pri;
        }
    };

    return pub;
};

module.exports = User;

修改后的 UserT.js 文件

// UserT.js
const User = require("../modules/User");

const UserT = (function () {
    let user = new User();

    function UserT() { }

    UserT.prototype.init = function () {
        user.setName("Michael");
    };

    UserT.prototype.getName = function () {
        console.log(user.getName());
    };

    return UserT;
})();

module.exports = UserT;

修改后的 Test.js 文件

// Test.js
const UserT = require("./UserT");

const userT = new UserT();
userT.init();
userT.getName(); // 输出 "Michael"

在这个修改后的版本中：

  1. User.js 正确导出了 User 函数。
  2. UserT.js 通过 require 引入了 User.js 文件中的 User 函数，并正确创建了 UserT 构造函数。
  3. Test.js 引入了 UserT.js 文件，并创建了 UserT 的实例，然后调用了 init 和 getName 方法。

这样可以确保每个模块都能正确地导入和使用所需的对象。

回到顶部