编程语言

中级语言

C：过程式语言代表

• 可对位，字节，地址直接操作

代码中的*(&x) = 20;语句可以直接修改变量x的值，说明C语言可以对位、字节、地址进行直接操作

• 代码和数据分离倡导结构化编程

代码中的#include <stdio.h>语句引入了标准输入输出库，说明C语言倡导代码和数据分离，支持结构化编程

• 功能齐全：数据类型和控制逻辑多样化

代码中声明了整型变量x和字符指针变量str，使用了printf函数进行输出，说明C语言的数据类型和控制逻辑非常多样化，功能齐全

• 可移植能力强

代码中使用了标准输入输出库，这使得代码可以在不同的平台上运行，说明C语言具有很强的可移植能力

高级语言

C++:面向对象语言代表

• C with Classes

C++最初是作为C语言的一种扩展，其基本语法与C语言相同，但增加了类、继承、多态等面向对象的特性，因此C++也被称为C with Classes

• 继承

代码中的class Student : public Person语句定义了一个Student类，它继承自Person类，这说明C++支持继承的特性

• 权限控制

代码中的public、protected和private关键字用来控制成员变量和成员函数的访问权限，这说明C++支持权限控制的特性

• 虚函数

代码中的virtual void sayHello()语句定义了一个虚函数，这说明C++支持虚函数的特性。虚函数可以实现多态，即在运行时根据对象的实际类型来调用相应的函数

• 多态

代码中的void sayHello() override语句实现了函数的重写，这说明C++支持多态的特性。在运行时，如果调用的函数是虚函数，那么实际调用的函数将根据对象的实际类型来确定

Lisp:函数式语言代表

• 与机器无关

• 列表：代码即数据

• 闭包

JavaScript：基于原型和头等函数的多范式语言

• 过程式

JavaScript最初被设计为一种过程式的脚本语言，它可以在Web浏览器中嵌入HTML页面，实现动态交互效果

• 面向对象

JavaScript是一种支持面向对象编程的语言，它支持类、对象、继承、封装等面向对象的特性。JavaScript中的对象是动态的，可以随时添加或删除属性和方法

• 函数式

JavaScript是一种支持函数式编程的语言，它的函数可以作为一等公民，可以赋值给变量，可以作为参数传递给其他函数，可以作为返回值返回给其他函数

• 响应式

JavaScript可以通过DOM操作实现响应式编程，可以实现页面元素的动态更新，与用户的交互效果等

编程范式

程序语言特性

1. 是否允许副作用

2. 操作的执行顺序

3. 代码组织

4. 状态管理

5. 语法和词法

常见编程范式

• 命令式：以计算机执行的命令为中心

面向过程：将问题分解为一系列步骤，通过函数的调用来实现程序的功能。

面向对象：将数据和函数封装在一起，通过对象的交互来实现程序的功能。

• 声明式：以描述问题为中心

函数式： 以函数为中心的编程方式，通过函数的组合来实现程序的功能。****

响应式： 以数据流为中心的编程方式，将数据和函数封装在一起，通过数据的变化触发函数执行。

过程式

自顶向下

结构化编程

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

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

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

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

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

JS中的面向过程

//进行导出

//数据

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的模块化方案和CommonJS都是JavaScript中常见的模块化方案，它们都支持导入和导出模块的功能，但是在具体的语法和使用方式上有所不同。ES6使用import和export关键字来导入和导出模块，而CommonJS使用require和module.exports来导入和导出模块。ES6的导入和导出是静态的，不能在运行时动态导入和导出，而CommonJS的导入和导出是动态的，可以在运行时动态地导入和导出模块

面向过程编程缺点

• 数据与算法关联弱

• 不利于修改和扩充

• 可维护性差：面向过程式编程缺乏封装性和抽象性，代码的耦合度高，修改代码时容易影响其他部分的代码，导致维护性差

• 不利于代码重用

• 可扩展性差：面向过程式编程很难对程序进行扩展，因为程序的逻辑分散在各个函数或过程中，很难进行整体性的扩展

 

• 面向对象的出现解决了这几个问题

可读性好：面向对象编程将数据和函数封装在一起，代码的可读性好，易于理解整个程序的逻辑。

可维护性好：面向对象编程具有封装性和抽象性，代码的耦合度低，修改代码时只需要修改对象的内部实现，不会影响其他部分的代码，导致维护性好。

可扩展性好：面向对象编程将数据和函数封装在一起，对象之间通过接口进行交互，易于对程序进行扩展。

面向对象编程

封装

• 将数据和行为封装在一个对象中，通过访问控制来保护对象的数据和行为，防止外部对象直接访问和修改

• 封装的目的是隐藏对象的实现细节，提供一个统一的接口来访问对象的数据和行为，增加对象的安全性和可靠性，同时也提高了程序的可维护性和可扩展性

继承

• 无需重写的情况下进行功能扩充

多态

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

依赖注入

依赖注入（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)

面向对象编程缺点

总是附带着所有它需要的隐含环境，会使得问题复杂化

函数式编程

函数的特点

• 函数是"一等公民"

• 纯函数/无副作用

• 高阶函数跟闭包

优势

• 可缓存

• 可移植

• 可测试

• 可推理

• 可并行

• 增加可测试性：新代码返回了一个新的对象，而不是修改原对象。因此可以更方便的进行测试，避免测试中对原对象造成修改引发副作用。

• 增加可维护性：新代码修改只会对函数中的方法进行变动，不会影响原对象，减少修改带来的影响。

• 增加可读性：将函数方法和原对象分离，代码含义更加明确

Currying

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

柯里化总结：

• 只传递给函数一部分参数来调用它，让它返回另一个函数处理剩下的参数

• 这个过程称为柯里化

柯里化的作用

• 在函数式编程中，我们其实往往希望一个函数处理的问题尽可能的单一，而不是将一大堆的处理过程交给一个函数来处理

• 那么我们是否就可以将每次传入的参数在单一的函数中进行处理，处理完后在下一个函数中再使用处理后的结果

单一职责原则：面向对象 -> 类 -> 尽量只完成一件单一的事情

Composition

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

• 比如我们现在需要对某一个数据进行函数的调用，执行两个函数fn1和fn2，这两个函数是依次执行的；

• 那么如果每次我们都需要进行两个函数的调用，操作上就会显得重复

• 那么是否可以将这两个函数组合起来，自动依次调用呢？

• 这个过程就是对函数的组合，我们称之为 组合函数（Compose Function）；

容器式编程

Functor

• 可以当做容器的类型，类型支持对容器内元素进行操作

• 常见的：functor：Array(Iterable).map，Promise.then

Monad

• 可以去除嵌套容器的容器类型

• 常见monad:Array.flatMapPromise.then

Applicative

• 直接对两个容器直接操作

Identity:Maybe(id).ap(v) === v;

Homomorphism:Maybe(f).ap(Maybe(x)) === Maybe(f(x));

Interchange:v.ap(Maybe(x)) === Maybe(f => f(x)).ap(v);

Composition:Maybe(compose).ap(u).ap(v).ap(w) ===u.ap(v.ap(w));

响应式编程

响应式编程（Reactive programming）是一种面向数据流和变化传播的声明式编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

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

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

  • 数据流

  • 操作符

    • 过滤

    • 合并

    • 转化

    • 高阶

观察者模式

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

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

• 松耦合：观察者模式将主题对象和观察者对象之间解耦，使得它们可以独立地变化和扩展。

• 可复用性：由于观察者对象可以动态地添加和删除，因此可以在不修改主题对象的情况下增加新的观察者对象，提高了代码的可复用性。

• 扩展性：在观察者模式中，可以灵活地添加和删除观察者对象，因此可以方便地扩展和修改系统的功能。

迭代器模式

迭代器模式（Iterator Pattern）是一种设计模式，它提供了一种顺序访问聚合对象中的元素，而不需要暴露聚合对象的内部表示。迭代器模式可以将遍历聚合对象的过程从聚合对象中分离出来，从而可以简化聚合对象的实现和遍历算法的实现。

在迭代器模式中，有两个核心角色：聚合对象和迭代器对象。聚合对象是一组对象的集合，它提供了一个方法来获取迭代器对象；迭代器对象则定义了访问和遍历聚合对象中元素的方法。

迭代器模式的优点包括：

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

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

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

• 类似于Promise和EventTraget超集

响应式编程的"compose"

• 合并

• 过滤

• 转化

• 异常处理

• 多播

领域特定语言

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

语言运行

lexer

SQL Token分类

• 注释

• 关键字

• 操作符

• 空格

• 字符串

• 变量

parser

上下文无关语法规则

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

parser_LL/LR

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

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

LL(K) > LR(1) > LL(1)

总结

编程范式中我们学习了编程语言的性质，也了解了各种编程中常用的思想。这有助于帮助我们构建编程思路并将其贯彻进实际应用中。而学习各种编程范式也可以让我们更好的进行项目的参与之中。