// Base.js
module.exports = function(db) {
    this.db = db;
};
module.exports.prototype = {
    extend: function(properties) {
        var Child = module.exports;
        Child.prototype = module.exports.prototype; // [1]
        for(var key in properties) {
            Child.prototype[key] = properties[key];
        }
        return Child;
    },
    setDB: function(db) {
        this.db = db;
    },
    collection: function() {
        if(this._collection) return this._collection;
        return this._collection = this.db.collection('fastdelivery-
content');
    }
}
// 这么写的好处是，可以：var model = new (require "Base");  并且预留接口便于
定义派生对象

下面这段代码，看的我晕了半天。虽然我知道是定义一个派生对象，派生对象有
insert, update, getlist, remove这些方法。

// ContentModel.js
var Model = require("./Base"),
    crypto = require("crypto"),
    model = new Model();
var ContentModel = model.extend({  // [2]
    insert: function(data, callback) {
        data.ID = crypto.randomBytes(20).toString('hex');
        this.collection().insert(data, {}, callback || function(){ });
    },
    update: function(data, callback) {
        this.collection().update({ID: data.ID}, data, {}, callback ||
function(){ });
    },
    getlist: function(callback, query) {
        this.collection().find(query || {}).toArray(callback);
    },
    remove: function(ID, callback) {
        this.collection().findAndModify({ID: ID}, [], {}, {remove: true},
callback);
    }
});
module.exports = ContentModel;   // [3]

问题：
[1] 这行代码是否可以省略?
[2] extend方法什么时候执行？ 先于[3]语句，还是后于[3]语句。 执行extend方法
时， module.exports该指向谁？
--
修改:saynothing FROM 218.108.104.*
FROM 218.108.104.*

yes, it do the work actually.

see the attached file, decompress, and try:

[root@localhost home]$ cd test/
[root@localhost test]$ node base.model.test.js
model.db is defined
model.extend is defined
model2.db is defined
model2.myCustomModelMethod is defined
[root@localhost test]$ cat base.model.test.js
var Model = require("../models/Base"),
    dbMockup = {};

function test1() {
    var model = new Model(dbMockup);
    if (model.db) {
        console.log("model.db is defined");
    }
    if (model.extend) {
        console.log("model.extend is defined");
    }
}

function test2() {
    var model = new Model(dbMockup);
    var OtherTypeOfModel = model.extend({
        myCustomModelMethod : function() {}
    });

    var model2 = new OtherTypeOfModel(dbMockup);
    if (model2.db) {
        console.log("model2.db is defined");
    }
    if (model2.myCustomModelMethod) {
        console.log("model2.myCustomModelMethod is defined");
    }
}

test1();
test2();

【 在 XeCycle (据说是小 X) 的大作中提到: 】
: does this code actually work???  Child is not a new function but the
: original function, and code below just mutates the original function
--
修改:saynothing FROM 218.108.104.*
FROM 218.108.104.*
附件(889B) nodejs_example.tar.gz

确实有问题，依你之见，应该如何实现c/c++虚函数、多态特性?

var Model = require("../models/Base"),
    dbMockup = {};

function test() {
    var model = new Model(dbMockup);
    var ModelA = model.extend({
        myMethodA : function() {}
    });

    var ModelB = model.extend({
        myMethodB : function() {}
    });

    var model_a = new ModelA(dbMockup);
    var model_b = new ModelB(dbMockup);  // myMethodB方法写入到model_a中
    if (model_a.db) {
        console.log("model_a.db is defined");
    }
    if (model_a.myMethodA) {
        console.log("model_a.myMethodA is defined");
    }
    if (model_a.myMethodB) {
        console.log("model_a.myMethodB is defined");
    }
}

test();

[coolbar@localhost test]$ node test.js
model_a.db is defined
model_a.myMethodA is defined
model_a.myMethodB is defined

【 在 XeCycle (据说是小 X) 的大作中提到: 】
: try
: var ExtendA = Model.extend({ methodA })
: var ExtendB = Model.extend({ methodB })
: ...................
--
FROM 60.186.191.*

不是说模拟其他语言，而是js如何实现OO特性吧。

找到了对应的代码，只是还得看underscore如何封装的。。。

[coolbar@localhost controllers]$ cat Base.js
var _ = require("underscore");
module.exports = {
        name: "base",
        extend: function(child) {
                return _.extend({}, this, child);
        },
        run: function(req, res, next) {

        }
}

[coolbar@localhost controllers]$ cat Page.js
var BaseController = require("./Base"),
        View = require("../views/Base"),
        model = new (require("../models/ContentModel"));

module.exports = BaseController.extend({
        name: "Page",
        content: null,
        run: function(type, req, res, next) {
                model.setDB(req.db);
                var self = this;
                this.getContent(type, function() {
                        var v = new View(res, 'inner');
                        v.render(self.content);
                });
        },
        getContent: function(type, callback) {
                var self = this;
                this.content = {}
                model.getlist(function(err, records) {
                        if(records.length > 0) {
                                self.content = records[0];
                        }
                        callback();
                }, { type: type });
        }
});

[coolbar@localhost controllers]$ cat Home.js
var BaseController = require("./Base"),
        View = require("../views/Base"),
        model = new (require("../models/ContentModel"));

module.exports = BaseController.extend({
        name: "Home",
        content: null,
        run: function(req, res, next) {
                model.setDB(req.db);
                var self = this;
                this.getContent(function() {
                        var v = new View(res, 'home');
                        v.render(self.content);
                })
        },
        getContent: function(callback) {
            ...
        }
});

【 在 shaolin (漫漫当爹路) 的大作中提到: 】
: js就是js，干嘛非模拟其他语言啊。。
--
FROM 60.186.191.*

// Base.js
var _ = require("underscore");
module.exports = {
    name: "base",
    extend: function(child) {
        return _.extend({}, this, child);
    },
    run: function(req, res, next) {

    }
}

// test.js
function test() {
    var childA = BaseController.extend({name: "A", methodA: function(){
                                       console.log("methodA");
                                                   }
                                       });

    var childB = BaseController.extend({name: "B", methodB: function(){
                                       console.log("methodB");
                                                   }
                                       });

    console.log(childA.name);
    console.log(childB.name);
    if (childA.methodB === undefined && childB.methodA === undefined) {
        console.log("childA and childB are mutally with different methods");
    }
    childA.methodA();
    childB.methodB();
}
test()

$ node test.js
A
B
childA and childB are mutally with different methods
method A
method B


【 在 XeCycle (据说是小 X) 的大作中提到: 】
: you should not try that
--
修改:saynothing FROM 218.108.104.*
FROM 218.108.104.*