编程范式之编程范式

编程范式

程序语言特性

是否允许副作用
操作的执行顺序
代码组织
状态管理
语法和词法

编程范式

命令式：命令式编程是一种以计算机执行的命令为中心的编程范式，它主要分为面向过程和面向对象两种形式
1. 面向过程
  - 面向过程是一种以过程为中心的编程方式，它将问题分解为一系列步骤，通过函数的调用来实现程序的功能。面向过程的代码通常是一系列的命令，描述了计算机执行的具体步骤
2. 面向对象
  - 面向对象是一种以对象为中心的编程方式，它将数据和函数封装在一起，通过对象的交互来实现程序的功能。面向对象的代码通常是一系列的对象，描述了程序中的实体和它们之间的关系
声明式：声明式编程是一种以描述问题为中心的编程范式，它主要分为函数式和响应式两种形式
1. 函数式
  - 函数式编程是一种以函数为中心的编程方式，它将计算视为函数的应用，通过函数的组合来实现程序的功能。函数式的代码通常是一系列的函数调用，描述了计算的过程
2. 响应式
  - 响应式编程是一种以数据流为中心的编程方式，它将数据和函数封装在一起，通过数据的变化来触发函数的执行，实现程序的功能。响应式的代码通常是一系列的数据流，描述了数据的变化和处理

过程式

自顶而下

结构化编程

结构化编程是一种以结构为中心的编程范式，它主要关注程序的可读性、可维护性和可扩展性，通过一系列的结构化的控制流程来组织程序的逻辑。

结构化编程的主要特点是：

顺序结构：程序按照顺序执行，从上到下依次执行每一条语句。

选择结构：程序根据条件选择执行不同的语句，包括if语句、switch语句等。

循环结构：程序通过循环执行一组语句，包括for、while、do-while等循环语句。

结构化编程的优点在于：

代码清晰：结构化编程通过一系列的结构化控制流程来组织程序的逻辑，使得代码更加清晰易懂。

可维护性高：结构化编程使得代码的逻辑更加清晰，易于维护和修改。

可扩展性强：结构化编程使得程序的逻辑更加清晰，易于扩展和添加新的功能。

结构化编程是现代编程语言的基础，几乎所有的编程语言都支持结构化编程。结构化编程的思想也是面向对象编程、函数式编程等其他编程范式的基础。

JS中的面向过程

下方中结尾的;属于可加可不加的，但具体的规则如下：

行结束：当一行代码结束时，如果下一行代码不是有效的JavaScript代码（比如空行或注释），JavaScript解析器会自动插入分号。

语句块结束：当一段代码块结束时，如果下一行代码不是有效的JavaScript代码，JavaScript解析器会自动插入分号。

return语句：在return语句后面的表达式如果不是一行代码的开头，JavaScript解析器会自动插入分号。

break语句和continue语句：在break语句和continue语句后面如果不是一行代码的开头，JavaScript解析器会自动插入分号。

//进行导出

//数据
export let car = {
  meter:100,
  speed:10
};

//算法：函数可以看作面向过程中的算法
export function advanceCar(meter){
  while(car < meter){
    car.meter += car.speed;
  }
}

//导入(命名导入)，除此之外还有默认导入的方案
import { car , advanceCar } from ".car"//导入上方模块内容

function main(){
  console.log('before',car);
  
  advanceCar(1000)
  
  console.log('after',car)
}

模块化的方案不止ES6中的import导入export导出方案。在ES6正式出来之前，社区也有自己根据需求编写了其他的方案，目前还在流行的有CommonJS方案
ES6的模块化方案和CommonJS都是JavaScript中常见的模块化方案，它们都支持导入和导出模块的功能，但是在具体的语法和使用方式上有所不同。ES6使用import和export关键字来导入和导出模块，而CommonJS使用require和module.exports来导入和导出模块。ES6的导入和导出是静态的，不能在运行时动态导入和导出，而CommonJS的导入和导出是动态的，可以在运行时动态地导入和导出模块

// 导出
module.exports = {
  a: 1,
  foo: function() {},
  MyClass: class {}
};

// 导入
const { a, foo, MyClass } = require('./module.js');

面向过程式编程的缺点

数据与算法关联弱
不利于修改和扩充（可维护性差）：面向过程式编程缺乏封装性和抽象性，代码的耦合度高，修改代码时容易影响到其它部分的代码，导致维护性差
不利于代码重用（可拓展性差）：面向过程式编程很难对程序进行拓展，因为程序的逻辑分散在各个函数或过程中，很难进行整体性的拓展

面向对象的出现解决了这些问题

可读性好：面向对象编程将数据和函数封装在一起，代码的可读性好，易于理解整个程序的逻辑。
可维护性好：面向对象编程具有封装性和抽象性，代码的耦合度低，修改代码时只需要修改对象的内部实现，不会影响到其他部分的代码，导致维护性好。
可拓展性好：面向对象编程将数据和函数封装在一起，对象之间通过接口进行交互，易于对程序进行拓展

面向对象

封装

将数据和行为封装在一个对象中，通过访问控制来保护对象的数据和行为，防止外部对象直接访问和修改
封装的目的是隐藏对象的实现细节，提供一个统一的接口来访问对象的数据和行为，增加对象的安全性和可靠性，同时也提高了程序的可维护性和可扩展性

class Person {
  // 姓名、年龄和性别都为private，外部对象无法直接访问和修改
  #name;
  #age;
  #gender;

  constructor(name, age, gender) {
    this.#name = name;
    this.#age = age;
    this.#gender = gender;
  }

  // 公共的getter方法，用于访问和获取私有的数据成员
  getName() {
    return this.#name;
  }

  getAge() {
    return this.#age;
  }

  getGender() {
    return this.#gender;
  }

  // 公共的setter方法，用于修改私有的数据成员
  setName(name) {
    this.#name = name;
  }

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

  setGender(gender) {
    this.#gender = gender;
  }
}

// 创建一个Person对象，并访问和修改私有的数据成员
const person = new Person('小余', 20, '男');
console.log(person.getName()); // 输出：小余
person.setName('小满');
console.log(person.getName()); // 输出：小满

继承

无需重写的情况下进行功能扩充，这个写法在react中是经常使用的

class Student extends Person {
  #id;
  #score;

  constructor(name, age, gender, id, score) {
    // 调用父类的构造函数，初始化姓名、年龄和性别
    super(name, age, gender);
    this.#id = id;
    this.#score = score;
  }

  // 公共的getter方法，用于访问和获取私有的数据成员
  getId() {
    return this.#id;
  }

  getScore() {
    return this.#score;
  }

  // 公共的setter方法，用于修改私有的数据成员
  setId(id) {
    this.#id = id;
  }

  setScore(score) {
    this.#score = score;
  }
}

// 创建一个Student对象，并访问和修改私有的数据成员
const student = new Student('张三', 20, '男', '1001', 90);
console.log(student.getName()); // 输出：张三
console.log(student.getId()); // 输出：1001
student.setScore(95);
console.log(student.getScore()); // 输出：95

多态

不同的结构可以进行接口共享，进而达到函数复用

基于上面的Person类和Student类，创建一个printInfo函数，用于打印对象的信息。这个函数接受一个Person或Student对象作为参数，根据对象的类型，打印不同的信息

我们定义了一个printInfo函数，用于打印对象的信息。这个函数接受一个Person或Student对象作为参数，根据对象的类型，打印不同的信息。在函数中，我们使用了instanceof关键字，判断对象的类型，实现了多态

function printInfo(obj) {
  console.log(`姓名：${obj.getName()}，年龄：${obj.getAge()}，性别：${obj.getGender()}`);
  if (obj instanceof Student) {
    console.log(`学号：${obj.getId()}，成绩：${obj.getScore()}`);
  }
}

// 创建一个Person对象和一个Student对象，并分别调用printInfo函数
const person = new Person('张三', 20, '男');
const student = new Student('李四', 22, '女', '1001', 90);

printInfo(person); // 输出：姓名：张三，年龄：20，性别：男
printInfo(student); // 输出：姓名：李四，年龄：22，性别：女，学号：1001，成绩：90

依赖注入

去除代码耦合

依赖注入（Dependency Injection，简称DI）是一种设计模式，它的主要目的是为了解耦合，使得代码更加灵活、可扩展和可维护。在一个应用程序中，各个组件之间通常会存在一些依赖关系，例如一个类需要使用另一个类的对象或者数据。在传统的代码实现中，通常是在类内部创建和管理依赖的对象，这样会导致代码的耦合性很高，一旦依赖的对象发生变化，就需要修改大量的代码，导致代码的可维护性很差。

而依赖注入则是通过将依赖的对象从类内部移动到类的外部，在类的构造函数或者方法中注入依赖的对象。这样做的好处是，使得类与依赖的对象解耦合，使得代码更加灵活、可扩展和可维护。同时，依赖注入也使得代码的测试更加方便，因为测试代码可以注入不同的依赖对象，测试不同的场景和情况。

面向对象编程_五大原则

单一职责原则SRP(Single Responsibility Principle)

一个类只负责一个功能领域中的相应职责，或者可以定义为一个类只有一个引起它变化的原因。这个原则的目的是将职责分离，提高类的内聚性，降低类的耦合性，使得代码更加灵活、可维护和可扩展

开放封闭原则OCP(Open-Close Principle)

一个软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。这个原则的目的是使得代码更加灵活、可扩展和可维护，同时也能降低代码的风险和复杂度。通过使用抽象化和多态等技术，使得代码能够适应不同的需求和变化

里式替换原则LSP(the Liskov Substitution Principle LSP)

所有引用基类（父类）的地方必须能透明地使用其子类的对象。这个原则的目的是保证代码的正确性和可靠性，避免在子类中破坏父类的行为和逻辑。通过遵循这个原则，可以使得代码更加灵活、可扩展和可维护

依赖倒置原则DIP(the Dependency Inversion Principle DIP)

高层模块不应该依赖于底层模块，两者都应该依赖于抽象；抽象不应该依赖于具体实现，具体实现应该依赖于抽象。这个原则的目的是降低代码的耦合性，提高代码的灵活性和可扩展性。通过使用接口和抽象类等技术，使得代码能够适应不同的需求和变化

接口分离原则ISP(the Interface Segregation Principle ISP)

一个类不应该依赖于它不需要的接口，一个类应该只依赖于它需要的接口。这个原则的目的是降低代码的耦合性，提高代码的灵活性和可扩展性。通过将接口进行分离，使得代码更加灵活、可维护和可扩展

太多啦，后面的写不完啦，感觉并不是很重要，所以后续笔记就不加了

编程范式 | 青训营笔记

编程范式之编程范式

编程范式

程序语言特性

编程范式

过程式

自顶而下

结构化编程

JS中的面向过程

面向过程式编程的缺点

面向对象

封装

继承

多态

依赖注入

面向对象编程_五大原则