Nodejs Mongoose子模块如何调用父模块的同名方法？

Nodejs Mongoose子模块如何调用父模块的同名方法？

子模块用discriminator继承了父模块，子模块示例的一个方法是否能调用父模块的方法？

2 回复

当然可以！在Node.js中使用Mongoose时，可以通过继承来创建子模型（submodule），子模型可以访问父模型（parent module）的方法。下面我将通过一个简单的例子来展示如何实现这一点。

示例背景

假设我们有一个User模型作为父模型，它包含一些基本的用户信息。现在我们希望创建一个Admin模型作为子模型，继承自User模型，并且添加一些管理员特有的属性和方法。

父模型 User

首先，定义一个基础的User模型：

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true }
});

// 在User模型上定义一个方法
userSchema.methods.greet = function() {
    console.log(`Hello, ${this.name}!`);
};

const User = mongoose.model('User', userSchema);
module.exports = User;

子模型 Admin

接着，创建一个继承自User的Admin模型：

const mongoose = require('mongoose');
const User = require('./User'); // 引入父模型

// 创建一个区分器以区分不同类型的用户
const adminSchema = new mongoose.Schema({
    role: { type: String, default: 'admin' },
    permissions: [String]
}, { discriminatorKey: 'kind' });

// 使用父模型的schema作为基础
adminSchema.add(userSchema);

// 添加子模型特有的方法
adminSchema.methods.adminGreet = function() {
    console.log(`Hello, Admin ${this.name} with permissions: ${this.permissions.join(', ')}`);
};

const Admin = User.discriminator('Admin', adminSchema); // 使用discriminator创建子模型
module.exports = Admin;

使用子模型 Admin

现在我们可以使用Admin模型并调用从父模型继承来的greet方法以及自己定义的adminGreet方法：

const Admin = require('./Admin');

const admin = new Admin({
    name: 'John Doe',
    email: 'john@example.com',
    permissions: ['edit', 'delete']
});

admin.greet(); // 输出: Hello, John Doe!
admin.adminGreet(); // 输出: Hello, Admin John Doe with permissions: edit, delete

通过这种方式，子模型不仅能够访问父模型中的属性和方法，还可以扩展这些功能以满足特定需求。


在Node.js中使用Mongoose时，如果你通过discriminator机制创建了一个子模型，并希望该子模型能够调用父模型的方法，通常情况下，这些方法会被继承。但是，有时可能需要显式地调用父模型的方法。

假设我们有一个父模型ParentModel，以及一个通过discriminator创建的子模型ChildModel。我们想让ChildModel调用ParentModel中的某个方法。

首先，定义父模型：

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const parentSchema = new Schema({
    name: String,
});

parentSchema.methods.parentMethod = function() {
    console.log("Parent method called");
};

const ParentModel = mongoose.model('Parent', parentSchema);

然后，通过discriminator创建子模型：

const childSchema = new Schema({
    age: Number,
}, { discriminatorKey: 'kind' });

const ChildModel = ParentModel.discriminator('Child', childSchema);

// 现在ChildModel可以访问到parentMethod方法
ChildModel.findOne().then(doc => {
    doc.parentMethod(); // 这里会输出 "Parent method called"
});

在这个例子中，ChildModel自动继承了ParentModel的所有方法，包括parentMethod。因此，你可以直接在ChildModel实例上调用parentMethod。

如果存在重名方法并且你希望确保调用的是父模型的方法，你可以通过显式引用父模型来实现：

ChildModel.prototype.__proto__ = ParentModel.prototype;

或者在特定的情况下手动调用父类的方法：

ChildModel.parentMethod.call(this);

不过，一般情况下继承机制已经足够处理大多数场景，无需额外操作。

回到顶部