Question

我有一个Tag类和一个TagCollection类来存储多个标签。现在TagRepository类需要构造一个新的Tag对象以返回。但是，当我尝试在Tag内创建新的TagRepository时，会返回错误：

未定义标签

这是我将所有类包含在主要JavaScript文件中的方式：

const Tag = require('./class/Tag.js');
const TagCollection = require('./class/TagCollection.js');
const TagRepository = require('./repository/TagRepository.js');

我们通常如何处理？我可以只将所需的类包含在需要它们的类的构造函数中。但这在我必须包含多个类时显得很混乱。

我唯一想到的另一种解决方案是使所需的类成为全局类，在线阅读似乎被认为是不好的做法。下面我列出了所有课程

Tag.js

module.exports = class Tag {
  constructor() {
    this.id;
    this.name;
  }

  setId(id) {
    this.id = id;
  }

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

  getId() {
    return this.id;
  }

  getName() {
    return this.name;
  }
}

TagCollection.js

module.exports = class TagCollection {
  constructor() {
    this.tags = [];
  }

  addTag(tag) {
    this.tags.push(tag);   
  }

  setTags(tags) {
    this.tags = tags;
  }

  getTags(tags) {
    return this.tags;
  }
}

TagRepository.js

module.exports = class TagRepository {
  constructor(conn) {
    this.conn = conn;
  }

  getAll(callback) {
    let tempTagCollection = new TagCollection;

    this.conn.query(`SELECT \`id\`, \`name\` FROM \`tag\` WHERE 1`, function (error, tags) {
      tags.forEach((tag) => {
        //Create single tag 
        let tempTag = new Tag;

        //Set properties
        tempTag.setName(tag.name);
        tempTag.setId(tag.id);

        //Add single tag to collection
        tempTagCollection.addTag(tempTag);
      })

      callback(tempTagCollection);
    })
  }
}

Answer 1

我唯一想到的另一种解决方案是使所需的类成为全局类，在线阅读似乎被认为是不好的做法。

您是对的，应尽可能避免使用全局变量，因为这会增加代码的脆弱性和调试难度。

您可以将每个文件视为一个模块。我个人喜欢为每个类保留一个文件，因此我可以将类本身视为模块。在每个模块中，您应该require依赖的每个类。

因此，我将使用经典的Animal / Cat / Dog示例：

//Animal.js
module.exports = class Animal { ... }

//Cat.js
const Animal = require('./Animal');
class Cat extends Animal { ... }

//Dog
const Animal = require('./Dog');
class Dog extends Animal { ... }

在NodeJS中，即使Cat和Dog都需要Animal， Animal.js 仅执行一次。因此，每个需要Animal的模块都将获得相同的Animal类。

我可以将所需的类包含在需要它们的类的构造函数中。

我也避免这样做。在构造函数中使用require，即使仅使用require的文件只会在第一次使用时执行该文件，它仍然会通过节点文件解析算法，这是一个昂贵的过程，并且可能导致性能瓶颈。通常，最好将require语句放在构造函数或函数之外。将它们保留在文件的顶部，所有要求在应用程序加载时将运行一次。

现在您可以在TagRepository内部看到它需要两个类，即Tag和TagCollection类，我将如何处理？

在TagRepository.js内部，您只需要简单地包含2个include语句，每个文件一个，请参见下文。

const Tag = require('./Tag');
const TagCollection = require('./TagCollection.js');

// Both Tag and TagCollection is now usable

class TagRepository { ... }

有关NodeJS模块的更多信息，请参见

https://nodejs.org/dist/latest-v10.x/docs/api/modules.html#modules_modules

Answer 2

您需要在每个需要的文件中“需要”您需要的每个类，因此与（例如）PHP不同，您不能只对每个程序要求一次。

注入其他班级

2 个答案: