我相信像我这样的人不知道设计软件中有什么坚实的原则？太糟糕了，我没有在大学或学位学习。但幸运的是，我自己做自学信息技术。到目前为止，我正在学习扎实的原则，以获得有关设计应用程序系统的酷技能或出色的知识 - 我认为。以下是关于编程语言中的单一责任原则（SRP）的几件事。我使用JavaScript代码示例。希望，您可以从我的帖子中存档一些内容。

你会读什么？

1. 什么是单一责任原则？
2. 为什么单一责任原则？
3. 当我们使用单一责任原则时？
4. JavaScript的示例代码。
5. 摘要。

1.什么是单一责任原则-SRP？

srp是一种软件设计原则，该原理指出，类，类，对象或模块等软件组件只能具有一个责任，只有一个理由可以更改。

换句话说，类或模块应只有一个主要目的。所有方法和属性都应与该责任有关。

它有助于降低模块或类之间的复杂性或耦合。使代码更易于理解，读取或维护，并使其更重复使用。

srp是面向对象设计的可靠原理的一部分。

srp于2003年首次在《敏捷软件开发，原理，模式和实践》一书中引入罗伯特·C·马丁（Robert C. Martin）（著名的软件工程师）作者。

2.为什么单一责任原则？

我们问自己，为什么我们需要在设计系统中遵循这一原则？根据我的经验，我正在从事很多项目。一个项目有几个人到一个大项目，有20人或更多的人一起工作。在这种情况下，我们将遇到有关可扩展，复杂的业务需求，维护，修复错误的问题。这就是为什么我们谈论原则-SRP。这是我们需要在SRP中遵循的几个重要原因：

• 鼓励模块化：通过每个模块或组件具有单一的目的。该系统更容易理解，阅读或维护，修复错误而不会影响系统的其他部分。
• 提高可维护性：因为每个模块都有一个责任
• 促进可重复性：模块只有一个目的，因此重复使用更容易。因为它们仅专注于特定任务，并且没有任何耦合或复杂性依赖性。
• 减少耦合：如果模块或组件具有很多依赖关系。它使应用程序更难更改或替换。因此，请尽可能保持模块。

3.当我们使用单一责任原则时？

SRP。它在以对象为导向的编程中很有用，其中类是系统的主要构建块。我们可以在以下情况下使用SRP：

1. 设计新模块：通过创建一个新的模块，我们应该考虑确保它具有单一的目的来做一件事情 - 定义明确的责任。
2. 重构现有模块：当我们重构现有模块时。考虑模块的耦合依赖性的复杂性。如果模块具有两个以上的用途。我们应该将它们分解为具有明确责任的小模块，并且不与其他模块重叠。
3. 设计软件体系结构：当我们设计软件系统的体系结构时。我们可以使用SRP来确保每个模块具有明确的责任，并且不会重叠其他模块。
4. 写作测试：写作测试是软件开发的一部分。我们可以使用SRP来确保每个测试都集中在模块逻辑或行为的单个方面。

4. JavaScript示例代码。

我们查看下面的示例：

function Question(questions) {
  this.questions = questions;

  this.printReport = () => {
    console.log("Printer called");
    console.log("3th party printer function called");
  };

  this.saveDatabase = (questions) => {
    console.log({questions});
    console.log(`Saved to database`);
  };

  this.remove = (question) => {
    console.log("removed question " + question);
    this.questions = this.questions.filter(q => q !== question);
    this.saveDatabase(this.questions);
  }

  this.add = (question) => {
    console.log("added " + question);
    this.questions.push(question);
        this.saveDatabase(this.questions);
  }
}

const q = new Question([
  "Question 1",
  "Question 2",
  "Question 3",
  "Question 4"
]);

q.remove("Question 1");
q.printReport();
q.add("Question 5");
q.printReport();

Question对象的目的是处理问题，例如保存，列出，删除问题，s和打印。在这种方法中，问题是printReport，saveDatabase，remove函数，以及系统的机制日志-console.log。

在这种情况下，我们将saveDatabase方法从postgres更改为mongodb，因此我们将更改对象参考的所有功能以保存数据方法。 printReport，remove和console.log与那样。

现在，查看下面的新代码：

function printer(data) {
    console.log("3th party function called");
  log(`[${new Date().toLocaleString()}]--------------------------------`);
  log(data, "info");
}

function log(message, type = "log") {
  console?.[type](message);
}

function saveDatabase(data) {
  log({data}, "info");
  log(`Saved data to database`, "info");
}

function Question(questions) {
  this.questions = questions;

  this.printReport = () => {
    printer(this.questions);
  };

  this.remove = (question) => {
    log("removed question " + question);
    this.questions = this.questions.filter(q => q !== question);
    saveDatabase(this.questions);
  }

  this.add = (question) => {
    log("added " + question);
    this.questions.push(question);
        saveDatabase(this.questions);
  }
}

const q = new Question([
    "Question 1",
    "Question 2",
    "Question 3",
    "Question 4"
]);

q.remove("Question 1");
q.printReport();
q.add("Question 5");
q.printReport();

printReport，saveDatabase，log函数移动到其他对象，实现了remove方法。因此，现在每个功能都做一件事。如果每个功能都更改逻辑，我们只能转到此功能，并根据另一个要求进行/更改逻辑，而无需修改其他功能并防止意外错误。

概括

有一些与单责任性原理有关的重要关键字（SRP）：

1. 责任：定义明确的责任。一个模块 - 一个目的 - 更改的原因。
2. 凝聚力：使设计系统成为无关的低粘性模块。
3. 耦合：使模块低耦合，该模块不依赖其他模块。
4. 关注点的分离：将大模块分解为小模块。每个模块都由系统的一小部分解决。
5. 重构：通过破坏对小和平的应用。重构更容易理解，阅读和维护模块而不会影响或影响其他模块。