编程范式小记 | 青训营笔记

1 目标

• 编程范式学习

2 面向对象

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

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('xx', xx, 'x');
console.log(person.getName()); 
person.setName('xx');
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('xx', 21, '男', '2001', 10);
console.log(student.getName()); 
console.log(student.getId()); 
student.setScore(100);
console.log(student.getScore()); // 输出：100

• 多态
• 不同的结构可以进行接口共享，进而达到函数复用
  • 基于上面的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)

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

• 面向对象编程有什么缺点？为什么我们推荐函数式编程

  • 它总是附带着所有它需要的隐含环境
  • 你想要苹果，却得到一个人拿着苹果以及碰面的地点

3 函数式编程

• 函数的特点
  • 函数是"一等公民"
  • 纯函数/无副作用
  • 高阶函数跟闭包

优势

1. 可缓存
2. 可移植
3. 可测试
4. 可推理
5. 可并行

//代码1
const retireAge = 100
function retirePerson(p){
  if(p.age > retireAge){
    p.status = "retired"
  }
}

//代码2
function retirePerson(p){
  const retireAge = 100
    if(p.age > retireAge){
     return {
       ...p,
       status = "retired"
     }
  }
  return p
}

• 通过上述两段代码，可以看出代码二的如下优势：
  1. 增加了代码的可测试性：由于代码2中的函数返回了一个新对象，而不是直接修改原对象，因此可以更方便地进行单元测试，避免了测试过程中修改原对象的副作用。
  2. 增加了代码的可维护性：由于代码2中的函数不直接修改原对象(在React中这个称之为不可变的力量)，而是返回一个新对象，因此更容易维护和修改。如果要修改函数的行为，只需要修改函数内部的代码即可，不会对其他代码产生影响。
  3. 增加了代码的可读性：由于代码2中的函数返回了一个新对象，而不是直接修改原对象，因此代码的含义更加清晰明确。代码2中的函数使用了解构赋值和对象展开运算符，使得代码更加简洁、易读。

柯里化（Curry）函数

• 在计算机科学中，柯里化(英语：Currying)，又译为卡瑞化或加里化

  • 把接收多个参数的函数，变成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数，而且返回结果的新函数的技术

• 柯里化总结：

  • 只传递给函数一部分参数来调用它，让它返回另一个函数处理剩下的参数
  • 这个过程称为柯里化

• 柯里化的结构

//正常结构
function add(x,y,z){
    return x+y+z
}
var result = add(1,2,3)
console.log(result);

//柯里化
function sum(x){
    return function(y){
        return function(z){
            return x+y+z
        }
    }
}
var result1 = sum(1)(2)(3)
console.log(result1);

//简化柯里化代码
var sum2 = x=>y=>z=>{
    return x+y+z 
}

//再次简化var sum2 = x=>y=>z=>x+y+z
var result2 = sum2(1)(2)(3)

• 柯里化的作用

  • 在函数式编程中，我们其实往往希望一个函数处理的问题尽可能的单一，而不是将一大堆的处理过程交给一个函数来处理
  • 那么我们是否就可以将每次传入的参数在单一的函数中进行处理，处理完后在下一个函数中再使用处理后的结果

• 柯里化：单一职责原则(SRP)

  • 面向对象 -> 类 -> 尽量只完成一件单一的事情

组合函数

• 组合（Composition）函数是在JavaScript开发过程中一种对函数的使用技巧、模式

  • 在需要对某一个数据进行函数的调用，执行两个函数fn1和fn2，这两个函数是依次执行的：
    • 那么如果每次我们都需要进行两个函数的调用，操作上就会显得重复
    • 那么是否可以将这两个函数组合起来，自动依次调用呢？
  • 这个过程就是对函数的组合，我们称之为 组合函数（Compose Function）

function double(num){
    return num*2
}
function square(num){
    return num ** 2//平方
}
var count = 10
var result = square(double(count))
console.log(result);

//将double和square结合起来，实现简单的组合函数
function composeFn(m,n){
    return function(count){
        return n(m(count))
    }
}
var newFn = composeFn(double,square)
console.log(newFn(10));

容器式编程

• 可以当做容器的类型，类型支持对容器内元素进行操作
• 常见的：functor：Array(Iterable).map，Promise.then

a.b != null ? (a.b.c != null ?(a.b.c.d !== a.b.c.d.e ：null) : null) :null

4 响应式编程

• 响应式编程或反应式编程（英语：Reactive programming）是一种面向数据流和变化传播的声明式编程范式

• 这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

  • 通俗来说，响应式编程就是一种处理数据流的编程方式。
  • 我们可以把数据流看成一条河流，数据就像是水流一样从上游流向下游。
    • 在响应式编程中，我们可以方便地定义这条河流，并在河流中处理数据的变化，就像是在河流中处理水流一样，这样，我们就可以很方便地处理数据的变化，而不需要手动追踪和处理每一个数据变化的位置。

• 没有纯粹的响应式编程语言，我们需要借助工具库的帮忙，例如RxJS

• 异步/离散的函数式编程

  • 数据流
  • 操作符

• 响应式编程的操作符

  • 合并
  • 过滤
  • 转化
  • 异常处理
  • 多播

Observable——观察者模式

• 观察者模式（Observer Pattern）是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并自动更新。

• 在观察者模式中，有两个核心角色：主题对象和观察者对象。主题对象维护一个观察者列表，并提供添加、删除和通知观察者的方法；观察者对象则定义了接收通知并进行更新的方法。

• 观察者模式的优点包括：

  1. 松耦合：观察者模式将主题对象和观察者对象之间解耦，使得它们可以独立地变化和扩展。
  2. 可复用性：由于观察者对象可以动态地添加和删除，因此可以在不修改主题对象的情况下增加新的观察者对象，提高了代码的可复用性。
  3. 扩展性：在观察者模式中，可以灵活地添加和删除观察者对象，因此可以方便地扩展和修改系统的功能。

• 观察者模式在实际应用中广泛使用，例如GUI界面中的事件处理机制、微信公众号的订阅功能等等。

Observable——迭代器模式

• 迭代器模式（Iterator Pattern）是一种设计模式，它提供了一种顺序访问聚合对象中的元素，而不需要暴露聚合对象的内部表示。

  • 迭代器模式可以将遍历聚合对象的过程从聚合对象中分离出来，从而可以简化聚合对象的实现和遍历算法的实现。

• 在迭代器模式中，有两个核心角色：聚合对象和迭代器对象。

  • 聚合对象是一组对象的集合，它提供了一个方法来获取迭代器对象
  • 迭代器对象则定义了访问和遍历聚合对象中元素的方法。

• 迭代器模式的优点包括：

  1. 简化聚合对象的实现：由于迭代器模式将遍历聚合对象的过程从聚合对象中分离出来，因此可以简化聚合对象的实现，使其只需要关注自己的核心业务逻辑。

  2. 提高聚合对象的访问效率：在迭代器模式中，迭代器对象可以提供不同的遍历算法，从而可以针对不同的应用场景进行优化，提高聚合对象的访问效率。

  3. 提高代码的可复用性：由于迭代器模式将遍历算法从聚合对象中分离出来，因此可以方便地重用遍历算法，提高代码的可复用性。

  • 迭代器模式在实际应用中广泛使用，例如Java中的Iterator接口、C++中的STL迭代器等等。
  • 它可以帮助我们更加方便地遍历聚合对象中的元素，提高代码的可读性和可维护性。

• Observable——Promise和EventTraget超集

• 三类如下

• Monad——去除嵌套的Observable

5 构建领域特定语言

• 领域特定语言（Domain-Specific Language，简称DSL）是一种专门用于解决特定领域问题的编程语言。与通用编程语言相比，DSL更加关注于特定领域的问题，使得针对该领域的编程变得更加高效、简单和直观。

• DSL的设计是为了解决特定领域的问题，因此它可以更加贴近领域的需求和特点，提供更加便捷和高效的解决方案。DSL通常具有简单的语法和丰富的领域专业术语，使得开发人员可以更加专注于解决领域问题，而无需关注底层技术实现。

• DSL的应用场景包括但不限于：配置文件、工作流程、数据分析、模型定义等。在这些领域中，DSL可以提供更加高效、直观和易于维护的解决方案，提升开发效率和代码质量。

• HTML

• SQL

• 与之相对应的是General-purpose language(通用语言)

• C/C++

• JavaScript

  • 特定语言需要由通用语言实现，通用语言无法由特定语言实现

词法解析

SQL Token分类

• 注释
• 关键字
• 操作符
• 空格
• 字符串
• 变量

lexer

语法分析

语法规则

• 上下文无关语法规则
  • 推导式：表示非终结符到（非终结符或终结符）的关系。
  • 终结符：构成句子的实际内容。可以简单理解为词法分析中的token.
  • 非终结符：符号或变量的有限集合。它们表示在句子中不同类型的短语或子句。

Parser

• LL：从左到右检查，从左到右构建语法树

• LR：从左到右检查，从右到左构建语法树

• LL(K) > LR(1) > LL(1)，括号里的内容构建语法树需要向下看的数量

6 总结

• 个人对编程范式很不熟悉，要多看多复习
• 很开心自己的学习有所产出，以后复习时候也可以拿自己文章来复习

参考

• ⁣⁣‍‬​⁡‍⁡‬​⁢⁣‍⁢⁣⁢⁣​‬​⁢⁤‌​​​​⁤‌⁡​​‬⁡‍⁡​⁡​⁣‌⁡‌字节前端训练营 - 编程范式.pdf - 飞书云文档 (feishu.cn)
• 掘金计网相关文章