javascript 如何编写面向对象的 Node.js 模型

How to write a object oriented Node.js model

提问by Q Zhao-Liu

I am having a lot of trouble writing an object oriented Cat class in Node.js. How can I write a Cat.js class and use it in the following way:

我在 Node.js 中编写面向对象的 Cat 类时遇到了很多麻烦。如何编写 Cat.js 类并按以下方式使用它：

// following 10 lines of code is in another file "app.js" that is outside 
// the folder "model"
var Cat = require('./model/Cat.js');

var cat1 = new Cat(12, 'Tom');
cat1.setAge(100);
console.log(cat1.getAge()); // prints out 100 to console

var cat2 = new Cat(100, 'Jerry');
console.log(cat1.equals(cat2)); // prints out false

var sameAsCat1 = new Cat(100, 'Tom');
console.log(cat1.equals(sameAsCat1)); // prints out True

How would you fix the following Cat.js class I have written:

您将如何修复我编写的以下 Cat.js 类：

 var Cat = function() {
    this.fields = {
        age: null,
        name: null
    };

    this.fill = function (newFields) {
        for(var field in this.fields) {
            if(this.fields[field] !== 'undefined') {
                this.fields[field] = newFields[field];
            }
        }
    };

    this.getAge = function() {
        return this.fields['age'];
    };

    this.getName = function() {
        return this.fields['name'];
    };

    this.setAge = function(newAge) {
        this.fields['age'] = newAge;
    };

    this.equals = function(otherCat) {
        if (this.fields['age'] === otherCat.getAge() && 
            this.fields['name'] === otherCat.getName())  {
            return true;
        } else {
            return false;
        }
    };
};

module.exports = function(newFields) {
    var instance = new Cat();
    instance.fill(newFields);
    return instance;
};

回答by thefourtheye

If I were to design an object like this, then I would have done like this

如果我要设计一个这样的对象，那么我会这样做

function Cat(age, name) {       // Accept name and age in the constructor
    this.name = name || null;
    this.age  = age  || null;
}

Cat.prototype.getAge = function() {
    return this.age;
}

Cat.prototype.setAge = function(age) {
    this.age = age;
}

Cat.prototype.getName = function() {
    return this.name;
}

Cat.prototype.setName = function(name) {
    this.name = name;
}

Cat.prototype.equals = function(otherCat) {
    return otherCat.getName() == this.getName()
        && otherCat.getAge() == this.getAge();
}

Cat.prototype.fill = function(newFields) {
    for (var field in newFields) {
        if (this.hasOwnProperty(field) && newFields.hasOwnProperty(field)) {
            if (this[field] !== 'undefined') {
                this[field] = newFields[field];
            }
        }
    }
};

module.exports = Cat;     // Export the Cat function as it is

And then it can be used like this

然后它可以像这样使用

var Cat = require("./Cat.js");

var cat1 = new Cat(12, 'Tom');
cat1.setAge(100);
console.log(cat1.getAge());                 // 100

var cat2 = new Cat(100, 'Jerry');
console.log(cat1.equals(cat2));             // false

var sameAsCat1 = new Cat(100, 'Tom');
console.log(cat1.equals(sameAsCat1));       // true

var sameAsCat2 = new Cat();
console.log(cat2.equals(sameAsCat2));       // false

sameAsCat2.fill({name: "Jerry", age: 100});
console.log(cat2.equals(sameAsCat2));       // true

回答by vijay

There is error loop holein answers by @thefourtheye, I will describe those below

@thefourtheye 的回答中存在错误漏洞，我将在下面描述

Object modelling rules

对象建模规则

• Create empty new object

• Create Filled Object

• Only Initial object should be set by machine/code

• After Initial object assignment Any changes in your object should happen by user interaction only.

• After Initial object assignment Any changes in object by code without user intention is going to add some bugs

• 创建空的新对象

• 创建填充对象

• 机器/代码只应设置初始对象

• 初始对象分配之后 对象中的任何更改都应仅通过用户交互发生。

• 在初始对象分配之后，在没有用户意图的情况下通过代码对对象进行的任何更改都会增加一些错误

Problem Use case :

问题用例：

Eg - So when you create filled object , at that time if any property(somedate) is not having any value then due to below code the default value gets assigned to it(somedate) , which is against object modelling rules.

例如 - 因此，当您创建填充对象时，当时如果任何属性（某个日期）没有任何值，那么由于下面的代码，默认值被分配给它（某个日期），这违反了对象建模规则。

• Bug
• Constructor function is given Dual responsibilityto create new & filled object which he mixes up while creating filled object , And its going to make mistakes.

• Means there is some buggy code in your app that is going to set values by it self without users intention

  function Cat(age, name, somedate ) { // Accept name and age in the constructor this.name = name || null; this.age = age || null; this.somedate = somedate || new Date(); //there will be lots of usecases like this }

• 漏洞
• 构造函数被赋予双重责任来创建新的和填充的对象，他在创建填充对象时将其混淆，并且会出错。

• 意味着您的应用程序中有一些错误代码会在用户无意中自行设置值

  function Cat(age, name, somedate ) { // Accept name and age in the constructor this.name = name || null; this.age = age || null; this.somedate = somedate || new Date(); //there will be lots of usecases like this }

So to solve this Problem i use below JavaScript data model.

所以为了解决这个问题，我使用下面的 JavaScript 数据模型。

So it allows user to create filled object Or new objectintentionally only when need any one of them and not messing with each other

所以它允许用户只在需要它们中的任何一个而不是相互混淆时有意地创建填充对象或新对象

class Cat {
    constructor(){
        this.name = null;
        this.age = null;
    }

    initModel (data) {
        this.name = data.name;
        this.age = data.age
    }

    getAge () { return this.age;}

    setAge (age) { this.age = age; }

    getName () {this.name;}

    setName (name) {this.name = name;}

    equals (otherCat) {
        return otherCat.getName() == this.getName()
            && otherCat.getAge() == this.getAge();
    }

    fill (newFields) {
        for (let field in newFields) {
            if (this.hasOwnProperty(field) && newFields.hasOwnProperty(field)) {
                if (this[field] !== 'undefined') {
                    this[field] = newFields[field];
                }
            }
        }
    };
    
}


let cat1 = new Cat();
cat1.initModel({age : 12,name :'Tom'})
cat1.setAge(100);
console.log(cat1.getAge());                 // 100

let cat2 = new Cat();
cat2.initModel({age : 100,name : 'Jerry'})
console.log(cat1.equals(cat2));             // false

let sameAsCat1 = new Cat({age : 100,name : 'Tom'});
sameAsCat1.initModel({age : 100,name : 'Tom'})
console.log(cat1.equals(sameAsCat1));       // true

let sameAsCat2 = new Cat();
console.log(cat2.equals(sameAsCat2));       // false

sameAsCat2.fill({name: "Jerry", age: 100});
console.log(cat2.equals(sameAsCat2)); 

• Note :
• Constructoris only used For creating new Object
• InitModelis only used For creating filled Object

• 笔记 ：
• 构造函数仅用于创建新对象
• InitModel仅用于创建填充对象

Note Before down vote please add your doubt's in comments

注意在否决投票之前，请在评论中添加您的疑问

回答by Murugan Pandian

This code is working fine Person.js code here

这段代码在这里工作正常 Person.js 代码

  exports.person=function(age,name)
    {
        age=age;
        name=name;
        this.setAge=function(agedata)
        {
           age=agedata;
        }
        this.getAge=function()
        {
            return age;
        }
        this.setName=function(name)
        {
            name=name;
        }
        this.getName=function()
        {
            return name;
        }

};

call object code:

调用对象代码：

var test=require('./route/person.js');
var person=test.person;
var data=new person(12,'murugan');
data.setAge(13);
console.log(data.getAge());
data.setName('murugan');
console.log(data.getName());

回答by basarat

I would use TypeScript:

我会使用打字稿：

class Cat{
    fields = {
        age: null,
        name: null
    };

    fill(newFields) {
        for(var field in this.fields) {
            if(this.fields[field] !== 'undefined') {
                this.fields[field] = newFields[field];
            }
        }
    }

    getAge() {
        return this.fields.age;
    }

    setAge(newAge:number) {
        this.fields.age = newAge;
    }
}

export = Cat;

You can see the javascript it generates.

你可以看到它生成的javascript。

TypeScript can be used in both NodeJS and Browser.

TypeScript 可以在 NodeJS 和浏览器中使用。