diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-13 Nodejs\345\210\235\350\257\206.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-13 Nodejs\345\210\235\350\257\206.md"
deleted file mode 100644
index c085627ae27016e625edc5413bea91edf392c9d9..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-13 Nodejs\345\210\235\350\257\206.md"	
+++ /dev/null
@@ -1,27 +0,0 @@
-# 主要功能
-  
-   V8引擎本身使用了一些最新的编译技术。这使得用Javascript这类脚本语言编写出来的代码运行速度获得了极大提升，又节省了开发成本。对性能的苛求是Node的一个关键因素。 Javascript是一个事件驱动语言，Node利用了这个优点，编写出可扩展性高的服务器。Node采用了一个称为“事件循环(event loop）”的架构，使得编写可扩展性高的服务器变得既容易又安全。提高服务器性能的技巧有多种多样。Node选择了一种既能提高性能，又能减低开发复杂度的架构。这是一个非常重要的特性。并发编程通常很复杂且布满地雷。Node绕过了这些，但仍提供很好的性能。
-
-   Node采用一系列“非阻塞”库来支持事件循环的方式。本质上就是为文件系统、数据库之类的资源提供接口。向文件系统发送一个请求时，无需等待硬盘（寻址并检索文件），硬盘准备好的时候非阻塞接口会通知Node。该模型以可扩展的方式简化了对慢资源的访问， 直观，易懂。尤其是对于熟悉onmouseover、onclick等DOM事件的用户，更有一种似曾相识的感觉。
-    
-   虽然让Javascript运行于服务器端不是Node的独特之处，但却是其一强大功能。不得不承认，浏览器环境限制了我们选择编程语言的自由。任何服务器与日益复杂的浏览器客户端应用程序间共享代码的愿望只能通过Javascript来实现。虽然还存在其他一些支持Javascript在服务器端 运行的平台，但因为上述特性，Node发展迅猛，成为事实上的平台。
-
-# 运行环境
-
-   Node作为一个新兴的前端框架，后台语言，有很多吸引人的地方：RESTful API，单线程。
-
-   Node可以在不新增额外线程的情况下，依然可以对任务进行并发处理 —— Node.js是单线程的。它通过事件循环（event loop）来实现并发操作，对此，我们应该要充分利用这一点 —— 尽可能的避免阻塞操作，取而代之，多使用非阻塞操作。
-
-# 功能模块
-
-   Node使用Module模块去划分不同的功能，以简化应用的开发。Modules模块有点像C++语言中的类库。每一个Node的类库都包含了十分丰富的各类函数，比如http模块就包含了和http功能相关的很多函数，可以帮助开发者很容易地对比如http,tcp/udp等进行操作，还可以很容易的创建http和tcp/udp的服务器。
-
-   要在程序中使用模块是十分方便的，只需要如下：
-    
-   在这里，引入了http类库，并且对http类库的引用存放在http变量中了。这个时候，Node会在我们应用中搜索是否存在node_modules的目录，并且搜索这个目录中是否存在http的模块。如果Node.js找不到这个目录，则会到全局模块缓存中去寻找，用户可以通过相对或者绝对路径，指定模块的位置，比如：
-    
-         var myModule = require('./myModule.js');\
-
-
-   模块中包含了很多功能代码片断，在模块中的代码大部分都是私有的，意思是在模块中定义的函数方法和变量，都只能在同一个模块中被调用。当然，可以将某些方法和变量暴露到模块外，这个时候可以使用exports对象去实现。
-
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-14 Nodejs\345\237\272\346\234\254\344\272\206\350\247\243.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-14 Nodejs\345\237\272\346\234\254\344\272\206\350\247\243.md"
deleted file mode 100644
index 291bdc523827eb773b96a2034f5887034c62f12b..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-14 Nodejs\345\237\272\346\234\254\344\272\206\350\247\243.md"	
+++ /dev/null
@@ -1,52 +0,0 @@
-# 安装Node.js
-
- 目前Node.js的最新版本是13.5.x。首先，从Node.js官网下载对应平台的安装程序，网速慢的童鞋请移步国内镜像。
-
- 12.7
- 在Windows上安装时务必选择全部组件，包括勾选Add to Path。
-
- 安装完成后，在Windows环境下，请打开命令提示符，然后输入node -v，如果安装正常，你应该看到v7.6.0这样的输出：
-
- C:\Users\IEUser>node -v
- v7.6.0
-
- 继续在命令提示符输入node，此刻你将进入Node.js的交互环境。在交互环境下，你可以输入任意JavaScript语句，例如100+200，回车后将得到输出结果。
-
- 要退出Node.js环境，连按两次Ctrl+C。
-
- 在Mac或Linux环境下，请打开终端，然后输入node -v，你应该看到如下输出：
-
- $ node -v
- v10.15.3
-
- 如果版本号小于v7.6.0，说明Node.js版本不对，后面章节的代码不保证能正常运行，请重新安装最新版本。
-
-# npm
-
- npm其实是Node.js的包管理工具（package manager）。
-
- 其实npm已经在Node.js安装的时候顺带装好了。我们在命令提示符或者终端输入npm -v，应该看到类似的输出：
-
- C:\>npm -v
- 4.1.2
- 如果直接输入npm，你会看到类似下面的输出：
-
- C:\> npm
-
- Usage: npm <command>
-
- where <command> is one of:
-    ...
- 上面的一大堆文字告诉你，npm需要跟上命令。现在我们不用关心这些命令，后面会一一讲到。
- 
-# node程序小结
-
-+ 用文本编辑器写JavaScript程序，然后保存为后缀为.js的文件，就可以用node直接运行这个程序了。
-
-+ Node的交互模式和直接运行.js文件有什么区别呢？
-
-+ 直接输入node进入交互模式，相当于启动了Node解释器，但是等待你一行一行地输入源代码，每输入一行就执行一行。
-
-+ 直接运行node hello.js文件相当于启动了Node解释器，然后一次性把hello.js文件的源代码给执行了，你是没有机会以交互的方式输入源代码的。
-
-+ 在编写JavaScript代码的时候，完全可以一边在文本编辑器里写代码，一边开一个Node交互式命令窗口，在写代码的过程中，把部分代码粘到命令行去 验证，事半功倍！前提是得有个27'的超大显示器！
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-16 \345\237\272\346\234\254 \347\263\273\347\273\237\346\250\241\345\235\227.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-16 \345\237\272\346\234\254 \347\263\273\347\273\237\346\250\241\345\235\227.md"
deleted file mode 100644
index 3ebe5885bc042542d69aa1d003ff3be8afc6cb46..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-16 \345\237\272\346\234\254 \347\263\273\347\273\237\346\250\241\345\235\227.md"	
+++ /dev/null
@@ -1,111 +0,0 @@
-# 模块
-
- 为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Node环境中，一个.js文件就称之为一个模块（module）。
-
-# 使用模块的优点
-
- + 大大提高了代码的可维护性
-
- + 编写代码不必从零开始，当一个模块编写完毕，就可以被其他地方引用
-
- + 避免函数名和变量名冲突
- 
-# CommonJS规范
-
- 在这个规范下，每个.js文件都是一个模块，它们内部各自使用的变量名和函数名都互不冲突，例如，hello.js和main.js都申明了全局变量var s = 'xxx'，但互不影响。
-
- 一个模块想要对外暴露变量（函数也是变量），可以用module.exports = variable;，一个模块要引用其他模块暴露的变量，用var ref = require('module_name');就拿到了引用模块的变量。
-
-# 结论
-
- 要在模块中对外输出变量，用：
-```
- module.exports = variable;
-```
- 输出的变量可以是任意对象、函数、数组等等。
-
- 要引入其他模块输出的对象，用：
-```
- var foo = require('other_module');
-```
- 引入的对象具体是什么，取决于引入模块输出的对象。
-
-# global
-
-在前面的JavaScript课程中，我们已经知道，JavaScript有且仅有一个全局对象，在浏览器中，叫window对象。而在Node.js环境中，也有唯一的全局对象，但不叫window，而叫global，这个对象的属性和方法也和浏览器环境的window不同。进入Node.js交互环境，可以直接输入：
-```
-> global.console
-
-Console {
-  log: [Function: bound ],
-  info: [Function: bound ],
-  warn: [Function: bound ],
-  error: [Function: bound ],
-  dir: [Function: bound ],
-  time: [Function: bound ],
-  timeEnd: [Function: bound ],
-  trace: [Function: bound trace],
-  assert: [Function: bound ],
-  Console: [Function: Console] }
-```
-
-# process
-
-process也是Node.js提供的一个对象，它代表当前Node.js进程。通过process对象可以拿到许多有用信息
-
-```
-> process === global.process;
-true
-> process.version;
-'v5.2.0'
-> process.platform;
-'darwin'
-> process.arch;
-'x64'
-> process.cwd(); //返回当前工作目录
-'/Users/michael'
-> process.chdir('/private/tmp'); // 切换当前工作目录
-undefined
-> process.cwd();
-'/private/tmp'
-```
-
-# 判断JavaScript执行环境
-
-有很多JavaScript代码既能在浏览器中执行，也能在Node环境执行，但有些时候，程序本身需要判断自己到底是在什么环境下执行的，常用的方式就是根据浏览器和Node环境提供的全局变量名称来判断：
-```
-if (typeof(window) === 'undefined') {
-    console.log('node.js');
-} else {
-    console.log('browser');
-}
-```
-
-# fs
-
-Node.js内置的fs模块就是文件系统模块，负责读写文件。
-
-和所有其它JavaScript模块不同的是，fs模块同时提供了异步和同步的方法。
-
-回顾一下什么是异步方法。因为JavaScript的单线程模型，执行IO操作时，JavaScript代码无需等待，而是传入回调函数后，继续执行后续JavaScript代码。比如jQuery提供的getJSON()操作：
-```
-$.getJSON('http://example.com/ajax', function (data) {
-    console.log('IO结果返回后执行...');
-});
-console.log('不等待IO结果直接执行后续代码...');
-```
-而同步的IO操作则需要等待函数返回：
-```
-// 根据网络耗时，函数将执行几十毫秒~几秒不等:
-var data = getJSONSync('http://example.com/ajax');
-```
-
-同步操作的好处是代码简单，缺点是程序将等待IO操作，在等待时间内，无法响应其它任何事件。而异步读取不用等待IO操作，但代码较麻烦。
-
-## 异步还是同步
-
-在fs模块中，提供同步方法是为了方便使用。那我们到底是应该用异步方法还是同步方法呢？
-
-由于Node环境执行的JavaScript代码是服务器端代码，所以，绝大部分需要在服务器运行期反复执行业务逻辑的代码，必须使用异步代码，否则，同步代码在执行时期，服务器将停止响应，因为JavaScript只有一个执行线程。
-
-服务器启动时如果需要读取配置文件，或者结束时需要写入到状态文件时，可以使用同步代码，因为这些代码只在启动和结束时执行一次，不影响服务器正常运行时的异步执行。
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-17 http\346\250\241\345\235\227\344\270\216\347\275\221\347\253\231\346\220\255\345\273\272\346\225\231\347\250\213.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-17 http\346\250\241\345\235\227\344\270\216\347\275\221\347\253\231\346\220\255\345\273\272\346\225\231\347\250\213.md"
deleted file mode 100644
index 624820e7a61d2fb91c1c49a8f9132ba78ff3c055..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-17 http\346\250\241\345\235\227\344\270\216\347\275\221\347\253\231\346\220\255\345\273\272\346\225\231\347\250\213.md"	
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTTP服务器
-用Node.js实现一个HTTP服务器程序非常简单。我们来实现一个最简单的Web程序hello.js，它对于所有请求，都返回Hello world!：
-```
-'use strict';
-
-// 导入http模块:
-var http = require('http');
-
-// 创建http server，并传入回调函数:
-var server = http.createServer(function (request, response) {
-    // 回调函数接收request和response对象,
-    // 获得HTTP请求的method和url:
-    console.log(request.method + ': ' + request.url);
-    // 将HTTP响应200写入response, 同时设置Content-Type: text/html:
-    response.writeHead(200, {'Content-Type': 'text/html'});
-    // 将HTTP响应的HTML内容写入response:
-    response.end('<h1>Hello world!</h1>');
-});
-
-// 让服务器监听8080端口:
-server.listen(8080);
-
-console.log('Server is running at http://127.0.0.1:8080/');
-```
-在命令提示符下运行该程序，可以看到以下输出：
-```
-$ node hello.js 
-Server is running at http://127.0.0.1:8080/
-```
-不要关闭命令提示符，直接打开浏览器输入http://localhost:8080，即可看到服务器响应的内容
-
-同时，在命令提示符窗口，可以看到程序打印的请求信息：
-```
-GET: /
-GET: /favicon.ico
-```
-
-
-# 网站
-
-![](./img/wangzhan.png)
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-20 http\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-20 http\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"
deleted file mode 100644
index dfb50b8152a6e29dccc64c876b27ea71d5f8a09d..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-20 http\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"	
+++ /dev/null
@@ -1,99 +0,0 @@
-# 文件服务器
-
-让我们继续扩展一下上面的Web程序。我们可以设定一个目录，然后让Web程序变成一个文件服务器。要实现这一点，我们只需要解析request.url中的路径，然后在本地找到对应的文件，把文件内容发送出去就可以了。
-
-解析URL需要用到Node.js提供的url模块，它使用起来非常简单，通过parse()将一个字符串解析为一个Url对象：
-```
-'use strict';
-
-var url = require('url');
-
-console.log(url.parse('http://user:pass@host.com:8080/path/to/file?query=string#hash'));
-```
-结果如下：
-```
-Url {
-  protocol: 'http:',
-  slashes: true,
-  auth: 'user:pass',
-  host: 'host.com:8080',
-  port: '8080',
-  hostname: 'host.com',
-  hash: '#hash',
-  search: '?query=string',
-  query: 'query=string',
-  pathname: '/path/to/file',
-  path: '/path/to/file?query=string',
-  href: 'http://user:pass@host.com:8080/path/to/file?query=string#hash' }
-```
-处理本地文件目录需要使用Node.js提供的path模块，它可以方便地构造目录：
-```
-'use strict';
-
-var path = require('path');
-
-// 解析当前目录:
-var workDir = path.resolve('.'); // '/Users/michael'
-
-// 组合完整的文件路径:当前目录+'pub'+'index.html':
-var filePath = path.join(workDir, 'pub', 'index.html');
-// '/Users/michael/pub/index.html'
-```
-使用path模块可以正确处理操作系统相关的文件路径。在Windows系统下，返回的路径类似于C:\Users\michael\static\index.html，这样，我们就不关心怎么拼接路径了。
-
-最后，我们实现一个文件服务器file_server.js：
-```
-'use strict';
-
-var
-    fs = require('fs'),
-    url = require('url'),
-    path = require('path'),
-    http = require('http');
-
-// 从命令行参数获取root目录，默认是当前目录:
-var root = path.resolve(process.argv[2] || '.');
-
-console.log('Static root dir: ' + root);
-
-// 创建服务器:
-var server = http.createServer(function (request, response) {
-    // 获得URL的path，类似 '/css/bootstrap.css':
-    var pathname = url.parse(request.url).pathname;
-    // 获得对应的本地文件路径，类似 '/srv/www/css/bootstrap.css':
-    var filepath = path.join(root, pathname);
-    // 获取文件状态:
-    fs.stat(filepath, function (err, stats) {
-        if (!err && stats.isFile()) {
-            // 没有出错并且文件存在:
-            console.log('200 ' + request.url);
-            // 发送200响应:
-            response.writeHead(200);
-            // 将文件流导向response:
-            fs.createReadStream(filepath).pipe(response);
-        } else {
-            // 出错了或者文件不存在:
-            console.log('404 ' + request.url);
-            // 发送404响应:
-            response.writeHead(404);
-            response.end('404 Not Found');
-        }
-    });
-});
-
-server.listen(8080);
-
-console.log('Server is running at http://127.0.0.1:8080/');
-```
-没有必要手动读取文件内容。由于response对象本身是一个Writable Stream，直接用pipe()方法就实现了自动读取文件内容并输出到HTTP响应。
-
-在命令行运行node file_server.js /path/to/dir，把/path/to/dir改成你本地的一个有效的目录，然后在浏览器中输入http://localhost:8080/index.html：
-
-只要当前目录下存在文件index.html，服务器就可以把文件内容发送给浏览器。观察控制台输出：
-```
-200 /index.html
-200 /css/uikit.min.css
-200 /js/jquery.min.js
-200 /fonts/fontawesome-webfont.woff2
-```
-第一个请求是浏览器请求index.html页面，后续请求是浏览器解析HTML后发送的其它资源请求。
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-21 \347\273\203\344\271\240.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-21 \347\273\203\344\271\240.md"
deleted file mode 100644
index 6e6cdd561d67ba39862a8a33ca334525f9ed0523..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-21 \347\273\203\344\271\240.md"	
+++ /dev/null
@@ -1,74 +0,0 @@
-# 练习
-
-在浏览器输入http://localhost:8080/时，会返回404，原因是程序识别出HTTP请求的不是文件，而是目录。请修改file_server.js，如果遇到请求的路径是目录，则自动在目录下依次搜索index.html、default.html，如果找到了，就返回HTML文件的内容。
-
-```javascript
-'use strict'
-
-let http = require('http') // 导入模块
-let fs = require('fs')  //文件模块
-//创建服务器
-let server = http.createServer((req,res)=>{
-    //  获取url路径 localhost：8080/{url}
-    let url = req.url;
-    // /url -> url
-    url = url.substring(1,url.length);
-    //查看url文件状态
-    fs.stat(url,(err,stat)=>{
-        // 访问 localhost:8080
-        if(url=="") {
-            res.end("welcome!");
-        }else if(err) {//未找到文件
-            res.end("not find ");
-            return;
-        }else if(stat.isDirectory()){//不为空，并且有找到文件判断是否为目录
-            //在目录下依次搜索index.html、default.html
-            fs.readdir(url,(err,files)=>{//read dir 
-                let flag = true;
-                //查询有没有index.html
-                files.map(x=>{
-                    let path;
-                    if(x=="index.html"){
-                        path = `./${url}/${x}`;
-                        fs.readFile(path,"utf-8",(err,data)=>{
-                            res.end(data);//结束数据
-                        });
-                        flag=false; //找到index.html，未找到默认为true
-                        return;
-                    }
-                });
-                //查询default.html
-                if(flag){
-                    let flag = true;
-                    files.map(x=>{
-                        let path;
-                        if(x=="default.html"){
-                            path = `./${url}/${x}`;
-                            fs.readFile(path,"utf-8",(err,data)=>{
-                                res.end(data);
-                            });
-                            flag = false;//找到default.html
-                            return;
-                        }
-                    });
-                //未找到文件
-                    if(flag){
-                        res.end("404_Not_find")
-                    }
-                }
-            });
-            return;
-        }
-        //不是目录
-        fs.readFile(url,(err,data)=>{
-            if(err){
-                res.end("404");
-                return;
-            }
-            res.end(data);
-        })
-    })
-});
-server.listen("8080");
-```
-![效果图](./img/2023-02-20.png)
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-23 promise async await .md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-23 promise async await .md"
deleted file mode 100644
index 549868bd3372168b666686e0eb15ab8e12544c2f..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-23 promise async await .md"	
+++ /dev/null
@@ -1,354 +0,0 @@
-# promise用来做什么？
-
-我们的需求是一次的去执行异步代码
-
-我们的做法是在异步请求成功后的回调函数里，执行下一个异步请求
-
-但是这样就出现了回调地狱（回调函数中嵌套了回调函数，代码的阅读性 低，维护不变，让人看着害怕）
-
-promise就是用来解决回调地狱的
-
-    回调地狱示例：
-
-```js
-
-// 需求：一次的读取a,b,c这三个文件
-const fs = require("fs");
-
-// 读a文件
-fs.readFile(`${__dirname}/etc/a.txt`, "utf-8", (err, data) => {
-  if (err) {
-    console.log(err);
-  } else {
-    console.log(data);
-    // 读b文件
-    fs.readFile(`${__dirname}/etc/b.txt`, "utf-8", (err, data) => {
-      if (err) {
-        console.log(err);
-      } else {
-        console.log(data);
-        // 读c文件
-        fs.readFile(`${__dirname}/etc/c.txt`, "utf-8", (err, data) => {
-          if (err) {
-            console.log(err);
-          } else {
-            console.log(data);
-          }
-        });
-      }
-    });
-  }
-});
-
- ```
-
-#  promise工作流程
-
-es6的语法，es6.ruanyifeng.com
-
-Promise对象是一个构造函数 ，用来生成promise实例
-
-Promise构造函数接受一个函数作为参数
-
-这个作为参数的函数，又有两个参数，这两个参数分别是resolve和reject
-
-这两个参数它们也是函数，只不过这两个函数由 javascript 引擎提供，不用自己部署
-
-异步操作成功后调用resolve()方法，他内部调用了then()里面的第一个参数函数
-
-异步操作成功后调用reject()方法，他内部调用了then()里面的第二个参数函数.
-
-```js
-const fs = require("fs");
-// 调用Promise构造函数，创建一个promise的实例
-let p = new Promise((resolve, reject) => {
-  // 写异步操作（读文件）
-  fs.readFile(`${__dirname}/etc/a.txt`, "utf-8", (err, data) => {
-    if (!err) {
-      // 操作成功（读文件成功）
-      resolve(data); // 调用resolve方法
-      // 调用then()里面的第一个参数函数
-    } else {
-      reject(err); // 调用reject方法
-      // 调用then()里面的第二个参数函数
-    }
-  });
-});
-
-p.then(
-  (data) => {
-    console.log(data);
-  },
-  (err) => {
-    console.log(err);
-  }
-);
-
-```
-
-#  promise原理
-
-Promise对象代表一个异步操作.
-
-有三种状态: pending (进行中)、fulfilled (已成功)和rejected (已失败)
-
-Promise对象的状态改变，只有两种可能:从pending变 为fulfilled和从pending变为rejected。
-
-只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态
-
-如果异步操作成功了(读文件成功了),从pending (进行中)变为 fulfilled (已成功) ;
-
-如果异步操作失败了(读文件失败了),从pending (进行中)变为 rejected (已失败) ;
-
-状态如果已经确定了， 就不会再去改变这个状态了
-
-# promise特点及其封装
-
-Promise新建后就会立即执行
-
-所以不要在promise里面写其他的代码，只写这个异步操作的代码就可以了
-
-```js
-const fs = require("fs");
-function getPromise(filename) {
-  // 调用Promise构造函数，创建一个promise的实例
-  return new Promise((resolve, reject) => {
-    // 写异步操作（读文件）
-    fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
-      if (!err) {
-        // 操作成功（读文件成功）
-        resolve(data); // 调用resolve方法
-        // 调用then()里面的第一个参数函数
-      } else {
-        reject(err); // 调用reject方法
-        // 调用then()里面的第二个参数函数
-      }
-    });
-  });
-}
-
-// console.log(getPromise("a"));
-getPromise("a").then(
-  (data) => {
-    console.log(data);
-  },
-  (err) => {
-    console.log(err);
-  }
-);
-```
- 
-# promise正确写法
-
-+ promise如何解决回调地狱
-
-   + 链式编程解决
-
- + 我们用promise解决的问题：让异步操作有顺序，并且不能有回调地狱 
-
-让异步操作有顺序本质是：
-
-异步操作实际上是没有顺序的
-
-在异步操作成功后的回调函数里返回另外的promise,调用他的then方法
-
-```js
-const fs = require("fs");
-function getPromise(filename) {
-  // 调用Promise构造函数，创建一个promise的实例
-  return new Promise((resolve, reject) => {
-    // 写异步操作（读文件）
-    fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
-      if (!err) {
-        // 操作成功（读文件成功）
-        resolve(data); // 调用resolve方法
-        // 调用then()里面的第一个参数函数
-      } else {
-        reject(err); // 调用reject方法
-        // 调用then()里面的第二个参数函数
-      }
-    });
-  });
-}
-
-// console.log(getPromise("a"));
-getPromise("a")
-  .then((data) => {
-    console.log(data);
-    //调用函数得到一个读b文件的promise对象并返回
-    return getPromise("b");
-  })
-  .then((data) => {
-    console.log(data);
-    //调用函数得到一个读c文件的promise对象并返回
-    return getPromise("c");
-  })
-  .then((data) => {
-    console.log(data);
-  });
-```
- 
-# promise的其他方法
-
-+ catch()
-
-        能够抓取错误的
-```js
-    const fs = require("fs");
-    function getPromise(filename) {
-      // 调用Promise构造函数，创建一个promise的实例
-      return new Promise((resolve, reject) => {
-        // 写异步操作（读文件）
-        fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
-          if (!err) {
-            // 操作成功（读文件成功）
-            resolve(data); // 调用resolve方法
-            // 调用then()里面的第一个参数函数
-          } else {
-            reject(err); // 调用reject方法
-            // 调用then()里面的第二个参数函数
-          }
-        });
-      });
-    }
-
-    // console.log(getPromise("a"));
-    getPromise("a")
-      .then((data) => {
-        console.log(data);
-        //调用函数得到一个读b文件的promise对象并返回
-        return getPromise("b");
-      })
-      .then((data) => {
-        console.log(data);
-        //调用函数得到一个读c文件的promise对象并返回
-        return getPromise("c");
-      })
-      .then((data) => {
-        console.log(data);
-      })
-      .catch((err) => {
-        console.log(err);
-      });
-```
- 
-+ all()
-
-```js
-    const fs = require("fs");
-    function getPromise(filename) {
-      // 调用Promise构造函数，创建一个promise的实例
-      return new Promise((resolve, reject) => {
-        // 写异步操作（读文件）
-        fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
-          if (!err) {
-            // 操作成功（读文件成功）
-            resolve(data); // 调用resolve方法
-            // 调用then()里面的第一个参数函数
-          } else {
-            reject(err); // 调用reject方法
-            // 调用then()里面的第二个参数函数
-          }
-        });
-      });
-    }
-
-    let p1 = getPromise("a");
-    let p2 = getPromise("b");
-    let p3 = getPromise("c");
-
-    // Promise.all()方法用于将多个 Promise 实例，包装成一个新的 Promise 实例
-    let pAll = Promise.all([p1, p2, p3]);
-    // 一个都不能少，每一个promise都要读取成功才会成功，相当于是并且
-    pAll.then((data) => {
-      console.log(data);
-    });
-```
- 
-+ race
-```js
-    const fs = require("fs");
-    function getPromise(filename) {
-      // 调用Promise构造函数，创建一个promise的实例
-      return new Promise((resolve, reject) => {
-        // 写异步操作（读文件）
-        fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
-          if (!err) {
-            // 操作成功（读文件成功）
-            resolve(data); // 调用resolve方法
-            // 调用then()里面的第一个参数函数
-          } else {
-            reject(err); // 调用reject方法
-            // 调用then()里面的第二个参数函数
-          }
-        });
-      });
-    }
-
-    let p1 = getPromise("a");
-    let p2 = getPromise("b");
-    let p3 = getPromise("c");
-
-    // Promise.race()方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例
-    let pRace = Promise.race([p1, p2, p3]);
-    // 只要有一个promise执行成功，那这个pRace就成功，相当于是或者
-    pRace.then((data) => {
-      console.log(data);
-    });
-```
-# 什么是async/await
-
- async/await是es7推出的一套关于异步的终极解决方案;主要作用就是转异步为同步。
-
-# async/await语法格式
-
-```js
-//可写一个函数返回的是异步的promise对象,也可以定义一个异步函数；
-        function fn(){
-            return new Promise((resolve,reject)=>{
-                   resolve(666)
-            })
-        }
-        let p1=new Promise((n1,n2)=>{  //也可以直接写一个promise对象
-                n1(999)
-        })
-        // 在需要使用上面异步函数的函数前面，加上async声明，声明这是一个异步函数
-        async function fn2(){
-        // 在异步函数前面加上await，函数执行就会等待用await声明的异步函数执行完毕之后，在往下执行
-            let a1=await fn()   
-            let p=await p1   
-            console.log(a1,p)
-        }
-        fn2()
-```
-  
-注意：async/await不能捕获错误，可以使用try/catch来进行错误的捕获
-
-```js
-        function fn() {
-            return new Promise((resolve, reject) => {
-                resolve(666)
-            })
-        }
-        let p1 = new Promise((n1, n2) => {
-            n1(999)
-        })
-        async function fn2() {
-            try {
-                let a1 = await fn()
-                let p = await p1
-                console.log(a1, p)
-            } catch (err) {
-                console.log(err)
-            }
-        }
-        fn2()
-```
-   
-# 小结：
-
-+ 1.async函数在声明形式上和普通函数没有区别，函数声明式，函数表达式，对象方法，class方法和箭头函数等都可以声明async函数。
-
-+ 2.任何一个await语句后面的 Promise 对象变为reject状态，那么整个async函数都会中断执行。
-
-+ 3.async函数返回的 Promise 对象，必须等到内部所有await命令后面的 Promise 对象执行完，才会发生状态改变，除非遇到return语句或者抛出错误。也就是说，只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数。
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-24 koa.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-24 koa.md"
deleted file mode 100644
index 3e834f751264a1ff9d81df196549b80008ace885..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-24 koa.md"	
+++ /dev/null
@@ -1,92 +0,0 @@
-# 一、koa是什么？
-  ## 1) koa定义：
-           koa是一个基于node实现的一个新的轻量级web框架，它是由express框架的原  班人马打造的。
-  ## 2）特点：
-           (1）免除重复繁琐的回调函数嵌套，提高错误处理效率
-           (2)  独特的中间件流程控制
-           (3)  典型洋葱模型
-  ## 3）优点 ：
-          简洁 ， 表达力强， 自由度高
-  ## 4）适用场景：
-# 二、使用步骤
-## 1. 使用前提条件
-
-    Koa需要 node v7.6.0或更高版本
-
-## 2. 搭建初始项目结构
-### 1>安装依赖
-```js
-    // 初始化项目会生成package.json和node_modules
-    npm init
-     
-    // 安装koa
-    npm install --save koa
-```
-### 2> 在根目录下，创建app.js 并全局配
-```js
-    // 引入koa
-    const koa = require("koa")
-    const app = new koa()
-     
-     
-    //渲染页面
-    // ctx 是 context的简写 , 包含respose 和 request
-    app.use((ctx)=>{
-      ctx.body = "hello world"
-    })
-     
-     
-    // 监听
-    app.listen("8888", ()=>{
-       console.log(" koa服务启动 ")
-    })
-     
-     
-    /**
-     
-    在终端运行: node app.js 后，会打印出 “koa服务启动”  ,在浏览器输入 localhost：8888 ,
-    就会显示 hello world
-     
-    **/
-```
-### 3> 文件会生成：
-
-![](./img/230224.png)
-
-## 3. 添加路由
-```js
-    // 安装依赖 koa-router 或者 @koa/router
-    npm install koa-router 
-     
-     
-    // 实例化路由
-    const Router = require("koa-router")
-    const router = new Router()
-     
-     
-    // 设置首页路由
-    router.get("/",async (ctx)=>{
-        ctx.body = "首页"
-    })
-     
-     
-    // 全局配置
-    app.use(router.routes(), router.allowedMethods())
- ```    
-     
-
-## 4. 安装热更新nodemon
-```js
-    // 安装依赖
-    // nodemon必须全局安装 ,否则会报错
-    npm install nodemon -g
-     
-     
-    *// 可在package.json中找到"scripts",配置项目启动命令npm run dev：
-     
-     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1",
-        "dev":"nodemon app.js"
-      },
-
-```
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-27 middleware \345\244\204\347\220\206url.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-27 middleware \345\244\204\347\220\206url.md"
deleted file mode 100644
index fa0091dfabb3be0d7f489166f60ebf0c66ea0401..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-27 middleware \345\244\204\347\220\206url.md"	
+++ /dev/null
@@ -1,83 +0,0 @@
-# koa middleware
-
-核心代码是：
-
-```js
-app.use(async (ctx, next) => {
-    await next();
-    ctx.response.type = 'text/html';
-    ctx.response.body = '<h1>Hello, koa2!</h1>';
-});
-```
-每收到一个http请求，koa就会调用通过app.use()注册的async函数，并传入ctx和next参数。
-
-我们可以对ctx操作，并设置返回内容。但是为什么要调用await next()？
-
-原因是koa把很多async函数组成一个处理链，每个async函数都可以做一些自己的事情，然后用await next()来调用下一个async函数。我们把每个async函数称为middleware，这些middleware可以组合起来，完成很多有用的功能。
-
-middleware的顺序很重要，也就是调用app.use()的顺序决定了middleware的顺序。
-
-此外，如果一个middleware没有调用await next()，会怎么办？答案是后续的middleware将不再执行了。这种情况也很常见.
-
-# 处理URL
-
-## koa-router
-为了处理URL，我们需要引入koa-router这个middleware，让它负责处理URL映射。
-
-我们把上一节的hello-koa工程复制一份，重命名为url-koa。
-
-先在package.json中添加依赖项：
-```
-"koa-router": "7.0.0"
-```
-然后用npm install安装。
-
-接下来，我们修改app.js，使用koa-router来处理URL：
-```js
-const Koa = require('koa');
-
-// 注意require('koa-router')返回的是函数:
-const router = require('koa-router')();
-
-const app = new Koa();
-
-// log request URL:
-app.use(async (ctx, next) => {
-    console.log(`Process ${ctx.request.method} ${ctx.request.url}...`);
-    await next();
-});
-
-// add url-route:
-router.get('/hello/:name', async (ctx, next) => {
-    var name = ctx.params.name;
-    ctx.response.body = `<h1>Hello, ${name}!</h1>`;
-});
-
-router.get('/', async (ctx, next) => {
-    ctx.response.body = '<h1>Index</h1>';
-});
-
-// add router middleware:
-app.use(router.routes());
-
-app.listen(3000);
-console.log('app started at port 3000...');
-```
-注意导入koa-router的语句最后的()是函数调用：
-```
-const router = require('koa-router')();
-```
-相当于：
-```
-const fn_router = require('koa-router');
-const router = fn_router();
-```
-然后，我们使用router.get('/path', async fn)来注册一个GET请求。可以在请求路径中使用带变量的/hello/:name，变量可以通过ctx.params.name访问。
-
-再运行app.js，我们就可以测试不同的URL：
-```
-输入首页：http://localhost:3000/
-```
-```
-输入：http://localhost:3000/hello/koa
-```
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-02-28 \345\244\204\347\220\206post\350\257\267\346\261\202.md" "b/03\350\214\203\345\217\266\345\205\260/2023-02-28 \345\244\204\347\220\206post\350\257\267\346\261\202.md"
deleted file mode 100644
index cdab559df968b7889fc4244f4699213d8cebbe00..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-02-28 \345\244\204\347\220\206post\350\257\267\346\261\202.md"	
+++ /dev/null
@@ -1,52 +0,0 @@
-# 处理post请求
-用router.get('/path', async fn)处理的是get请求。如果要处理post请求，可以用router.post('/path', async fn)。
-
-用post请求处理URL时，我们会遇到一个问题：post请求通常会发送一个表单，或者JSON，它作为request的body发送，但无论是Node.js提供的原始request对象，还是koa提供的request对象，都不提供解析request的body的功能！
-
-所以，我们又需要引入另一个middleware来解析原始request请求，然后，把解析后的参数，绑定到ctx.request.body中。
-
-koa-bodyparser就是用来干这个活的。
-
-我们在package.json中添加依赖项：
-```
-"koa-bodyparser": "3.2.0"
-```
-然后使用npm install安装。
-
-下面，修改app.js，引入koa-bodyparser：
-```
-const bodyParser = require('koa-bodyparser');
-```
-在合适的位置加上：
-```
-app.use(bodyParser());
-```
-由于middleware的顺序很重要，这个koa-bodyparser必须在router之前被注册到app对象上。
-
-现在我们就可以处理post请求了。写一个简单的登录表单：
-```js
-router.get('/', async (ctx, next) => {
-    ctx.response.body = `<h1>Index</h1>
-        <form action="/signin" method="post">
-            <p>Name: <input name="name" value="koa"></p>
-            <p>Password: <input name="password" type="password"></p>
-            <p><input type="submit" value="Submit"></p>
-        </form>`;
-});
-
-router.post('/signin', async (ctx, next) => {
-    var
-        name = ctx.request.body.name || '',
-        password = ctx.request.body.password || '';
-    console.log(`signin with name: ${name}, password: ${password}`);
-    if (name === 'koa' && password === '12345') {
-        ctx.response.body = `<h1>Welcome, ${name}!</h1>`;
-    } else {
-        ctx.response.body = `<h1>Login failed!</h1>
-        <p><a href="/">Try again</a></p>`;
-    }
-});
-```
-注意到我们用var name = ctx.request.body.name || ''拿到表单的name字段，如果该字段不存在，默认值设置为''。
-
-类似的，put、delete、head请求也可以由router处理。
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-03-02 \351\207\215\346\236\204\350\267\257\347\224\261\345\212\237\350\203\275\302\267.md" "b/03\350\214\203\345\217\266\345\205\260/2023-03-02 \351\207\215\346\236\204\350\267\257\347\224\261\345\212\237\350\203\275\302\267.md"
deleted file mode 100644
index c0ab3775df9563da717522f5c05dfbb8b041e43d..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-03-02 \351\207\215\346\236\204\350\267\257\347\224\261\345\212\237\350\203\275\302\267.md"	
+++ /dev/null
@@ -1,73 +0,0 @@
-# 重构路由功能
-
-实现路由功能：
-```js
-//server.js
-var http = require('http') //输入node.js核心模块
-
-function startServer(route){
-    var onRequest = function(req,res) {
-        route(req.url) //传入请求的路径
-    }
-    var server = http.createServer(onRequest)
-server.listen(3000)  //监听一个端口
-}
-
-module.exports.startServer = startServer;  //输出模块
-```
-我们新建一个server.js模块，在这个模块中，我们定义了一个startServer函数，这个函数监听了一个3000端口，函数执行的时候调用route方法。我们先将这个模块输出
-```js
-//index.js
-var server = require("./server");  //输入./server模块
-var router = require('./router');  //输入./router模块
-var handler = require("./handler")  //输入./handler模块
-var handle = {};   
-handle["/"] = handler.home;           
-handle["/home"] = handler.home;
-handle["/list"] = handler.list;
-handle["/add"] = handler.add
-server.startServer(router.route,handle)
-```
-route()接收到了请求路径，我们希望它接收到不同的路径会调用不同的方法，因此我们可以先把要执行的方法作为属性值传给一个handle对象，它的键就等于route接收到的请求路径。于是我们分别把创建route.js和handler.js，在index.js中把请求路径和handle对象传给route函数
-```js
-  //server.js
-var http = require('http') //引入node.js核心模块
-
-function startServer(route,handle){
-var onRequest = function(req,res) {
-route(req.url,handle,res) //传入请求的路径
-}
-var server = http.createServer(onRequest)
-server.listen(3000) //监听一个端口
-}
-module.exports.startServer = startServer; //输出模块
-
-
-//route.js
-function route(pathname,handle，res){
-  if(typeof handle[pathname] == "function"){
-     handle[pathname](res)
-  }else{
-     res.end("404:connot find anything") //未匹配到路径的时候，响应“404”页面
-  }
-}
-module.exports.route = route;
-
-
-//handler.js
-function home (res){
-    res.end("home")
-}
-function list (res){
-    res.end("list")
-}
-function add(res){
-   res.end("add")
-}
-module.exports = {
-    home:home,
-    list: list,
-    add:add
-}
-```
-因为我们希望在地址栏输入路径的时候，页面会响应出响应的内容，所以我们要把响应参数res传递给route函数，它又会把这个参数传递给handler里的方法，这个我们就能很灵活地根据请求的地址响应我们想要的内容。
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-03-03 \347\273\203\344\271\240\345\237\272\346\234\254.md" "b/03\350\214\203\345\217\266\345\205\260/2023-03-03 \347\273\203\344\271\240\345\237\272\346\234\254.md"
deleted file mode 100644
index 7444e33810062ef0aa0ef1729fca3bbe9b2e34c4..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-03-03 \347\273\203\344\271\240\345\237\272\346\234\254.md"	
+++ /dev/null
@@ -1,84 +0,0 @@
-# app.js
-```js
-'use strict'
-
-//引用模块
-const Koa=require('koa');
-
-//引入index.js的模块
-let index=require('./controller')
-
-
-//实例化
-let app=new Koa();
-
-index(app);
-// console.log(obj)
-
-
-//监视端口
-let posh=8000;
-app.listen(posh);
-
-console.log(`网站:http://localhost:${posh}`);
-```
-
-# index.js
-
-```js
-'use strict'
-//模块
-const fs = require('fs');
-
-//koa-router:是函数调用
-const router = require('koa-router')();
-//koa-bodyparser不是函数调用
-const bodyParser = require('koa-bodyparser')
-
-
-
-//请求的方法函数:注册指定模块的所有定义路由
-function fn_url(obj) {
-    for (let key in obj) {
-        // console.log(key)
-        let ad = key.split(' ')//将字符串分割成数组
-        // console.log('是'+ad)
-        let method = ad[0]//请求方法
-        let url = ad[1]//请求路径
-        let fn = obj[key]//函数方法
-
-        if (method === 'get') {
-            router.get(url, fn)
-        } else if (method === 'post') {
-            router.post(url, fn)
-        } else if (method === 'put') {
-            router.put(url, fn)
-        } else if (method === 'delete') {
-            router.delete(url, fn)
-        }
-    }
-}
-
-//判断请求路径的方法函数
-function url(app) {
-    let filtes = fs.readdirSync('./controller')//用同步获取控制器文件夹中的文件
-    console.log(filtes)
-    let filt = filtes.filter(item => {
-        return item !== 'index.js'//排除index.js文件
-    })
-
-    filt.forEach(item => {
-        //replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
-        let obj = require('./' + item.replace('.js', ''))//调用的路由模块
-        console.log('修改后:' + obj)
-
-        fn_url(obj);
-    })
-
-    app.use(bodyParser())
-    app.use(router.routes())
-}
-
-console.log(url)
-module.exports = url;
-```
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-03-06 \351\207\215\346\236\204anew.md" "b/03\350\214\203\345\217\266\345\205\260/2023-03-06 \351\207\215\346\236\204anew.md"
deleted file mode 100644
index 48989b346b0ad3ca9e0caad1172a0c1cba71c751..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-03-06 \351\207\215\346\236\204anew.md"	
+++ /dev/null
@@ -1,151 +0,0 @@
-# 重构
-
-1. app.js
-
-```js
-//引入模块
-const Koa=require('koa');
-const registerRouter=require('./controllers')
-const templating=require('./templating')
-const staticFiles=require('./staticFiles')
-//实例化
-let app=new Koa();
-
-
-//注册路由
-registerRouter(app)
-
-//端口号
-let port=8088;
-app.listen(port)
-
-console.log(`http://localhost:${port}`);
-```
-2. 控制器（controllers)
-  index.js
-   ```js
-        const router=require('koa-router')();
-        const bodyParser=require('koa-bodyparser');
-        const {findControllers,registerRouter2}=require('../utils/tools')
-
-        function registerRouter(app){
-            //找到所有文件
-            let files=findControllers()
-            //遍历注册
-            registerRouter2(files,router)
-
-            app.use(router.routes());
-            app.use(bodyParser())
-        }
-
-        module.exports=registerRouter;
-        ```
-  roles.js
-```js
-
-        let list=[
-            {
-                id:1,
-                name:'小范',
-                img:url
-            },{
-                id:2,
-                name:'小徐',
-                img:url
-            },{
-                id:3,
-                name:'小陈',
-                img:url
-            },{
-                id:4,
-                name:'小王',
-                img:url
-            },{
-                id:5,
-                name:'小许',
-                img:url
-            },
-        ]
-
-        async function getAll(ctx,next){
-
-           
-        }
-        async function getById(ctx,next){
-
-        }
-        async function addItem(ctx,next){
-
-        }
-        async function updateItem(ctx,next){
-
-        }
-        async function delItem(ctx,next){
-
-        }
-       
-
-        module.exports={
-            'get /roles':getAll,
-            'get /roles/:id':getById,
-            'post /roles':addItem,
-            'put /roles/:id':updateItem,
-            'delete /roles/:id':delItem,
-        }
- ```
-3. 路由系统封装（utils——>tools.js)
-
-``` js
-    'use strict';
-
-    const fs = require('fs');
-
-    // 查找所有路由文件
-    function findControllerFiles(path) {
-        // 如果传入指定目录，则从指定目录查找路由文件，否则默认从   controllers目录下查找路由文件
-        path = path || './controllers';
-
-        // 使用fs模块读取指定目录下的文件
-        let files = fs.readdirSync(path);
-
-        // 返回过滤后的路由文件（查找到的文件过滤掉非.js结尾的、    并且不能是index.js的文件）
-        return files.filter(item => {
-            return item.endsWith('.js') && item !== 'index. js';
-        });
-    }
-
-    //注册路由(传入所有的路由文件)
-    function registryRouter(files,router) {
-        // 遍历路由文件
-        files.forEach(file => {// 形如这个样子的字符串： 'users.js'
-
-            // 加载指定文件模块，返回形式是一个对象
-            let tmpModule = require('../controllers/' +     file);
-            // 遍历对象
-            for (let key in tmpModule) {
-                // 使用空格分割字符串
-                let arr = key.split(' ');
-
-                let method = arr[0];//http的方法，可能是：get post put delete中的其中一种
-                let url = arr[1];//请求地址，不包含主机地址：localhost:port
-                let fn = tmpModule[key];//请求需要调用的异步函数
-
-                if (method === 'get') {
-                    router.get(url, fn);
-                } else if (method === 'post') {
-                    router.post(url, fn);
-                } else if (method === 'put') {
-                    router.put(url, fn);
-                } else if (method === 'delete') {
-                    router.delete(url, fn);
-                }
-            }
-        })
-    }
-
-    module.exports = {
-        findControllerFiles,
-        registryRouter
-    }
- ```     
-    
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-03-07 \347\203\255\351\207\215\350\275\275 nunjucks.md.md" "b/03\350\214\203\345\217\266\345\205\260/2023-03-07 \347\203\255\351\207\215\350\275\275 nunjucks.md.md"
deleted file mode 100644
index 1ad64e81576cfa49afb01fd7b2b9d3dff3ddd73f..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-03-07 \347\203\255\351\207\215\350\275\275 nunjucks.md.md"	
+++ /dev/null
@@ -1,194 +0,0 @@
-
-## 一.热重载:nodemon
-
-### 安装
-
-+ 方法一:全局安装
-```js
-$ npm i -g nodemon
-
-删除: npm un -g nodemon
-```
-
-+ 方法二:本地安装
-```js
-$ npm i -D nodemon
-
-注意：本地安装需要在 package.json 文件的 script 脚本中指定要需要执行的命令
-
-{
-  "script": {
-    "dev": "nodemon app.js"
-  }
-}
-使用 npm dev 运行
-```
-
-
-
-## 二.nunjucks模板引擎
-
-### 安装nunjucks
-```
-    npm add nunjucks/yarn add nunjucks
-```
-
-### 用法
-
-### nunjucks 插值语法
-
-+ nunjucks 的插值语法和我们平常写 VUE 的语法一样, 只需要写双大括号{{}} 即可以完成插值引用.
-
-### 渲染:render
-#### index.html
-```js
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta http-equiv="X-UA-Compatible" content="IE=edge">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>练习</title>
-</head>
-<body>
-    {{username}}敲代码
-</body>
-</html>
-```
-#### users.js
-```js
-'use strict'
-
-const nunjucks=require('nunjucks')
-
-nunjucks.configure('views',{
-    autoescape:true
-})
-
-async function getAll(ctx, next) {
-    ctx.body=nunjucks.render('index.html',{username:"码农"})
-}
-
-async function getById(ctx, next) {
-
-}
-
-async function addItem(ctx, next) {
-
-}
-
-async function updateItem(ctx, next) {
-
-}
-
-async function delItem(ctx, next) {
-
-}
-
-module.exports = {
-    'get /users': getAll,
-    'get /users/:id': getById,
-    'post /users': addItem,//新增
-    'put /users/:id': updateItem,//修改
-    'delete /users/:id': delItem,
-}
-```
-
-### 循环:for in 循环
-
-+ 开始和结束语句都要在 **{%  %}**中间
-
-+ 要一个结束循环的标志. {% endfor %}
-
-#### use.html
-```js
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta http-equiv="X-UA-Compatible" content="IE=edge">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>生活</title>
-</head>
-<body>
-    <ul>
-        {% for item in items %}
-
-        <!-- <li>{{item.id}}</li> -->
-
-        <li>{{item.name}}</li>
-
-        {% endfor %}
-    </ul>
-</body>
-</html>
-```
-#### users,js
-```js
-'use strict'
-
-const nunjucks=require('nunjucks')
-
-nunjucks.configure('views',{
-    autoescape:true
-})
-
-async function getAll(ctx, next) {
-    ctx.body=nunjucks.render('use.html',{items:[
-        {id:1,name:"HTML"},
-        {id:2,name:"SQL"},
-        {id:3,name:"JS"},
-        {id:4,name:"NODEJS"},
-    ]})
-}
-
-async function getById(ctx, next) {
-    // let id = ctx.request.params.id;
-
-    // let data = list.filter(item => {
-    //     return item.id == id
-    // })
-
-    // ctx.body = data
-}
-
-async function addItem(ctx, next) {
-
-}
-
-async function updateItem(ctx, next) {
-
-}
-
-async function delItem(ctx, next) {
-
-}
-
-module.exports = {
-    'get /users': getAll,
-    'get /users/:id': getById,
-    'post /users': addItem,//新增
-    'put /users/:id': updateItem,//修改
-    'delete /users/:id': delItem,
-}
-```
-
-### nunjucks.configure()
-```
-传入 path 指定存放模板的目录，opts 可让某些功能开启或关闭，这两个变量都是可选的。path 的默认值为当前的工作目录，opts 提供以下功能：
-```
-+ autoescape (默认值: true) 控制输出是否被转义，查看 Autoescaping
-
-+ throwOnUndefined (default: false) 当输出为 null 或 undefined 会抛出异常
-+ trimBlocks (default: false) 自动去除 block/tag 后面的换行符
-+ lstripBlocks (default: false) 自动去除 block/tag 签名的空格
-+ watch (默认值: false) 当模板变化时重新加载。使用前请确保已安装可选依赖 chokidar。
-+ noCache (default: false) 不使用缓存，每次都重新编译
-+ web 浏览器模块的配置项
-    + useCache (default: false) 是否使用缓存，否则会重新请求下载模板
-    + async (default: false) 是否使用 ajax 异步下载模板
-+ express 传入 express 实例初始化模板设置
-+ tags: (默认值: see nunjucks syntax) 定义模板语法，查看 Customizing Syntax
-```
-configure 返回一个 Environment 实例, 他提供了简单的 api 添加过滤器 (filters) 和扩展 (extensions)
-```
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-03-09 \345\244\204\347\220\206\351\235\231\346\200\201\350\265\204\346\272\220.md" "b/03\350\214\203\345\217\266\345\205\260/2023-03-09 \345\244\204\347\220\206\351\235\231\346\200\201\350\265\204\346\272\220.md"
deleted file mode 100644
index 423d146b8a48b791a241168e5bf1cd8c584b666f..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-03-09 \345\244\204\347\220\206\351\235\231\346\200\201\350\265\204\346\272\220.md"	
+++ /dev/null
@@ -1,108 +0,0 @@
-# 处理静态资源
-1. 问题描述
- 浏览器在收到服务器返回的HTML内容之后，就要开始从上到下依次解析,当在解析的过程中，如果发现:
-
- link
- script
- img
- iframe
- video
- audio
-
- 等带有src或者link 的href属性标签的时候，浏览器会自动对这些静态资源发起一个新的请求。我们要对这些新的请求进行处理
-
-2. 解决方法
-
-为了方便的统一处理这些静态资源，所以我们约定把所有的静态资源都存放在 public目录，目的是为了统一处理
-
-如果请求路径是以 /public/ 开头的，则服务器认为你要获取 public中的某个资源，所以我们就直接可以把请求路径当作文件路径来直接进行读取
-
-3. 代码演示
-
-# index.html文件
-```js
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>首页</title>
-  <link rel="stylesheet" href="/public/lib/bootstrap.css">
-  <link rel="stylesheet" href="/public/css/main.css">
-</head>
-<body>
-<h1>灰太狼</h1>
-<img src="/public/img/1.jpg">
-</body>
-</html>
-```
-注意：在服务端中，文件中的路径就不要去写相对路径了。因为这个时候所有的资源都是通过url标识来获取的。
-服务器开放 /public/ 目录
-所以代码中的请求路径都写成：/public/xxx
-/ 在这里就是url根路径的意思。
-浏览器在真正发请求的时候会最终把url拼接到 http:/ /127.0.0.1:3000上
-
-# app.js文件
-
-如果不对那些静态资源进行处理，我们看一下是什么情况
-```js
-let http = require('http');
-let fs = require('fs');
-
-http.createServer(function (request,response) {
-  console.log("服务器收到请求");
-  let url = request.url;
-  if (url === '/') {
-    fs.readFile('./views/index.html',function (err,data) {
-      if (err) {
-        response.end('404');
-        return;
-      }
-      response.end(data)
-    })
-  }
-}).listen(3000,function () {
-  console.log('http://127.0.0.1:3000');
-})
-```
-![](./img/jingtaiziyuanchuli.png)
-
-使用node app.js启动服务器，访问 http://127.0.0.1:3000，打开控制台，结果如图所示。原因就在于我们没有写对这些静态资源进行处理的代码，服务器读取不到它们，也就无法返回给浏览器。下面重新写app.js
-
-
-# app.js（对静态资源进行处理）
-
-```js
-let http = require('http');
-let fs = require('fs');
-
-http.createServer(function (request,response) {
-  console.log("服务器收到请求");
-  let url = request.url;
-  if (url === '/') {
-    fs.readFile('./views/index.html',function (err,data) {
-      if (err) {
-        response.end('404');
-        return;
-      }
-      response.end(data)
-    })
-  } else if (url.indexOf('/public/') !== -1) {
-     //此处是关键，当发现请求路径中含有 /public/，我们把请求路径当作文件路径来直接进行读取
-    fs.readFile('.' + url,function (err,data) {
-      if (err) {
-        response.end('404');
-        return;
-      }
-      response.end(data);
-    })
-  }
-}).listen(3000,function () {
-  console.log('http://127.0.0.1:3000');
-})
-```
-
-我们所有的静态资源都放在了public文件夹中，所以资源的请求路径前都会有 /public/
-所以说如果请求路径是以 /public/ 开头的，则服务器认为你要获取 public中的某个资源，我们就直接可以把请求路径当作文件路径来直接进行读取
-
-我们重新启动node app.js，访问 http://127.0.0.1:3000，刷新一下，页面马上就可以显示出来。打开控制台看看，资源也都请求到了。
-
diff --git "a/03\350\214\203\345\217\266\345\205\260/2023-03-10 sequelize.md" "b/03\350\214\203\345\217\266\345\205\260/2023-03-10 sequelize.md"
deleted file mode 100644
index 03041080f2ade9017ab4f8fb58c40288369b82f3..0000000000000000000000000000000000000000
--- "a/03\350\214\203\345\217\266\345\205\260/2023-03-10 sequelize.md"	
+++ /dev/null
@@ -1,85 +0,0 @@
-# 一.使用Sequelize
-
-## 安装Sequelize
-```js
-使用 npm
-npm i sequelize /npm add sequelize
-
-使用 yarn
-yarn add sequelize
-
-```
-
-## 为所选数据库安装驱动程序
-
-+ 上课讲mysql
-```js
-使用 npm
-npm i pg pg-hstore # PostgreSQL
-npm i mysql2 # MySQL
-npm i mariadb # MariaDB
-npm i sqlite3 # SQLite
-npm i tedious # Microsoft SQL Server
-npm i ibm_db # DB2
-
-
-使用 yarn
-yarn add pg pg-hstore # PostgreSQL
-yarn add mysql2 # MySQL
-yarn add mariadb # MariaDB
-yarn add sqlite3 # SQLite
-yarn add tedious # Microsoft SQL Server
-yarn add ibm_db # DB2
-```
-## 详细的
-+ Sequelize的中文文档: https://www.sequelize.cn/core-concepts/getting-started
-
-# 二.安装mysql
-
-安装步骤的详细地址: https://blog.csdn.net/SoloVersion/article/details/123760428
-
-+ 装5.7.x的更稳定(也不知道是不是真的)
-
-# 三.使用
-
-## 运行mysql
-
-方法一:
-+ 右键打开任务管理器,在服务里打开mysql
-
-方法二:
-
-+ win+R,打开运行框，输入services.msc直接打开服务，在里面打开mysql
-
-
-## 使用命令行，查看数据库的连接
-
-+ win+R，输入cmd
-
-+ 输入mysql，看看能不能正常运行，如果不可以就有添加一下环境变量
-
-+ 连接一下,输入
-```
-    mysql -u root -p
-```
-+ 输入密码，成功就连接上了
-
-+ 创建数据库,**必须用;结束**
-```
-    create database 库名;
-```
-
-+ 进入数据库
-```
-    use 库名
-```
-
-+ 查看库中的表
-```
-    show tables
-```
-
-+ 查看表的内容
-```
-    select * from 表名
-```
\ No newline at end of file
diff --git "a/03\350\214\203\345\217\266\345\205\260/img/2023-02-20.png" "b/03\350\214\203\345\217\266\345\205\260/img/2023-02-20.png"
deleted file mode 100644
index d5156ec5ec667ff25974db87abfa50f3678ff239..0000000000000000000000000000000000000000
Binary files "a/03\350\214\203\345\217\266\345\205\260/img/2023-02-20.png" and /dev/null differ
diff --git "a/03\350\214\203\345\217\266\345\205\260/img/230224.png" "b/03\350\214\203\345\217\266\345\205\260/img/230224.png"
deleted file mode 100644
index ec33e298727201beff032b711aef07a75ba592cd..0000000000000000000000000000000000000000
Binary files "a/03\350\214\203\345\217\266\345\205\260/img/230224.png" and /dev/null differ
diff --git "a/03\350\214\203\345\217\266\345\205\260/img/httpmokuai/img01.png" "b/03\350\214\203\345\217\266\345\205\260/img/httpmokuai/img01.png"
deleted file mode 100644
index f30b31b7eb81492c6919fa40e7a77305256f0982..0000000000000000000000000000000000000000
Binary files "a/03\350\214\203\345\217\266\345\205\260/img/httpmokuai/img01.png" and /dev/null differ
diff --git "a/03\350\214\203\345\217\266\345\205\260/img/httpmokuai/img02.png" "b/03\350\214\203\345\217\266\345\205\260/img/httpmokuai/img02.png"
deleted file mode 100644
index 62c88a1dd191aeea5ff7359d87dad06090ff35e6..0000000000000000000000000000000000000000
Binary files "a/03\350\214\203\345\217\266\345\205\260/img/httpmokuai/img02.png" and /dev/null differ
diff --git "a/03\350\214\203\345\217\266\345\205\260/img/wangzhan.png" "b/03\350\214\203\345\217\266\345\205\260/img/wangzhan.png"
deleted file mode 100644
index 0ad22d18231c4d28d928ec939630bee8ca8ade42..0000000000000000000000000000000000000000
Binary files "a/03\350\214\203\345\217\266\345\205\260/img/wangzhan.png" and /dev/null differ
diff --git "a/05\345\210\230\350\203\241/230213-\350\256\244\350\257\206Node.js.md" "b/05\345\210\230\350\203\241/230213-\350\256\244\350\257\206Node.js.md"
deleted file mode 100644
index 40b4645581c600917d7d7d5e05a131f122f3a071..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230213-\350\256\244\350\257\206Node.js.md"
+++ /dev/null
@@ -1,76 +0,0 @@
-Node.js是目前非常火热的技术，但是它的诞生经历却很奇特。
-
-众所周知，在Netscape设计出JavaScript后的短短几个月，JavaScript事实上已经是前端开发的唯一标准。
-
-后来，微软通过IE击败了Netscape后一统桌面，结果几年时间，浏览器毫无进步。（2001年推出的古老的IE 6到今天仍然有人在使用！）
-
-没有竞争就没有发展。微软认为IE6浏览器已经非常完善，几乎没有可改进之处，然后解散了IE6开发团队！而Google却认为支持现代Web应用的新一代浏览器才刚刚起步，尤其是浏览器负责运行JavaScript的引擎性能还可提升10倍。
-
-先是Mozilla借助已壮烈牺牲的Netscape遗产在2002年推出了Firefox浏览器，紧接着Apple于2003年在开源的KHTML浏览器的基础上推出了WebKit内核的Safari浏览器，不过仅限于Mac平台。
-
-随后，Google也开始创建自家的浏览器。他们也看中了WebKit内核，于是基于WebKit内核推出了Chrome浏览器。
-
-Chrome浏览器是跨Windows和Mac平台的，并且，Google认为要运行现代Web应用，浏览器必须有一个性能非常强劲的JavaScript引擎，于是Google自己开发了一个高性能JavaScript引擎，名字叫V8，以BSD许可证开源。
-
-现代浏览器大战让微软的IE浏览器远远地落后了，因为他们解散了最有经验、战斗力最强的浏览器团队！回过头再追赶却发现，支持HTML5的WebKit已经成为手机端的标准了，IE浏览器从此与主流移动端设备绝缘。
-
-浏览器大战和Node有何关系？
-
-话说有个叫Ryan Dahl的歪果仁，他的工作是用C/C++写高性能Web服务。对于高性能，异步IO、事件驱动是基本原则，但是用C/C++写就太痛苦了。于是这位仁兄开始设想用高级语言开发Web服务。他评估了很多种高级语言，发现很多语言虽然同时提供了同步IO和异步IO，但是开发人员一旦用了同步IO，他们就再也懒得写异步IO了，所以，最终，Ryan瞄向了JavaScript。
-
-因为JavaScript是单线程执行，根本不能进行同步IO操作，所以，JavaScript的这一“缺陷”导致了它只能使用异步IO。
-
-选定了开发语言，还要有运行时引擎。这位仁兄曾考虑过自己写一个，不过明智地放弃了，因为V8就是开源的JavaScript引擎。让Google投资去优化V8，咱只负责改造一下拿来用，还不用付钱，这个买卖很划算。
-
-于是在2009年，Ryan正式推出了基于JavaScript语言和V8引擎的开源Web服务器项目，命名为Node.js。虽然名字很土，但是，Node第一次把JavaScript带入到后端服务器开发，加上世界上已经有无数的JavaScript开发人员，所以Node一下子就火了起来。
-
-在Node上运行的JavaScript相比其他后端开发语言有何优势？
-
-最大的优势是借助JavaScript天生的事件驱动机制加V8高性能引擎，使编写高性能Web服务轻而易举。
-
-其次，JavaScript语言本身是完善的函数式语言，在前端开发时，开发人员往往写得比较随意，让人感觉JavaScript就是个“玩具语言”。但是，在Node环境下，通过模块化的JavaScript代码，加上函数式编程，并且无需考虑浏览器兼容性问题，直接使用最新的ECMAScript 6标准，可以完全满足工程上的需求。
-
-    我还听说过io.js，这又是什么鬼？
-
-因为Node.js是开源项目，虽然由社区推动，但幕后一直由Joyent公司资助。由于一群开发者对Joyent公司的策略不满，于2014年从Node.js项目fork出了io.js项目，决定单独发展，但两者实际上是兼容的。
-
-然而中国有句古话，叫做“分久必合，合久必分”。分家后没多久，Joyent公司表示要和解，于是，io.js项目又决定回归Node.js。
-
-具体做法是将来io.js将首先添加新的特性，如果大家测试用得爽，就把新特性加入Node.js。io.js是“尝鲜版”，而Node.js是线上稳定版，相当于Fedora Linux和RHEL的关系。
-
-
-认识**node.js**和安装
-===
-
-一 .认识**Node.js**
----
-### 1.什么是**Node.js** :
-   + 就是运行在服务端的**JavaScript**
-    
-     Node.js 是一个基于 *Chrome JavaScript* 运行时建立的一个平台  
-     Node.js 是一个事件驱动 I/O 服务端 **JavaScript** 环境，基于 **Google 的 V8 引擎，V8 引擎执行 Javascript 的速度非常快，性能非常好**
-        + 如果你在了解**Node.js**之前有JavaScript的基础，在使用时就会大大提高学习效率，这对于**后端**的服务部署**提高了性能**
-### 2.**Node.js**的发展历程 :
-1. **混沌期**：发布初期，创始人 *Ryan Dahl* 带著他的团队开发出了**以 Web 为中心的**“**Web.js**”，一切都是非常混乱，API大多都还除外研究阶段s
-2. **成长期**：**Node.js** 的核心用户 *Isaac Z. Schlueter* 开发出奠定了 **Node.js** 如今地位的重要工具--**npm**。同时也为他后来成为 *Ryan* 的接班人的重要条件
-3. **高速期**：**connect, express, socket.io** 等库的出现吸引了一大波爱好者加入到 **Node.js** 开发者的阵营中来。**CoffeeScript** 的出现更是让不少 *Ruby* 和 *Python* 开发者找到了学习的理由。期间一大波以 **Node.js** 作为运行环境的 CLI 工具涌现，其中不乏有用于加速前端开发的优秀工具，如   **less, UglifyJS, browserify, grunt** 等等。**Node.js** 的发展势如破竹
-4. **更迭期**：经过了一大批一线工程师的探索实践后，**Node.js** 也开始进入了时代的更迭期，新模式代替旧模式，新技术代替旧技术，好实践代替旧实践。ES6 也开始出现在 **Node.js** 世界中
-5. **分裂期**：ES6 的发展越来越明显，v8 也对 ES6 中的部分特性实现了支持，如 **Generator** 等等，利用--**harmony**作为开启阀门。后来，诞生了 **Io.js** 分支，再后来也回到了 **Node.js** 主线上
-6. **飞速发展期**：随著 ES2015 的发展和最终定稿，一大批利用 ES2015 特性开发的新模块出现，如原 **express** 核心团队所开发的 **koa**
-
-    > 作者：时见疏星  
-    > 链接：https://www.jianshu.com/p/5b9b245fcefa  
-    > 来源：简书
-
-### 3.**Node.js**的作用 :
-+ **node.js**可以大大提升了开发的性能以及便利. 我们知道 **Apache + PHP** 以及 **Java** 的 **Servlet** 都可以用来开发动态网页，**Node.js** 的作用与他们类似，只不过是使用 **JavaScript** 来开发，它大大提升了开发的性能以及便利
-+ 使用 ***node*** 开发还可以使用配套的**npm**包管理工具 **NPM**是随同**NodeJS**一起安装的包管理工具，能解决**NodeJS**代码部署上的很多问题
-
-二 .安装**Node.js**
----
-+ 点击这个**链接[Node.js下载安装](https://nodejs.org/en/download/)**就可以去**官网**找寻你需要的相应版本，进行下载安装
-![官网下载地址截图](./imgs/Node.js%E4%B8%8B%E8%BC%89/Node%E5%AE%98%E7%BD%91%E4%B8%8B%E8%BD%BD%E5%9C%B0%E5%9D%80.png)
-    + . 安装**Node.js**之后，可以在终端中打入```node -v```查看版号        
-        >   node -v  
-        >   18.02.5  
-        + 类似这个样子,查看版号，就知道是否是你需要的了
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230214-node.\346\226\207\344\273\266\343\200\201\350\267\257\345\276\204\343\200\201\351\205\215\347\275\256\345\222\214\346\250\241\345\235\227.md" "b/05\345\210\230\350\203\241/230214-node.\346\226\207\344\273\266\343\200\201\350\267\257\345\276\204\343\200\201\351\205\215\347\275\256\345\222\214\346\250\241\345\235\227.md"
deleted file mode 100644
index 7085f0e1d2d87397201c5763fa2537ff628968b7..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230214-node.\346\226\207\344\273\266\343\200\201\350\267\257\345\276\204\343\200\201\351\205\215\347\275\256\345\222\214\346\250\241\345\235\227.md"
+++ /dev/null
@@ -1,80 +0,0 @@
-**Node.js**文件的运行、路径、调试配置和模块
-===
-
-一 .创建**Node.js**文件去运行：
----
-+ 当安装配置好 **Node** 环境，在终端中就可以 ``node 文件.js``让 **js** 文件运行起来了，正常它需要用浏览器去运行
-
->创建一个文件：**mian.js**
-```js
-    'use strict';
-
-    console.log('Hello World');
-```
-> ``node main.js``  
-> 就会在终端中输出  
-> ``Hello World``
-+ 如果只是在终端中输入**node**，就会切换交互模式，**js** 代码就会写一行执行一行
-
-
-二 .文件的路径：
----
-路径也分为本地路径和费本地路径俩大类  
-
-1. 本地路径
-    + **相对路径**：***./文件***  相对的，路径指定更灵活更加简洁
-    + **绝对路径**：***盘符：\父级文件夹\子级文件夹\文件*** 不管如何都是指定一个完整的文件路径
-2. 非本地路径
-    + **网络路径**：***协议://主机：端口/路径***
-
-
-三 .调试配置：
----
-我们在写**node.js文件**都会用到编辑器，一般使用 ***VS code*** 编辑器就可以了  
-+ 在编写项目文件时，会把他们都放在一个文件内，我们可以在内部配置调试环境  
-    1. 先创建一个 **.vscode** 隐藏文件
-    2. 在该文件下创建一个 **launch.json** 配置文件
-    3. 在里面编写配置
-        ```json
-        {
-                "vesion":"0.2.0"
-                 "configurations": [
-                    {
-                    "type": "pwa-node",
-                    "request": "launch",
-                    "name": "Launch Program",                    
-                    "program": "${file}"
-                    }]
-        }        
-        ```
-        + 在某些编辑器里面你也可以这样去配置调试文件，可以对代码进行调试，并且可以断点去调节
-
-四 .**Node.js**模块：
----
-什么是模块？
-+ 相对于你的每一个的**js**文件都可以是模块，他可以像方法一样去使用，并且可以大大减少**代码量的维护和代码的重写率**，这样就可以提高代码的效率和利用率，方便了很多
-
-> 1. 现在有一个**fun.js**这样的文件
-```js
-    'use strict';
-
-    let fun = function(x,y){
-        rutern x+y;
-    }
-
-    module.exports = fun;
-```
->这样就可以暴露出**fun**()方法，就可以在别的**js**文件中引用了，这里函数、数组、对象等变量都可以像这样暴露出在别的文件中引用了
-
-> 2. 现在有一个**Main.js**文件
-```js
-    'use strict'
-    
-    let fun = require('./fun');
-    let a = fun(5,6);
-
-    console.log(a);    
-```
->就会打印出 *11* ，正常都是在**require**(写入相对路径)，否则Node会依次在**内置模块、全局模块和当前模块**下查找，并报错
-
->每个**js**文件就是一个模块，所以各自内部的变量名和函数名都互不冲突
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230216-node.js\347\232\204\345\237\272\346\234\254\346\250\241\345\235\227\345\222\214\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227.md" "b/05\345\210\230\350\203\241/230216-node.js\347\232\204\345\237\272\346\234\254\346\250\241\345\235\227\345\222\214\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227.md"
deleted file mode 100644
index d774a3f556a2b6987fca15b59a55989abce5efda..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230216-node.js\347\232\204\345\237\272\346\234\254\346\250\241\345\235\227\345\222\214\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227.md"
+++ /dev/null
@@ -1,227 +0,0 @@
-**Node.js**的基本模块和文件系统模块
-===
-因为**Node.js**是运行在服务区端的 *JavaScript* 环境，服务器程序和浏览器程序相比，最大的特点是没有浏览器的安全限制了，而且，服务器程序必须能接收网络请求，读写文件，处理二进制内容，所以，**Node.js**内置的常用模块就是为了实现基本的服务器功能。*这些模块在浏览器环境中是无法被执行的，因为它们的底层代码是用* ***C/C++*** 在**Node.js**运行环境中实现的 
-
-一 .基本模块：
----
-+ **Node.js**和 ***JavaScript*** (***window***)  全局变量一样也有自己的全局变量 (**global**) 
-    ```js
-    > global.console
-        Console {
-        log: [Function: bound ],
-        info: [Function: bound ],
-        warn: [Function: bound ],
-        error: [Function: bound ],
-        dir: [Function: bound ],
-        time: [Function: bound ],
-        timeEnd: [Function: bound ],
-        trace: [Function: bound trace],
-        assert: [Function: bound ],
-        Console: [Function: Console] }
-    ```
-+  **process** 是**Node.js**提供的一个对象，可以获取当前**Node.js**进程,拿到一些有用的信息，它也属于**global**的属性  
-    ```js
-        > process === global.process;
-        true
-        > process.version;
-        'v5.2.0'
-        > process.platform;
-        'darwin'
-        > process.arch;
-        'x64'
-        > process.cwd(); //返回当前工作目录
-        '/Users/michael'
-        > process.chdir('/private/tmp'); // 切换当前工作目录
-        undefined
-        > process.cwd();
-        '/private/tmp'
-    ```
-    1. > *JavaScript*的程序是由事件驱动的单线程模式，所以**Node.js**也是一样，在 **process** 中可以调用 ``process.nextTick()``,将事件下一次响应  
-    ```js
-        process.nextTick(function(){
-            console.log('我后一步');
-        });
-        console.log('我先一步');
-    ```
-    > 我先一步  
-    >我后一步
-    
-    2. > **Node.js**进程本身的事件就是由**process**对象来处理， 如果想要退出进程，我们可以响应 **exit** 事件，在程序退出时执行一个回调函数  
-    ```js
-        process.on('exit',function(code){
-            console.log('about to exit with code' + code);
-        });
-    ```    
-
-    3. > 判断**JavaScript**执行环境：
-    + 有很多JavaScript代码既能在浏览器中执行，也能在Node环境中执行，所以有时候要程序去判断当前执行的环境
-    ```js    
-        if(type(window) === 'undefined'){
-            console.log('node.js');
-        }else{
-            console.log('browser');
-        }
-        //或者是global，if返回的就是browser
-    ```
-
-二 .文件系统模块：
----
-+ Node.js内置的**fs**模块就是文件系统模块，负责读写文件,和所有其他 ***JavaScript*** 模块不同，**fs**模块同时提供了异步和同步的方法
-
-### **异步和同步**：
-1. **异步**：因为 *JavaScript*是单线程模式，执行异步时，*JavaScript* 代码无需等待，而是在传回参数后，继续执行 *JavaScript* 代码
-2. **同步**：因为 *JavaScript*是单线程模式，执行同步时，*JavaScript* 代码需要等待 
-
-### 读文件：
-1. **异步读文件**：
-    >按照 *JavaScript* 的标准，异步读取一个文本文件的代码如下：
-    ```js
-        'use strict';
-
-        var fs = require('fs');
-
-        fs.readFile('sample.txt', 'utf-8', function (err, data) {
-            if (err) {
-                console.log(err);
-            } else {
-                console.log(data);
-            }
-        });
-    ```
-    + 请注意，**sample.txt**文件必须在当前目录下，且文件编码为**utf-8**
-
-    > 异步读取时，传入的回调函数接收两个参数，当正常读取时，*err* 参数为 *null* ，*data* 参数为读取到的 *String*  
-    > 当读取发生错误时，*err* 参数代表一个错误对象，*data*为*undefined*
-    > 这也是**Node.js**标准的回调函数：**第一个参数代表错误信息，第二个参数代表结果**
-
-    > 由于 *err* 是否为 *null* 就是判断是否出错的标志，所以通常的判断逻辑总是：
-    ```js
-        if (err) {
-            // 出错了
-        } else {
-            // 正常
-        }
-    ```
-+ 如果我们要读取的文件不是文本文件，而是二进制文件，怎么办？
-    >下面的例子演示了如何读取一个图片文件：
-    ```js
-    'use strict';
-
-    var fs = require('fs');
-
-    fs.readFile('sample.png', function (err, data) {
-        if (err) {
-            console.log(err);
-        } else {
-            console.log(data);
-            console.log(data.length + ' bytes');
-        }
-    });
-    ```
-    > 当读取二进制文件时，不传入文件编码时，回调函数的 *data* 参数将返回一个**Buffer**对象。在**Node.js**中，**Buffer**对象就是***一个包含零个或任意个字节的数组***（*注意和Array不同*）。
-
-    > **Buffer**对象可以和 *String* 作转换，例如，把一个**Buffer**对象转换成 *String*：
-    ```js
-    // Buffer -> String
-    var text = data.toString('utf-8');
-    console.log(text);
-    ```
-    > 或者把一个 *String* 转换成**Buffer**：
-    ```js
-    // String -> Buffer
-    var buf = Buffer.from(text, 'utf-8');
-    console.log(buf);
-    ```
-2. **同步读文件**：
-+ 除了标准的异步读取模式外，**fs** 也提供相应的同步读取函数。同步读取的函数和异步函数相比，多了一个 ***Sync*** 后缀，并且不接收回调函数，函数直接返回结果
-
-    > 用**fs**模块同步读取一个文本文件的代码如下：
-    ```js
-    'use strict';
-
-    var fs = require('fs');
-
-    var data = fs.readFileSync('sample.txt', 'utf-8');
-    console.log(data);
-    ```
-    > 可见，原异步调用的回调函数的*data*被函数直接返回，函数名需要改为**readFileSync**，其它参数不变
-
-    > 如果同步读取文件发生错误，则需要用``try...catch``捕获该错误：
-    ```js
-    try {
-        var data = fs.readFileSync('sample.txt', 'utf-8');
-        console.log(data);
-    } catch (err) {
-        // 出错了
-    }
-    ```
-### 写文件：
-1. **异步写文件**：
-    >将数据写入文件是通过 ``fs.writeFile()`` 实现的：  
-    ```js
-        'use strict';
-
-        var fs = require('fs');
-
-        var data = 'Hello, Node.js';
-        fs.writeFile('output.txt', data, function (err) {
-            if (err) {
-                console.log(err);
-            } else {
-                console.log('ok.');
-            }
-        });
-    ```
-    > **writeFile**()的参数依次为***文件名、数据和回调函数***。如果传入的数据是 *String* ，默认按**UTF-8**编码写入文本文件，如果传入的参数是**Buffer**，则写入的是二进制文件。回调函数由于只关心成功与否，因此只需要一个 *err* 参数
-
-2. **同步写文件**：
-    > 这个是将文件同步写入的 ``writeFileSync()``：
-    ```js
-        'use strict';
-
-        var fs = require('fs');
-
-        var data = 'Hello, Node.js';
-        fs.writeFileSync('output.txt', data);
-    ```        
-#### ***异步还是同步？***
-+ 在fs模块中，提供同步方法是为了方便使用。那我们到底是应该用异步方法还是同步方法呢？
-
-    1. 由于**Node**环境执行的**JavaScript**代码是服务器端代码，所以，绝大部分需要在服务器运行期反复执行业务逻辑的代码，必须使用异步代码，否则，同步代码在执行时期，服务器将停止响应，因为**JavaScript**只有一个执行线程
-    2. 服务器启动时如果需要读取配置文件，或者结束时需要写入到状态文件时，可以使用同步代码，因为这些代码只在启动和结束时执行一次，不影响服务器正常运行时的异步执行。
-
-### **stat**对象:
-+ 如果我们要获取文件大小，创建时间等信息，可以使用``fs.stat()``，它返回一个**Stat**对象，能告诉我们文件或目录的详细信息：
-    ```js
-        'use strict';
-
-        var fs = require('fs');
-
-        fs.stat('sample.txt', function (err, stat) { status
-            if (err) {
-            console.log(err);
-            } else {
-            // 是否是文件:
-                console.log('isFile: ' + stat.isFile());
-            // 是否是目录:
-                console.log('isDirectory: ' + stat.isDirectory());
-                if (stat.isFile()) {
-                    // 文件大小:
-                    console.log('size: ' + stat.size);
-                    // 创建时间, Date对象:
-                    console.log('birth time: ' + stat.birthtime);
-                    // 修改时间, Date对象:
-                    console.log('modified time: ' + stat.mtime);
-                }
-            }
-        });
-    ```
-    > 运行结果如下：
-    ```js
-        isFile: true
-        isDirectory: false
-        size: 181
-        birth time: Fri Dec 11 2015 09:43:41 GMT+0800 (CST)
-        modified time: Fri Dec 11 2015 12:09:00 GMT+0800 (CST)
-    ```
-    > stat()也有一个对应的同步函数statSync()
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230217-node.js\347\232\204http\346\250\241\345\235\227\345\222\214\347\275\221\347\253\231\351\203\250\347\275\262.md" "b/05\345\210\230\350\203\241/230217-node.js\347\232\204http\346\250\241\345\235\227\345\222\214\347\275\221\347\253\231\351\203\250\347\275\262.md"
deleted file mode 100644
index 9e23e0286d4c52e88f7e815975823bc2bb6a2bfd..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230217-node.js\347\232\204http\346\250\241\345\235\227\345\222\214\347\275\221\347\253\231\351\203\250\347\275\262.md"
+++ /dev/null
@@ -1,79 +0,0 @@
-**Node.js**的***http***模块和网站的部署
-===
-**Node.js**的开发目的就是为了用***JavaScript***编写*web*服务器程序因为***JavaScript***实际上已经统治了浏览器端的脚本，其优势就是有世界上数量最多的前端开发人员。如果已经掌握了***JavaScript***前端开发，再学习一下如何将***JavaScript***应用在后端开发，就是名副其实的全栈了
-
-一 .**Node.js**的***http***模块
----
-
-+ **HTTP**协议：
-    >要理解**Web**服务器程序的工作原理，首先，我们要对**HTTP**协议有基本的了解。如果你对**HTTP**协议不太熟悉，先看一看[**HTTP协议简介**](https://www.cnblogs.com/ranyonsue/p/5984001.html)
-
-+ **HTTP**服务器
-    >要开发**HTTP服务器程序**，从头处理**TCP连接**，解析**HTTP**是不现实的。这些工作实际上已经由**Node.js**自带的 *http* 模块完成了。应用程序并不直接和**HTTP协议**打交道，而是操作 *http模块* 提供的 *request* 和 *response* 对象。
-    1. **request对象**封装了**HTTP请求**，我们调用 *request* 对象的属性和方法就可以拿到所有**HTTP请求的信息**；
-    2. **response对象**封装了**HTTP响应**，我们操作 *response* 对象的方法，就可以把**HTTP响应返回给浏览器**。
-+ 创建**HTTP**应用服务器  
-
-    > 用**Node.js**实现一个**HTTP**服务器程序非常简单。我们来实现一个最简单的Web程序，它对于所有请求，都返回Hello world!：
-    ```js
-        'use strict';
-
-        let http = require('http');
-
-        let server = http.createServer(function(request,response){
-            console.log(request.method + ': ' + request.url);
-
-            response.writeHead(200, {'Content-Type': 'text/html'});
-            response.end('<h1>Hello world!</h1>');
-
-        }).listen(5050);
-    ```
-    ![http服务器效果](./imgs/http%E6%A8%A1%E5%9D%97/%E7%AE%80%E5%8D%95http%E6%9C%8D%E5%8A%A1%E5%99%A8%E7%9A%84%E6%95%88%E6%9E%9C.png)
-
-    > 同时，在命令提示符窗口，可以看到程序打印的请求信息：
-    ```js
-    GET: /
-    GET: /favicon.ico
-    ```
-
-二 .网站的部署
----
-+ 网站多个部署的步骤：
-    1. 先将域名解析，添加记录值；别忘了给自己的服务器加密
-    2. 打开终端：
-        > ssh root@**域名/IP地址**  
-        输入自己服务器的秘钥  
-        
-        > **apt update**    *更新 Linux 的系统上的软件包列表*  
-        > **apt upgrade -y**    *命令将软件包升级到最新版本，-y 代表这个命令接下来的所有询问默认yes*  
-        > **apt install nginx**     *安装 **Nginx** ，接着的询问选 Y*  
-        > **systemctl status nginx**     *查看nginx的状态*  
-        > **systemctl stop nginx**   *关闭nginx服务*  
-        > **systemctl start nginx**  *开启nginx服务*  
-        > **cd /var/www**   *cd是用来切换目录的*  
-        > **mkdir 文件1 文件2**  *用来创建文件夹/文件或多个文件夹/文件*  
-        > **rm** *可以用来删除 -i 文件/ -r 文件夹,-f 可以强制删除*  
-        > **vim ~/.bashrc** *打开编辑器*  
-        > **source ~/.bashrc** *执行刚修改的初始化文件，使之立即生效*  
-        > **ll** *可以查看目录和文件了*
-    3. 创建好文件，就可以配置了：
-        > **cd /etc/nginx/conf.d**  
-        > **vim 域名.conf** *就会进入编辑器去配置了*
-        ```vim
-        server {
-            listen 80;
-            server_name 域名；
-
-            location / {
-                root /var/www/文件夹名
-                index 文件名.html
-            }
-        }
-        //保存退出
-        ```
-    4. 远程上传或下载文件/文件夹：
-        > 打开终端，cd 切换到文件夹或文件所在位置  
-        > scp -r 文件夹 root@域名/IP地址：路径 远程地址路径  
-        > scp 文件 root@域名/IP地址：路径 远程地址路径  
-
-    
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230220-node.js\347\232\204\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md" "b/05\345\210\230\350\203\241/230220-node.js\347\232\204\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"
deleted file mode 100644
index 0e07e44af217dfb59fb4a602d46d1235ff6dae0c..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230220-node.js\347\232\204\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"
+++ /dev/null
@@ -1,99 +0,0 @@
-**Node.js**的文件服务器
-===
-
-文件服务器
----
-+ 扩展**Web程序**。我们可以设定一个目录，然后让**Web程序**变成一个文件服务器。要实现这一点，我们只需要解析 **request.url** 中的路径，然后在本地找到对应的文件，把文件内容发送出去就可以了
-
-    > 解析URL需要用到**Node.js**提供的 ***url* 模块** ，它使用起来非常简单，通过 **parse**() 将一个字符串解析为一个**Url对象**：
-    ```js
-        'use strict';
-
-        let url = require('url');
-
-        console.log(url.parse('http://user:pass@host.com:8080/path/to/file?query=string#hash'));
-    ```
-    
-    > 结果如下:
-    ```js
-        Url {
-        protocol: 'http:',
-        slashes: true,
-        auth: 'user:pass',
-        host: 'host.com:8080',
-        port: '8080',
-        hostname: 'host.com',
-        hash: '#hash',
-        search: '?query=string',
-        query: 'query=string',
-        pathname: '/path/to/file',
-        path: '/path/to/file?query=string',
-        href: 'http://user:pass@host.com:8080/path/to/file?query=string#hash' }
-    ```
-+ 处理本地文件目录需要使用**Node.js**提供的 ***path*  模块**，它可以方便地构造目录：
-    ```JS
-        'use strict';
-
-            let path = require('path');
-        // 解析当前目录:
-            let workDir = path.resolve('.'); // '/Users/michael'
-        // 组合完整的文件路径:当前目录+'pub'+'index.html':
-            let filePath = path.join(workDir, 'pub', 'index.html');
-        // '/Users/michael/pub/index.html'
-    ```
-    > 使用 **path模块** 可以正确处理操作系统相关的文件路径。在***Windows系统***下，返回的路径类似于**C:\Users\michael\static\index.html**
-
-+ 最后，我们实现一个文件服务器 **file_server.js**：
-    ```js
-        'use strict';
-
-        let
-            fs = require('fs'),
-            url = require('url'),
-            path = require('path'),
-            http = require('http');
-
-        // 从命令行参数获取root目录，默认是当前目录:
-        let root = path.resolve(process.argv[2] || '.');
-            console.log('Static root dir: ' + root);
-
-        // 创建服务器:
-        let server = http.createServer(function (request, response) {
-            // 获得URL的path，类似 '/css/bootstrap.css':
-                let pathname = url.parse(request.url).pathname;
-            // 获得对应的本地文件路径，类似 '/srv/www/css/bootstrap.css':
-                let filepath = path.join(root, pathname);
-            // 获取文件状态:
-                fs.stat(filepath, function (err, stats) {
-                    if (!err && stats.isFile()) {
-                    // 没有出错并且文件存在:
-                        console.log('200 ' + request.url);
-                    // 发送200响应:
-                        response.writeHead(200);
-                    // 将文件流导向response:
-                        fs.createReadStream(filepath).pipe(response);
-                    } else {
-                    // 出错了或者文件不存在:
-                        console.log('404 ' + request.url);
-                    // 发送404响应:
-                        response.writeHead(404);
-                        response.end('404 Not Found');
-                    }
-                });
-            });
-            
-            server.listen(8080);
-            console.log('Server is running at http://127.0.0.1:8080/');
-    ```
-    > 没有必要手动读取文件内容。由于**response对象**本身是一个 ***Writable Stream***，直接用 *pipe*() 方法就实现了自动读取文件内容并输出到**HTTP响应**
-
-+ 在命令行运行``node file_server.js /path/to/dir``把 **/path/to/dir** 改成你本地的一个有效的目录，然后在浏览器中输入``**http://localhost:8080/index.html**``：
-
-    > 只要当前目录下存在文件 *index.html* ，服务器就可以把文件内容发送给浏览器。观察控制台输出：
-    ```js
-        200 /index.html
-        200 /css/uikit.min.css
-        200 /js/jquery.min.js
-        200 /fonts/fontawesome-webfont.woff2
-    ```
-    > 第一个请求是浏览器请求 *index.html* 页面，后续请求是 *浏览器解析HTML后发送的其它资源请求*
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230221-node.js\347\232\204Web\347\250\213\345\272\217\345\210\244\346\226\255\346\226\207\344\273\266\343\200\201\346\226\207\344\273\266\345\244\271.md" "b/05\345\210\230\350\203\241/230221-node.js\347\232\204Web\347\250\213\345\272\217\345\210\244\346\226\255\346\226\207\344\273\266\343\200\201\346\226\207\344\273\266\345\244\271.md"
deleted file mode 100644
index defda695c775a5e2beb519a44782ada67f06fb98..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230221-node.js\347\232\204Web\347\250\213\345\272\217\345\210\244\346\226\255\346\226\207\344\273\266\343\200\201\346\226\207\344\273\266\345\244\271.md"
+++ /dev/null
@@ -1,70 +0,0 @@
-**Node.js**的web程序判断文件、文件夹
-===
- 当我们创建了一个文件服务器，可以更多的扩展，去实现的我们所需要的结果，像是 **开发web程序** 。因为用 **node.js** 去创建服务器，所以只用去掌握好***JavaScript语言***，因为拥有异步执行，也可以减少等待代码执行的时间，只用等代码的返回
-
-创建服务器
----
-+ 先用node.js去创建服务器
-    > 创建一个main.js，在里面实现服务器：
-    ```js
-    'use strict'
-
-        let http = require('http'),
-            fs = require('fs');
-        
-        let server = http.createServer(
-            function(request,response){
-                response.writeHead(200,{"content-type":"text/html;charset=utf-8"});
-                response.end('Hello world!');
-            }
-        ).listen(8080);
-
-        console.log('Server is runing at http://localhost:8080');
-    ```
-    > 这样就简单的创建好了一个 **web程序** ，接下来实现文件和文件夹的判断
-
-判断文件和文件夹
----
-+ 我们要引用到**fs 模块**，去使用 ***stat.isDirectory***() 方法去*判断文件夹和文件，我们来简单的用代码实现一下*
-
-    > 创建一个文件夹 *Project*，再创建 *main.js* 和 *index.html* 文件，利用代码去实现判断：
-    ```js
-    'use strict'
-
-        let fs = require('fs'),
-            http = require('http');
-
-        let server = http.createServer(
-            function(request,response){
-                
-                let path ='.'+request.url;            
-                fs.stat(path,function(err,stats){
-                    if(!err){
-                        if(path == './'){
-                            response.writeHead(200,{"content-type":"text/html;charset=utf-8"});
-                            console.log(path);
-                            response.end('可以判断文件或文件夹');
-                        } 
-                        else if(stats.isDirectory()==true){
-                            response.writeHead(200,{"content-type":"text/html;charset=utf-8"});
-                            console.log(path);
-                            response.end('这是文件夹');
-                        }
-                        else{
-                            response.writeHead(200,{"content-type":"text/html;charset=utf-8"});
-                            console.log(path);
-                            response.end('这是文件');
-                        }
-                    }
-                    else{
-                        response.writeHead(404,{"content-type":"text/html;charset=utf-8"});
-                        console.log(path);
-                        response.end('不存在该文件、文件夹或不是文件和文件夹');
-                    }
-                });
-            }
-        ).listen(8080);
-
-        console.log('http://localhost:8080');
-    ```
-    > 像这样开发了一个判断文件夹和文件的**web程序**
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230223-node.js\347\232\204Web\347\250\213\345\272\217\345\210\244\346\226\255\346\226\207\344\273\266\343\200\201\346\226\207\344\273\266\345\244\2712.md" "b/05\345\210\230\350\203\241/230223-node.js\347\232\204Web\347\250\213\345\272\217\345\210\244\346\226\255\346\226\207\344\273\266\343\200\201\346\226\207\344\273\266\345\244\2712.md"
deleted file mode 100644
index 5cdc2926d6bc2b6fd054eea55e4a4215e5385b5d..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230223-node.js\347\232\204Web\347\250\213\345\272\217\345\210\244\346\226\255\346\226\207\344\273\266\343\200\201\346\226\207\344\273\266\345\244\2712.md"
+++ /dev/null
@@ -1,44 +0,0 @@
-**Node.js**的web程序判断文件、文件夹 *2*
-===
-用**Node.js**去做一个***文件、文件夹的判断程序***，在判断文件和文件夹时，我们往往也会将文件的内容也显示出来，当然也有多种方法去实现我们想要的效果，有*同步、promise和其他方法！*
-  
-一 .判断文件、文件夹的同步方法：
----
-+ 同步方法的文件、文件夹判断，代码是比较简单的，但是在遇到一些大文件的读写时，就会大大增加文件读写成功后返回相应的速度，所以一般在处理一些小文件时，还是可以的的，代码量也不是很大
-    > 创建一个main.js文件，去写我们的同步方法代码：
-    ```js
-    'use strict';
-
-    let fs = require('fs'),
-        http = require('http');
-
-        function readFile(path){
-            let result = 404;
-
-            let stats = fs.statSync(path);
-            
-            if(stats.isDirectory()){
-                let newPath = path+'index.html';
-                let data = fs.readFileSync(newPath,'utf-8');
-                result = data;
-            }
-            return result;
-        }
-
-        let server = http.createServer(function(request,response){
-            let path = '.'+request.url;
-            let datas = readFile(path);
-            response.end(datas);
-        }).listen('8080');
-
-        console.log("server is runing at http://localhost:8080");
-    ```    
-    > 虽然是同步方法，代码很简单，但是功能性是很差的
-
-二 .用promise方法判断文件、文件夹：
----
-+ 用promise方法，就可以使得异步执行成功，但会加大代码的编写难度，但是会提升响应速度
- 
-三 .用async/await去判断文件、文件夹：
----
-+ async/await这个东西其实是跟promise一样，并且不用像promise还要实例一下，用起来还是很方便的
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230224-node.js\347\232\204Web\345\274\200\345\217\221\345\222\214Koa\346\241\206\346\236\266.md" "b/05\345\210\230\350\203\241/230224-node.js\347\232\204Web\345\274\200\345\217\221\345\222\214Koa\346\241\206\346\236\266.md"
deleted file mode 100644
index e5b4d7b45e3cc566d9401aadf6ac38921e238a23..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230224-node.js\347\232\204Web\345\274\200\345\217\221\345\222\214Koa\346\241\206\346\236\266.md"
+++ /dev/null
@@ -1,89 +0,0 @@
-**Node.js**——**web开发和Koa框架**
-===
-在**web应用**开发之前，网页都是静态设计，以供浏览的，在有了 *JavaScript* 的语言之后，使得页面可以交互，随着发展，在网页上开发 **web应用**，也实现了起来，并且因为有了**node.js**可以在服务端运行的**JavaScript**的代码，*使得web应用兴起……，还有koa框架等等的开发，使得代码量更加简洁*
-
-一 .Web开发：
----
-### web应用的发展进程：  
-+ 最早的软件都是运行在大型机上，软件的使用通过“哑终端”登录到大型机上去运行软件，后面因为 *PC机* 的流行，软件主要运行在桌面上了，而数据库这样的软件运行在服务器端，这种 ***Client/Server模式*** 简称 **CS架构**，后来互联网的兴起，人们发现，**CS架构**不适合 **Web**，*最大的原因是 **Web应用程序** 的修改和升级非常迅速*，而 **CS架构** 需要每个客户端逐个升级桌面App，因此，***Browser/Server模式*** 开始流行，简称 **BS架构**，在 **BS架构** 下，客户端只需要浏览器，应用程序的逻辑和数据都存储在服务器端。浏览器只需要请求服务器，获取Web页面，并把Web页面展示给用户即可，服务器端升级后，客户端无需任何部署就可以使用到新的版本，*因此，**BS架构** 迅速流行起来*
-    + 现在大部分软件都可以用web提供服务，都被称为是web应用
-
-### web应用经历的几个阶段：
-1. **静态Web页面**：由文本编辑器直接编辑并生成静态的**HTML页面**，如果要修改Web页面的内容，就需要再次编辑**HTML源文件**，早期的互联网Web页面就是静态的；
-2. **CGI**：由于静态Web页面无法与用户交互，比如用户填写了一个注册表单，静态Web页面就无法处理。要处理用户发送的动态数据，出现了 *Common Gateway Interface* ，简称**CGI，用C/C++编写**。
-3. **ASP/JSP/PHP**：由于Web应用特点是修改频繁，用 *C/C++* 这样的低级语言非常不适合Web开发，而脚本语言由于开发效率高，与HTML结合紧密，因此，迅速取代了**CGI模式**。ASP是微软推出的用VBScript脚本编程的Web开发技术，而JSP用Java来编写脚本，PHP本身则是开源的脚本语言。
-4. **MVC**：为了解决直接用脚本语言嵌入HTML导致的可维护性差的问题，Web应用也引入了 **Model-View-Controller的模式** ，来简化Web开发。ASP发展为ASP.Net，JSP和PHP也有一大堆MVC框架。
-5. **Node.js**: 由于Node.js把JavaScript引入了服务器端，因此，原来必须使用PHP/Java/C#/Python/Ruby等其他语言来开发服务器端程序，现在可以使用Node.js开发了！
-
-### Node.js开发web服务端：
-> 用 **Node.js开发Web服务器端**，有几个显著的优势：
-1. 后端语言也是 *JavaScript* ，以前掌握了 *前端JavaScript* 的开发人员，现在可以同时编写后端代码
-2. 前后端统一使用 *JavaScript* ，就没有切换语言的障碍了
-3. 速度快，非常快！这得益于**Node.js天生是异步的**
-
-+ 在**Node.js**诞生后的短短几年里，出现了无数种***Web框架、ORM框架、模版引擎、测试框架、自动化构建工具***
-    > 1. 常见的Web框架包括：Express，Sails.js，koa，Meteor，DerbyJS，Total.js，restify……  
-    > 2. ORM框架比Web框架要少一些：Sequelize，ORM2，Bookshelf.js，Objection.js……  
-    > 3. 模版引擎PK：Jade，EJS，Swig，Nunjucks，doT.js……   
-    > 4. 测试框架包括：Mocha，Expresso，Unit.js，Karma……  
-    > 5. 构建工具有：Grunt，Gulp，Webpack……  
-    + 目前，在npm上已发布的开源Node.js模块数量超过了30万个
-
-二 .Koa的介绍：
----
-+ koa是Express的下一代基于Node.js的web框架，目前有1.x和2.0两个版本。
-
-### 历史
-
-1. **Express是第一代最流行的web框架**，它对**Node.js**的 *http* 进行了封装,虽然**Express**的**API**很简单，但是它是基于**ES5的语法**，要实现异步代码，只有一个方法：回调。  
-    + 如果异步嵌套层次过多，代码写起来就非常难看,虽然可以用async这样的库来组织异步代码，但是用回调写异步实在是太痛苦了
-
-2. 随着新版**Node.js**开始支持**ES6**，*Express的团队又基于ES6的 generator 重新编写了下一代 **web框架koa***。和**Express**相比，**koa 1.0**使用 *generator* 实现异步，代码看起来像同步的用 *generator* 实现异步比回调简单了不少，但是***generator的本意并不是异步***,**Promise**才是为异步设计的，但是**Promise**的写法比较复杂,为了简化异步代码，**ES7**（目前是草案，还没有发布）引入了新的**关键字 async 和 await** ，***可以轻松地把一个function变为异步模式，这是JavaScript未来标准的异步代码，非常简洁，并且易于使用***。
-
-3. **koa**团队并没有止步于**koa 1.0**，他们非常超前地基于**ES7**开发了**koa2**，和***koa 1相比，koa2完全使用Promise并配合async来实现异步***
-
-    > **koa2**的代码看上去像这样：
-    ```js
-    app.use(async (ctx, next) => {
-        await next();
-        var data = await doReadFile();
-        ctx.response.type = 'text/plain';
-        ctx.response.body = data;
-    });
-    ```
-    > 出于兼容性考虑，目前koa2仍支持generator的写法，但下一个版本将会去掉
-
-三 .Koa的入门：
----
-
-+ 创建**koa2工程**
-
-    >首先，我们创建一个目录并作为工程目录用**VS Code打开**。然后，我们创建 *app.js*，输入以下代码：
-    ```js
-    // 导入koa，和koa 1.x不同，在koa2中，我们导入的是一个class，因此用大写的Koa表示:
-        const Koa = require('koa');
-    // 创建一个Koa对象表示web app本身:
-        const app = new Koa();  
-    // 对于任何请求，app将调用该异步函数处理请求：
-        app.use(async (ctx, next) => { 
-            await next();
-            ctx.response.type = 'text/html';
-            ctx.response.body = '<h1>Hello, koa2!</h1>';
-        });
-    // 在端口3000监听:
-        app.listen(3000);
-        console.log('app started at port 3000...');
-    ```
-    > 对于每一个**http请求**，**koa** 将调用我们传入的异步函数来处理：
-    ```js
-    async (ctx, next) => {
-        await next();
-        // 设置response的Content-Type:
-        ctx.response.type = 'text/html';
-        // 设置response的内容:
-        ctx.response.body = '<h1>Hello, koa2!</h1>';
-    }
-    ```
-    + 其中，参数ctx是由koa传入的封装了request和response的变量，我们可以通过它访问request和response，next是koa传入的将要处理的下一个异步函数
-
-    > 上面的异步函数中，我们首先用 **await next**() ;处理下一个异步函数，然后，设置 *response* 的Content-Type和内容。由async标记的函数称为异步函数，在异步函数中，可以用await调用另一个异步函数，这两个关键字将在ES7中引入。
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230227-node.js-Koa\346\241\206\346\236\266\345\222\214URL\345\244\204\347\220\206.md" "b/05\345\210\230\350\203\241/230227-node.js-Koa\346\241\206\346\236\266\345\222\214URL\345\244\204\347\220\206.md"
deleted file mode 100644
index 3443365e608a7a18c7237785f1b60b287299d571..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230227-node.js-Koa\346\241\206\346\236\266\345\222\214URL\345\244\204\347\220\206.md"
+++ /dev/null
@@ -1,209 +0,0 @@
-**Node.js——Koa框架和URL处理**
-===
-用**Node.js**的**包npm管理器去下载Koa**,使用**Koa框架**，用**Koa框架**去创建一个web应用，代码会简单很多，更加简洁方便，还有**URL的处理**，用到Koa-router，[**路由**](https://baike.baidu.com/item/%E8%B7%AF%E7%94%B1/363497)（这里指网路工程术语的路由），在对应的请求显示不同的响应，路由也是用到比较多的
-> 下载Koa之后，去引用Koa和实例化：
-```js
-    //先去引用模块：
-        const Koa = require('Koa');
-    //再去实例化：
-        let app = new Koa();
-```
-> 这样就是去引用到Koa和实例
-
-一 .**Koa框架**：
----
-### 1 .下载Koa:
-+ 下载Koa有俩种方法：
-    1. **方法一**：直接用npm命令下载Koa,并且创建一个文件夹，并在改文件下去进行：
-        ```ps
-        c://……/文件夹> npm install Koa@2.0.0
-        ```
-    > npm会把koa2以及koa2依赖的所有包全部安装到当前文件夹目录下
-
-    2. **方法二**:创建一个文件夹，在这个文件夹目录下创建一个package.json，这个文件描述了会用到哪些包，完整的文件内容如下：
-        ```json
-        {
-            "name": "hello-koa2",
-            "version": "1.0.0",
-            "description": "Hello Koa 2 example with async",
-            "main": "app.js",
-            "scripts": {
-                "start": "node app.js"
-            },
-            "keywords": [
-                "koa",
-                "async"
-            ],
-            "author": "Michael Liao",
-            "license": "Apache-2.0",
-            "repository": {
-                "type": "git",
-                "url": "https://github.com/michaelliao/learn-javascript.git"
-            },
-            "dependencies": {
-                "koa": "2.0.0"
-            }
-        }
-        ```
-    > 其中，*dependencies* 描述了我们的工程依赖的包以及版本号。其他字段均用来描述项目信息，可任意填写
-
-    > 然后，我们在文件夹目录下执行``npm install``就可以把所需包以及依赖包一次性全部装好：
-    ```ps
-    C:\...\hello-koa> npm install
-    ```
-    >很显然，第二个方法更靠谱，因为我们只要在**package.json**正确设置了依赖，npm就会把所有用到的包都装好
-
-    + 注意，任何时候都可以直接删除整个**node_modules目录**,因为用``npm install``命令可以完整地重新下载所有依赖。并且，这个目录不应该被放入版本控制中
-    > 紧接着，我们在**package.json**中添加依赖包：
-    ```json
-    "dependencies": {
-        "koa": "2.0.0"
-    }
-    ```
-    > 然后使用``npm install``命令安装后，在VS Code中 **执行js文件** ，调试控制台输出如下：
-    ```ps
-        node --debug-brk=40645 --nolazy app.js 
-        Debugger listening on port 40645
-        app started at port 3000...
-    ```
-    > 我们打开浏览器，输入http://localhost:3000，即可看到效果.
-
-### 2 .用npm启动程序
-+ 还可以直接用命令``node app.js``在命令行启动程序，或者用``npm start``启动。``npm start``命令会让npm执行定义在**package.json文件**中的**start对应命令**：
-    ```json
-    "scripts": {
-        "start": "node app.js",
-        "":"IMP"
-    }
-    ```
-
-### 3 .koa middleware
-+ 让我们再仔细看看koa的执行逻辑。核心代码是：
-    ```js
-    app.use(async (ctx, next) => {
-        await next();
-        ctx.response.type = 'text/html';
-        ctx.response.body = '<h1>Hello, koa2!</h1>';
-    });
-    ```
-    > 每收到一个http请求，koa就会调用通过app.use()注册的async函数，并传入ctx和next参数
-
-+ 我们可以对ctx操作，并设置返回内容。但是为什么要调用await next()？原因是koa把很多async函数组成一个处理链，每个async函数都可以做一些自己的事情，然后用await next()来调用下一个async函数。我们把每个async函数称为middleware，这些middleware可以组合起来，完成很多有用的功能
-
-    > 例如，可以用以下3个middleware组成处理链，依次打印日志，记录处理时间，输出HTML：
-    ```js
-    app.use(async (ctx, next) => {
-        console.log(`${ctx.request.method} ${ctx.request.url}`); // 打印URL
-        await next(); // 调用下一个middleware
-    });
-
-    app.use(async (ctx, next) => {
-        const start = new Date().getTime(); // 当前时间
-        await next(); // 调用下一个middleware
-        const ms = new Date().getTime() - start; // 耗费时间
-        console.log(`Time: ${ms}ms`); // 打印耗费时间
-    });
-
-    app.use(async (ctx, next) => {
-        await next();
-        ctx.response.type = 'text/html';
-        ctx.response.body = '<h1>Hello, koa2!</h1>';
-    });
-    ```
-
-    + middleware的顺序很重要，也就是调用app.use()的顺序决定了middleware的顺序
-
-+ 此外，如果一个middleware没有调用await next()，会怎么办？答案是后续的middleware将不再执行了。这种情况也很常见，例如，一个检测用户权限的middleware可以决定是否继续处理请求，还是直接返回403错误：
-    ```js
-    app.use(async (ctx, next) => {
-        if (await checkUserPermission(ctx)) {
-            await next();
-        } else {
-            ctx.response.status = 403;
-        }
-    });
-    ```
-    > 理解了middleware，我们就已经会用koa了！
-
-    + 最后注意ctx对象有一些简写的方法，例如ctx.url相当于ctx.request.url，ctx.type相当于ctx.response.type
-
-二 .URL处理
----
-
-+ 在我们处理http请求一律返回相同的HTML，这样虽然非常简单，但是用浏览器一测，随便输入任何URL都会返回相同的网页
-
-    >正常情况下，我们应该对不同的URL调用不同的处理函数，这样才能返回不同的结果。例如像这样写：
-    ```js
-    app.use(async (ctx, next) => {
-        if (ctx.request.path === '/') {
-            ctx.response.body = 'index page';
-        } else {
-            await next();
-        }
-    });
-    app.use(async (ctx, next) => {
-        if (ctx.request.path === '/test') {
-            ctx.response.body = 'TEST page';
-        } else {
-            await next();
-        }
-    });
-    app.use(async (ctx, next) => {
-        if (ctx.request.path === '/error') {
-            ctx.response.body = 'ERROR page';
-        } else {
-            await next();
-        }
-    });
-    ```
-    > 应该有一个能集中**处理URL的middleware**，它根据不同的URL调用不同的处理函数，这样，我们才能专心为每个URL编写处理函数
-
-### **koa-router**:
-+ 为了**处理URL**，我们需要引入**koa-router**这个 *middleware*，让它负责**处理URL映射**
-
-    >先在**package.json**中添加依赖项：
-    ```json
-    "koa-router": "7.0.0"
-    ```
-+ 然后用``npm install``安装
-
-    >接下来,使用koa-router来处理URL：
-    ```js
-        const Koa = require('koa');
-    // 注意require('koa-router')返回的是函数:
-        const router = require('koa-router')();
-        const app = new Koa();
-    // log request URL:
-        app.use(async (ctx, next) => {
-            console.log(`Process ${ctx.request.method} ${ctx.request.url}...`);
-            await next();
-        });
-    // add url-route:
-        router.get('/hello/:name', async (ctx, next) => {
-            var name = ctx.params.name;
-            ctx.response.body = `<h1>Hello, ${name}!</h1>`;
-        });
-
-        router.get('/', async (ctx, next) => {
-            ctx.response.body = '<h1>Index</h1>';
-        });
-    // add router middleware:
-        app.use(router.routes());
-        app.listen(3000);
-        console.log('app started at port 3000...');
-    ```
-    > 注意导入**koa-router**的语句 ***最后的()是函数调用***：
-    ```js
-    const router = require('koa-router')();
-    ```
-    > 相当于：
-    ```js
-    const fn_router = require('koa-router');
-    const router = fn_router();
-    ```
-+ 然后，我们使用``router.get('/path', async fn)``来注册一个**GET请求**。可以在请求路径中使用带变量的``/hello/:name``，变量可以通过**ctx.params.name访问**
-    > 再运行，我们就可以测试不同的URL：
-    ```JS
-        输入首页：http://localhost:3000/
-        输入：http://localhost:3000/hello/koa
-    ```
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230228-node.js-URL\345\244\204\347\220\206\347\232\204post\350\257\267\346\261\202\345\222\214\351\207\215\346\236\204.md" "b/05\345\210\230\350\203\241/230228-node.js-URL\345\244\204\347\220\206\347\232\204post\350\257\267\346\261\202\345\222\214\351\207\215\346\236\204.md"
deleted file mode 100644
index 96d8698bdddfc40a392a87bfb9967f58a5ffeee3..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230228-node.js-URL\345\244\204\347\220\206\347\232\204post\350\257\267\346\261\202\345\222\214\351\207\215\346\236\204.md"
+++ /dev/null
@@ -1,126 +0,0 @@
-**Node.js**——**URL处理的post请求和重构**
-===
-在用**Node.js创建了web应用服务器**后，会有一些对 *URL的处理*，有**get、post、delete、put**等一类的请求，跟路由都有关系，但在一个比较完善的系统结构中，这种路由请求会很多，所以用重构，将他们去分类统一放在各自的文件夹中，这样更便于去写处理的代码，只用调用出来就好了，也可以让逻辑关系更加清晰
-
-一 .URL处理的post请求:
----
-
-用``router.get('/path', async fn)``处理的是**get请求**,如果要**处理post请求**，可以用``router.post('/path', async fn)``
-
-+ 用**post请求处理URL**时，我们会遇到一个问题：*post请求通常会发送一个表单，或者JSON* ，它作为**request的body**发送，但无论是**Node.js**提供的***原始request对象，还是koa提供的request对象，都不提供解析request的body的功能***
-
-    + 所以，我们又需要引入另一个 *middleware* 来解析原始**request请求**，然后，把解析后的参数，绑定到`ctx.request.body`中
-
-+ **koa-bodyparser**就是用来干这个活的
-
-    > 我们在**package.json**中添加依赖项：
-    ```json
-    "koa-bodyparser": "3.2.0"
-    ```
-    > 然后使用`npm install`安装
-
-    > 下面修改js文件，引入koa-bodyparser：
-    ```js
-        const bodyParser = require('koa-bodyparser');
-    // 在合适的位置加上：
-        app.use(bodyParser());
-    ```
-    + 由于 *middleware* 的顺序很重要，这个**koa-bodyparser**必须在**router**之前被 *注册到app对象上*
-
-> 现在我们就可以**处理post请求**了。写一个简单的登录表单：
-```js
-    router.get('/', async (ctx, next) => {
-        ctx.response.body = `<h1>Index</h1>
-            <form action="/signin" method="post">
-                <p>Name: <input name="name" value="koa"></p>
-                <p>Password: <input name="password" type="password"></p>
-                <p><input type="submit" value="Submit"></p>
-            </form>`;
-    });
-
-    router.post('/signin', async (ctx, next) => {
-        var
-            name = ctx.request.body.name || '',
-            password = ctx.request.body.password || '';
-        console.log(`signin with name: ${name}, password: ${password}`);
-        if (name === 'koa' && password === '12345') {
-            ctx.response.body = `<h1>Welcome, ${name}!</h1>`;
-        } else {
-            ctx.response.body = `<h1>Login failed!</h1>
-            <p><a href="/">Try again</a></p>`;
-        }
-    });
-```
-+ 注意到我们用`var name = ctx.request.body.name || ''`拿到表单的**name字段**，如果该字段不存在，默认值设置为''
-
-    > 类似的，**put、delete、head请求**也可以由**router处理**。
-
-二 .重构项目
----
-现在，我们已经可以处理不同的URL了，但是看看js文件，总觉得还是有点不对劲
-
-+ 所有的URL处理函数都放到js文件里显得很乱，而且，每加一个URL，就需要修改js文件,随着URL越来越多，js文件就会越来越长
-
-    >如果能把URL处理函数集中到某个js文件，或者某几个js文件中就好了，然后让app.js自动导入所有处理URL的函数。这样，代码一分离，逻辑就显得清楚了，最好是这样：
-    ```
-    url2-koa/
-    |
-    +- .vscode/
-    |  |
-    |  +- launch.json <-- VSCode 配置文件
-    |
-    +- controllers/
-    |  |
-    |  +- login.js <-- 处理login相关URL
-    |  |
-    |  +- users.js <-- 处理用户管理相关URL
-    |
-    +- app.js <-- 使用koa的js
-    |
-    +- package.json <-- 项目描述文件
-    |
-    +- node_modules/ <-- npm安装的所有依赖包
-    ```
-
-    > 我们先在controllers目录下编写index.js：
-    ```js
-    var fn_index = async (ctx, next) => {
-        ctx.response.body = `<h1>Index</h1>
-            <form action="/signin" method="post">
-                <p>Name: <input name="name" value="koa"></p>
-                <p>Password: <input name="password" type="password"></p>
-                <p><input type="submit" value="Submit"></p>
-            </form>`;
-    };
-
-    var fn_signin = async (ctx, next) => {
-        var
-            name = ctx.request.body.name || '',
-            password = ctx.request.body.password || '';
-        console.log(`signin with name: ${name}, password: ${password}`);
-        if (name === 'koa' && password === '12345') {
-            ctx.response.body = `<h1>Welcome, ${name}!</h1>`;
-        } else {
-            ctx.response.body = `<h1>Login failed!</h1>
-            <p><a href="/">Try again</a></p>`;
-        }
-    };
-
-    module.exports = {
-        'GET /': fn_index,
-        'POST /signin': fn_signin
-    };
-    ```
-    > 这个index.js通过module.exports把两个URL处理函数暴露出来。
-
-    > 类似的，hello.js把一个URL处理函数暴露出来：
-    ```js
-    var fn_hello = async (ctx, next) => {
-        var name = ctx.params.name;
-        ctx.response.body = `<h1>Hello, ${name}!</h1>`;
-    };
-
-    module.exports = {
-        'GET /hello/:name': fn_hello
-    };
-    ```
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230302-node.js-URL\345\244\204\347\220\206\350\257\267\346\261\202\345\222\214\351\241\271\347\233\256\351\207\215\346\236\204.md" "b/05\345\210\230\350\203\241/230302-node.js-URL\345\244\204\347\220\206\350\257\267\346\261\202\345\222\214\351\241\271\347\233\256\351\207\215\346\236\204.md"
deleted file mode 100644
index f48d79eab1bec83738025ae36519411e4e1231a3..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230302-node.js-URL\345\244\204\347\220\206\350\257\267\346\261\202\345\222\214\351\241\271\347\233\256\351\207\215\346\236\204.md"
+++ /dev/null
@@ -1,140 +0,0 @@
-**Node.js**——**URL处理请求和项目重构**
-===
-在一个**Node.js的web应用项目**里，**URL的处理**可以说是非常繁琐的，所以要去 *进行包装重构，这样能让代码更加简洁，逻辑更加清晰明了* ，创建一个文件夹去将这些不同页面访问URL处理进行封装成模块，只用去引用
-
-一 .url的处理请求：
----
-
-### 1 .http的请求方法：
-+ URL处理，http的请求方法：
-
-|**方法**：|描述：|
-|---|---|
-|**GET**|请求指定的页面信息，并返回实体主体|
-|**HEAD**|类似于 GET 请求，只不过返回的响应中没有具体的内容，用于获取报头|
-|**POST**|向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST 请求可能会导致新的资源的建立和/或已有资源的修改|
-|**PUT**|从客户端向服务器传送的数据取代指定的文档的内容|
-|**DELETE**	|请求服务器删除指定的页面|
-|**CONNECT**|HTTP/1.1 协议中预留给能够将连接改为管道方式的代理服务器|
-|**OPTIONS**|允许客户端查看服务器的性能|
-|**TRACE**|回显服务器收到的请求，主要用于测试或诊断|
-|**PATCH**|是对 PUT 方法的补充，用来对已知资源进行局部更新|
-
- > 常用的请求方法有**get、post、put、delete**这些请求,会常写这些请求的处理方法和模块
-
-### 2 .对URL处理引用的模块:
-+ 用Koa框架在对URL路由处理时，会引用到很多的模块
-    > 会引用到的模块代码：
-    ```js
-    const
-        Koa = require('Koa'),
-        router = require('kao-router')(),
-        bodyParser = require('koa-bodyparser');
-        fs = require('fs');
-    ```
-    > 这些模块的
-
-二 .项目模块扫描重构：
----
-+ 我们把项目重构，很多模块都存放在一个文件夹下，包装好，所以在调用的时候，将他们都扫描一遍，不用再去一个一个的调用，也是为了减少代码的写入量
-
-    > 现在，我们修改**主程序js文件**让它自动**扫描controllers目录**，*找到所有js文件，导入，然后注册每个URL* ：
-    ```js
-    // 先导入fs模块，然后用readdirSync列出文件
-    // 这里可以用sync是因为启动时只运行一次，不存在性能问题:
-        var files = fs.readdirSync(__dirname + '/controllers');
-        // 过滤出.js文件:
-        var js_files = files.filter((f)=>{
-            return f.endsWith('.js');
-        });
-    // 处理每个js文件:
-        for (var f of js_files) {
-            console.log(`process controller: ${f}...`);
-        // 导入js文件:
-            let mapping = require(__dirname + '/controllers/' + f);
-            for (var url in mapping) {
-                if (url.startsWith('GET ')) {
-                // 如果url类似"GET xxx":
-                    var path = url.substring(4);
-                    router.get(path, mapping[url]);
-                    console.log(`register URL mapping: GET ${path}`);
-                } else if (url.startsWith('POST ')) {
-                // 如果url类似"POST xxx":
-                    var path = url.substring(5);
-                    router.post(path, mapping[url]);
-                    console.log(`register URL mapping: POST ${path}`);
-                } else {
-                // 无效的URL:
-                    console.log(`invalid URL: ${url}`);
-                }
-            }
-        }
-    ```
-    > 如果上面的大段代码看起来还是有点费劲，那就把它拆成更小单元的函数：
-    ```js
-    function addMapping(router, mapping) {
-        for (var url in mapping) {
-            if (url.startsWith('GET ')) {
-                var path = url.substring(4);
-                router.get(path, mapping[url]);
-                console.log(`register URL mapping: GET ${path}`);
-            } else if (url.startsWith('POST ')) {
-                var path = url.substring(5);
-                router.post(path, mapping[url]);
-                console.log(`register URL mapping: POST ${path}`);
-            } else {
-                console.log(`invalid URL: ${url}`);
-            }
-        }
-    }
-
-    function addControllers(router) {
-        var files = fs.readdirSync(__dirname + '/controllers');
-        var js_files = files.filter((f) => {
-            return f.endsWith('.js');
-        });
-
-        for (var f of js_files) {
-            console.log(`process controller: ${f}...`);
-            let mapping = require(__dirname + '/controllers/' + f);
-            addMapping(router, mapping);
-        }
-    }
-
-    addControllers(router);
-    ```
-    + 确保每个函数功能非常简单，一眼能看明白，是代码可维护的关键
-
-三 .设置 Middleware 
----
-将一些在**controllers目录和route要引入的模块封装好在一个模块中**，这样去减少主程序js文件中的繁琐代码
-+ 最后把扫描**controllers目录**和**创建router的代码**从 *入口js文件中提取出来，作为一个简单的middleware使用* ，命名为**index.js**存放在**controllers目录**：
-    ```js
-    const fs = require('fs');
-
-    function addMapping(router, mapping) {
-        ...
-    }
-    function addControllers(router, dir) {            
-        ...
-    }
-    module.exports = function (dir) {
-        let
-            // 如果不传参数，扫描目录默认为'controllers'
-            controllers_dir = dir || 'controllers',            
-            router = require('koa-router')();
-            addControllers(router, controllers_dir);
-            return router.routes();
-        };
-    ```
-    > 这样一来，我们在**主程序的js文件代码**就又简化了：
-    ```js
-    ...
-    // 导入controller middleware:
-    const controller = require('./controller');
-    ...
-    // 使用middleware:
-    app.use(controller());
-    ...
-    ```
-+ 经过重新整理后的项目具备非常好的模块化，所有**处理URL**的***函数按功能组存放在controllers目录，今后我们也只需要不断往这个目录下加东西就可以了，主程序的js文件保持不变***
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230303-node.js-\351\207\215\346\236\204\351\241\271\347\233\2562.md" "b/05\345\210\230\350\203\241/230303-node.js-\351\207\215\346\236\204\351\241\271\347\233\2562.md"
deleted file mode 100644
index dc6eb562b1416c192a2ca9448ac71d07cb488fe8..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230303-node.js-\351\207\215\346\236\204\351\241\271\347\233\2562.md"
+++ /dev/null
@@ -1,17 +0,0 @@
-# 项目重构
-在一个Node.js的web应用项目里，URL的处理可以说是非常繁琐的，所以要去 进行包装重构，这样能让代码更加简洁，逻辑更加清晰明了 ，创建一个文件夹去将这些不同页面访问URL处理进行封装成模块，只用去引用
-## 设置 Middleware
-将一些在controllers目录和route要引入的模块封装好在一个模块中，这样去减少主程序js文件中的繁琐代码
-
-最后把扫描controllers目录和创建router的代码从 入口js文件中提取出来，作为一个简单的middleware使用 ，命名为index.js存放在controllers目录：
-
-这样一来，我们在主程序的js文件代码就又简化了：
-
-...
-// 导入controller middleware:
-const controller = require('./controller');
-...
-// 使用middleware:
-app.use(controller());
-...
-经过重新整理后的项目具备非常好的模块化，所有处理URL的函数按功能组存放在controllers目录，今后我们也只需要不断往这个目录下加东西就可以了，主程序的js文件保持不变
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230306-node.js-\346\241\206\346\236\266.md" "b/05\345\210\230\350\203\241/230306-node.js-\346\241\206\346\236\266.md"
deleted file mode 100644
index c5219291cf9725e8245f5466f3160706211bff11..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230306-node.js-\346\241\206\346\236\266.md"
+++ /dev/null
@@ -1,45 +0,0 @@
-### 框架
-
-
-小步骤
-```js
-// 引入Koa模块
-const Koa = require('koa');
-//导入控制器模块，并且处理post请求参数的反序列化，注册路由
-const controller = require('./controllers')
-//创建实例
-let app = new Koa();
-//调用控制器模块
-controller(app);
-//监听运行
-let port = 3000;
-app.listen(port);
-//打印下服务地址
-console.log(`http://127.0.0.1:${post}`);
-
-```
-
-注册路由
-
-```js
-const bodyparser = require('koa-bodyparser')
-
-const { findFiles, registiR } = require('../utils/help')
-
-function initRouter(app) {
-    //找出所有的路由文件
-    let contFiles = findFiles();
-    //注册所有定义好的路由
-
-    registiR(contFiles);
-    //需要引入bodyParser模块的帮助，使post请求获取参数方便
-    app.use(bodyparser());
-
-    //注册路由中间件
-    app.use(router.touters());
-
-}
-module.exports = initRouter;
-
-
-```
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230307-node.js-\346\250\241\346\235\277\345\274\225\346\223\216.md" "b/05\345\210\230\350\203\241/230307-node.js-\346\250\241\346\235\277\345\274\225\346\223\216.md"
deleted file mode 100644
index 3f590d77d8bd4ca5cf25034a4edff30e5787e8dd..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230307-node.js-\346\250\241\346\235\277\345\274\225\346\223\216.md"
+++ /dev/null
@@ -1,24 +0,0 @@
-## Nunjucks
-变量env就表示Nunjucks模板引擎对象，它有一个render(view, model)方法，正好传入view和model两个参数，并返回字符串。
-
-创建env需要的参数可以查看文档获知。我们用opts.noCache || false这样的代码给每个参数加上默认值，最后使用new nunjucks.FileSystemLoader('views')创建一个文件系统加载器，从views目录读取模板。
-
-
-# 练习
-```js
-'use strict'
-const nunjucks = require('nunjucks');
-
-let env = nunjucks.configure('views',{
-    autoescape:true,watch:true,noCache:true
-});
-function temp(){
-    return async(ctx,next)=>{
-        ctx.render =function(view,data){
-            ctx.body = env.render(view,data);
-        }
-        await next;
-    }
-}
-module.exports=temp;
-```
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230309-node.js-MVC.md" "b/05\345\210\230\350\203\241/230309-node.js-MVC.md"
deleted file mode 100644
index db88f9a47dd0c128c1ff9387e71c02c955e5acd5..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230309-node.js-MVC.md"
+++ /dev/null
@@ -1,36 +0,0 @@
-## 封装静态资源
-如何上传 
-
-
-# 练习
-```js
-'use strict';
-
-//安装mine使用css文件
-const mime = require('mime');
-//异步文件的引用
-const fs = require('fs/promises');
-
-function statics(){
-    return async (ctx, next) => {
-        let tmpPath = ctx.request.path;
-        console.log(tmpPath);
-        let fullPath = __dirname + tmpPath;
-        // await next();
-        if (tmpPath.startsWith('/statics')) {
-            //判断这个文件是否存在，存在则读取，返回给响应，否则返回404
-            let stat = await fs.stat(fullPath);
-            if (stat.isFile()) {
-                ctx.type = mime.getType(fullPath);
-                ctx.body = await fs.readFile(fullPath);
-            } else {
-                ctx.response.status = 404;
-            }
-        } else {
-            await next();
-        }
-    }
-}
-
-module.exports=statics;
-```
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/230310-node.js-\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245.md" "b/05\345\210\230\350\203\241/230310-node.js-\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245.md"
deleted file mode 100644
index 6028eae075a5672d096699af0c7a044dbe14c108..0000000000000000000000000000000000000000
--- "a/05\345\210\230\350\203\241/230310-node.js-\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245.md"
+++ /dev/null
@@ -1,69 +0,0 @@
-# 数据库的连接
-
-引入sequelize这个orm工具
-
-
-
-```js
-'use strict';
-//引人Sequelize这个ORM工具
-const { Sequelize, DataTypes } = require('sequelize');
-const config = require('./config');
-
-let db  = new Sequelize(config.database,config.uid,config.pwd,{
-    host :config.host ;
-    dialect:'mysql'
-})
-
-let User = db.define('user', {
-    id: {
-        type: DataTypes.STRING,
-        primaryKey: true
-    },
-    username: DataTypes.STRING,
-    password: DataTypes.STRING,
-    avatar: DataTypes.STRING
-});
-// 定义模型
-let Role=db.define('roles',{
-    id: {
-        type: DataTypes.STRING,
-        primaryKey: true
-    },
-    roleName:DataTypes.STRING
-})
-// 将模型同步到数据库，即根据模型定义，生成相应的数据库表
-db.sync({force:true}).then(() => {
-    // 将数据插入到数据表
-    User.create({
-        id: '1',
-        username: 'admin',
-        password: '113',
-        avatar: '888'
-    });
-
-    Role.create({
-        id:'3',
-        roleName:'super admin'
-    })
-
-});
-
-
-
-
-let app = new Koa();
-
-// 处理静态资源的逻辑：判断path是不是包含statics，是则表示都是静态资源，否则放行await next();
-app.use(statics());
-
-let config = {
-    database: 'db2',
-    host: 'localhost',
-    uid: 'root',
-    pwd: 'root',
-    port: 5432
-}
-
-module.exports = config;
-```
\ No newline at end of file
diff --git "a/05\345\210\230\350\203\241/imgs/Node.js\344\270\213\350\274\211/Node\345\256\230\347\275\221\344\270\213\350\275\275\345\234\260\345\235\200.png" "b/05\345\210\230\350\203\241/imgs/Node.js\344\270\213\350\274\211/Node\345\256\230\347\275\221\344\270\213\350\275\275\345\234\260\345\235\200.png"
deleted file mode 100644
index f18161ea3f01d26fe97dd5f25cd6627e67415420..0000000000000000000000000000000000000000
Binary files "a/05\345\210\230\350\203\241/imgs/Node.js\344\270\213\350\274\211/Node\345\256\230\347\275\221\344\270\213\350\275\275\345\234\260\345\235\200.png" and /dev/null differ
diff --git "a/05\345\210\230\350\203\241/imgs/http\346\250\241\345\235\227/\347\256\200\345\215\225http\346\234\215\345\212\241\345\231\250\347\232\204\346\225\210\346\236\234.png" "b/05\345\210\230\350\203\241/imgs/http\346\250\241\345\235\227/\347\256\200\345\215\225http\346\234\215\345\212\241\345\231\250\347\232\204\346\225\210\346\236\234.png"
deleted file mode 100644
index a55aa0be546e034651456afc604c9cb369a28bab..0000000000000000000000000000000000000000
Binary files "a/05\345\210\230\350\203\241/imgs/http\346\250\241\345\235\227/\347\256\200\345\215\225http\346\234\215\345\212\241\345\231\250\347\232\204\346\225\210\346\236\234.png" and /dev/null differ
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230213-js\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md" "b/06\351\231\210\345\230\211\351\221\253/20230213-js\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
deleted file mode 100644
index 51d2771eacf6b9cdbb2bd863fd005ae02bf4dda1..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230213-js\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
+++ /dev/null
@@ -1,23 +0,0 @@
-# js的基本概念
-## node.js简介
-```
-node.js是一个js运行环境，是一个可以快速构建网络服务及应用的平台，是用js语言构建的服务平台，可用于后端建立服务器
-```
-## node.js与js的区别
-```
-node.js 主要应用后端 ‘平台运行环境’(一个基于Chrome JavaScript运行时建立的平台，它是对Google V8引擎进行了封装的运行环境)
-简单的说node.js就是把浏览器的解释器封装起来作为服务器运行平台，用类似javascript的结构语法进行编程，在node.js上运行
-Javascript主要应用前端，是编程语言 ，客户端编程语言(需要浏览器的javascript解释器进行解释执行)
-```
-## node.js的缺点
-```
-nodejs可靠性比较低，一个地方报错会导致整个程序崩溃，需要守护进程或者docker重启来解决
-单进程，单线程，只支持单核cpu，不能充分的利用多核cpu服务器
-```
-## node.js的优点
-```
-1.事件驱动
-2.异步编程
-3.非阻塞模式的IO
-4.轻量高效
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230214-js\347\232\204\347\254\254\344\272\214\350\257\276.md" "b/06\351\231\210\345\230\211\351\221\253/20230214-js\347\232\204\347\254\254\344\272\214\350\257\276.md"
deleted file mode 100644
index 150ae5b3f305c4419bee85d6389488aed2bb8d39..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230214-js\347\232\204\347\254\254\344\272\214\350\257\276.md"
+++ /dev/null
@@ -1,30 +0,0 @@
-## 命令行模式和交互式模式
-
-```
-交互模式的代码是输入一行，执行一行，而命令行模式下直接运行.py文件是一次性执行该文件内的所有代码
-```
-
-## 模块
-
-```
-随着一个文件的程序越来越长，越来越不容易维护。
-为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，在Node环境中，一个.js文件就称之为一个模块
-```
-
-## 模块的好处
-
-```
-最大的好处是大大提高了代码的可维护性，编写代码不必从零开始
-```
-
-如果我们要输出的是一个函数或数组，那么，只能给module.exports赋值：
-
-```js
-module.exports = function () { return 'foo'; };
-```
-
-当我们用require()获取module时，Node找到对应的module，把这个module的exports变量返回，这样，另一个模块就顺利拿到了模块的输出：
-
-```js
-var greet = require('./hello');
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230216-\345\237\272\346\234\254\346\250\241\345\235\227.md" "b/06\351\231\210\345\230\211\351\221\253/20230216-\345\237\272\346\234\254\346\250\241\345\235\227.md"
deleted file mode 100644
index 4d5e917f4bd8443d1414592765f0097993aa3d57..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230216-\345\237\272\346\234\254\346\250\241\345\235\227.md"
+++ /dev/null
@@ -1,51 +0,0 @@
-# 基本模块
-
-#  global
-
-在Node.js环境中，有唯一的全局对象，不叫window，而叫global，这个对象的属性和方法也和浏览器环境的window不同。进入Node.js交互环境，可以直接输入：
-
-```
-> global.console
-
-Console {
-  log: [Function: bound ],
-  info: [Function: bound ],
-  warn: [Function: bound ],
-  error: [Function: bound ],
-  dir: [Function: bound ],
-  time: [Function: bound ],
-  timeEnd: [Function: bound ],
-  trace: [Function: bound trace],
-  assert: [Function: bound ],
-  Console: [Function: Console] }
-```
-
-用Node执行上面的代码node test.js，你会看到，打印输出是：
-
-```
-nextTick was set!
-nextTick callback!
-```
-
-这说明传入process.nextTick()的函数不是立刻执行，而是要等到下一次事件循环。
-
-Node.js进程本身的事件就由process对象来处理。如果我们响应exit事件，就可以在程序即将退出时执行某个回调函数：
-
-```
-// 程序即将退出时的回调函数:
-process.on('exit', function (code) {
-    console.log('about to exit with code: ' + code);
-});
-```
-
-# 判断JavaScript执行环境
-
-有很多JavaScript代码既能在浏览器中执行，也能在Node环境执行，但有些时候，程序本身需要判断自己到底是在什么环境下执行的，常用的方式就是根据浏览器和Node环境提供的全局变量名称来判断：
-
-```
-if (typeof(window) === 'undefined') {
-    console.log('node.js');
-} else {
-    console.log('browser');
-}
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230217-fs.md" "b/06\351\231\210\345\230\211\351\221\253/20230217-fs.md"
deleted file mode 100644
index e5134b220f430434f16025c5f7b01c41a907f17b..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230217-fs.md"
+++ /dev/null
@@ -1,69 +0,0 @@
-#  fs 
-
-## 异步读文件
-
-```
-var fs = require('fs');
-
-fs.readFile('sample.txt', 'utf-8', function (err, data) {
-    if (err) {
-        console.log(err);
-    } else {
-        console.log(data);
-    }
-});
-```
-
-##  写文件
-
-```
-var fs = require('fs');
-
-var data = 'Hello, Node.js';
-fs.writeFile('output.txt', data, function (err) {
-    if (err) {
-        console.log(err);
-    } else {
-        console.log('ok.');
-    }
-});
-```
-
-## stat对象
-
-如果我们要获取文件大小，创建时间等信息，可以使用fs.stat()，它返回一个Stat对象，能告诉我们文件或目录的详细信息：
-
-```
-'use strict';
-
-var fs = require('fs');
-
-fs.stat('sample.txt', function (err, stat) { status
-    if (err) {
-        console.log(err);
-    } else {
-        // 是否是文件:
-        console.log('isFile: ' + stat.isFile());
-        // 是否是目录:
-        console.log('isDirectory: ' + stat.isDirectory());
-        if (stat.isFile()) {
-            // 文件大小:
-            console.log('size: ' + stat.size);
-            // 创建时间, Date对象:
-            console.log('birth time: ' + stat.birthtime);
-            // 修改时间, Date对象:
-            console.log('modified time: ' + stat.mtime);
-        }
-    }
-});
-```
-
-运行结果如下：
-
-```
-isFile: true
-isDirectory: false
-size: 181
-birth time: Fri Dec 11 2015 09:43:41 GMT+0800 (CST)
-modified time: Fri Dec 11 2015 12:09:00 GMT+0800 (CST)
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230217-http\346\234\215\345\212\241\345\231\250.md" "b/06\351\231\210\345\230\211\351\221\253/20230217-http\346\234\215\345\212\241\345\231\250.md"
deleted file mode 100644
index 84db7f8f0bbef07256516f5087e8dee369d64b06..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230217-http\346\234\215\345\212\241\345\231\250.md"
+++ /dev/null
@@ -1,26 +0,0 @@
-# HTTP服务器
-
-```
-要开发HTTP服务器程序，从头处理TCP连接，解析HTTP是不现实的。这些工作实际上已经由Node.js自带的http模块完成了。应用程序并不直接和
-HTTP协议打交道，而是操作http模块提供的request和response对象。
-
-request对象封装了HTTP请求，我们调用request对象的属性和方法就可以拿到所有HTTP请求的信息；
-
-response对象封装了HTTP响应，我们操作response对象的方法，就可以把HTTP响应返回给浏览器。
-```
-
-1. 请示相应的协议，本身是基于ICP/IP协议（request,response）
-2. 无状态
-3. 常见方法：put post get delete options
-4. websocket ws这个东西可以让服务器直接向客户端（浏览器、app、各种小程序等）发送消息
-
-```
-var http = require('http');
-var server = http.createServer(function(req,res){
-    res.writeHead(200,'sb');
-    res.end('yuchengxin BigSB');
-})
-server.listen(8080);
-console.log('点这里http://localhost:8080/')
-```
-
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230217-\345\215\201\344\270\252\347\275\221\347\253\231.md" "b/06\351\231\210\345\230\211\351\221\253/20230217-\345\215\201\344\270\252\347\275\221\347\253\231.md"
deleted file mode 100644
index 93c0af6d3ab893ce8bef74f80511b79a486a2002..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230217-\345\215\201\344\270\252\347\275\221\347\253\231.md"
+++ /dev/null
@@ -1,17 +0,0 @@
-# 十个网站
-
-```
-b1.laia.wang
-b2.laia.wang
-b3.laia.wang
-b4.laia.wang
-b5.laia.wang
-b6.laia.wang
-b7.laia.wang
-b8.laia.wang
-b9.laia.wang
-b10.laia.wang
-```
-
-
-
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230220\345\237\272\346\234\254\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md" "b/06\351\231\210\345\230\211\351\221\253/20230220\345\237\272\346\234\254\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"
deleted file mode 100644
index 39d4378c9208eb830185f7ecd9c50076340d369d..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230220\345\237\272\346\234\254\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"
+++ /dev/null
@@ -1,20 +0,0 @@
-# 文件服务器
-```
-var fs = require('fs');
-var http = require('http');
-var server = http.createServer((req,res)=>{
-    var url = '.' + req.url;
-    if(url==='./'){
-        url = './index.html';
-    }
-
-    fs.readFile(url,'utf-8',(err,data)=>{
-        if(err){
-            res.end('404');
-        }else{
-            res.writeHead(200,"'Content-Type':'text/html'",)
-            res.end(data);
-        }
-    })
-}).listen(8088);
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230223-\344\270\211\347\247\215\346\226\271\346\263\225.md" "b/06\351\231\210\345\230\211\351\221\253/20230223-\344\270\211\347\247\215\346\226\271\346\263\225.md"
deleted file mode 100644
index 2a83864bff29898972bc610ab4fd721b6ff3cff6..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230223-\344\270\211\347\247\215\346\226\271\346\263\225.md"
+++ /dev/null
@@ -1,65 +0,0 @@
-# 第一种
-```
-var fs = require('fs');
-var http = require('http');
-
-function ReadFile(url){
-    var result = '404';
-    
-    var stats = fs.statSync(url);
-    if(stats.isDirectory()){
-        var tmpUrl = '.' + url +'index.html';
-        var data = fs.readFileSync(tmpUrl,'utf-8');
-        result = data;
-    }
-    return result;
-}
-
-var server = http.createServer((req,res)=>{
-    var url = req.url;
-    var data = ReadFile(url);
-    res.writeHead(200,"'Content-Type':'text/html'");
-    res.end(data);
-}).listen('8088');
-```
-
-# 第二种
-```
-var fs = require('fs');
-var http = require('http');
-
-function ReadFile(url){
-    return new Promise((res,rej)=>{
-        fs.readFile(url,'utf-8',(err,data)=>{
-           if(err){
-            rej('404');
-           }else{
-            fs.stat(url,(err,stat)=>{
-                if(err){
-                    rej('404');
-                }else{
-                    if(stat.isDirectory()){
-                        res(data);
-                    }
-                }   
-            })
-           }
-        })
-    })
-}
-
-var server = http.createServer((req,res)=>{
-    var url = req.url;
-    var data = ReadFile(url);
-    data.then((x)=>{
-        res.end('成功');
-    }).catch((x)=>{
-        res.end('404');
-    });
-}).listen('8088');
-```
-
-# 第三种
-```
-await async
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230224-koa.md" "b/06\351\231\210\345\230\211\351\221\253/20230224-koa.md"
deleted file mode 100644
index 9479108e663736c8aa655255ef1a57a2fd71aa51..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230224-koa.md"
+++ /dev/null
@@ -1,13 +0,0 @@
-# Koa
-## koa的基本使用
-```
-// 安装 npm install koa
-
-var Koa = require('koa');
-var app = new Koa();
-app.use(async(ctx,next)=>{
-    await next();
-    ctx.type = 'text/html';
-    ctx.body = '231';
-}).listen('8089');
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230227-\345\210\235\346\255\245\350\256\244\350\257\206Koa.md" "b/06\351\231\210\345\230\211\351\221\253/20230227-\345\210\235\346\255\245\350\256\244\350\257\206Koa.md"
deleted file mode 100644
index 4db0ce04e66c170ae98bbcfb9fd4a53d4aa8f9be..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230227-\345\210\235\346\255\245\350\256\244\350\257\206Koa.md"
+++ /dev/null
@@ -1,27 +0,0 @@
- # 初步认识Koa
-
- ## 1.安装koa
- ```
- npm install koa
- ```
-## 2.koa基本写法
-```
- 引入koa
- const Koa = require('koa');
-new 一个koa对象
- let app = new Koa();
- 调用该异步函数处理请求
- app.use(async (ctx,next)=>{
-   ctx有一个请求对象和一个响应对象
-    ctx.response.body = '1和2';
-    用await next()来调用下一个async函数
-    await next();
- })
- app.use(async (ctx,next)=>{
-   console.log('222');
- }
- app.use(async (ctx,next)=>{
-   console.log('333');
- }
- app.listen('8080');
- ```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230228-\350\267\257\347\224\261.md" "b/06\351\231\210\345\230\211\351\221\253/20230228-\350\267\257\347\224\261.md"
deleted file mode 100644
index 7a77db562793cc3a8a0f5d1393a2f4edf64da422..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230228-\350\267\257\347\224\261.md"
+++ /dev/null
@@ -1,42 +0,0 @@
-# Router
-## 安装 koa 和 router 
-```
-npm install koa
-npm install koa-router
-```
-## 使用router
-```
-const Koa = require('koa');
-const router = require('koa-router')();
-let app = new Koa();
-router.get('/abc',async (ctx,next)=>{
-    ctx.body = '123';
-})
-app.use(router.routes());
-app.listen(1000);
-```
-## koa传参
-```
-1.问号传参
-在你寻址后面/写上?id=你要写的参数
-const Koa = require('koa');
-const router = require('koa-router')();
-let app = new Koa();
-router.get('/abc',async (ctx,next)=>{
-    let item = ctx.query.id;
-    ctx.body = item;
-})
-app.use(router.routes());
-app.listen(1000);
-2.冒号传参
-直接在寻址后面/写上你要写的参数
-const Koa = require('koa');
-const router = require('koa-router')();
-let app = new Koa();
-router.get('/abc/：id',async (ctx,next)=>{
-    let id = ctx.params.id;
-    ctx.body = id;
-})
-app.use(router.routes());
-app.listen(1000);
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230302-\345\244\204\347\220\206post\350\257\267\346\261\202.md" "b/06\351\231\210\345\230\211\351\221\253/20230302-\345\244\204\347\220\206post\350\257\267\346\261\202.md"
deleted file mode 100644
index 72d1108bb87505ffb48bedd5924a49e36599803e..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230302-\345\244\204\347\220\206post\350\257\267\346\261\202.md"
+++ /dev/null
@@ -1,17 +0,0 @@
-# 处理post请求
-```
-处理post请求，要用router.post('/path', async fn)
-post请求通常会发送一个表单，或者JSON，它作为request的body发送，
-但无论是Node.js提供的原始request对象，还是koa提供的request对象，
-都不提供解析request的body的功能！
-
-我们又需要引入另一个middleware来解析原始request请求，然后，把解析后的参数，绑定到ctx.request.body中。
-koa-bodyparser就是用来干这个活的。
-
-安装依赖件
-npm install koa-bodyparser
-
-const bodyParser = require('koa-bodyparser');
-最后koa对象app注册
-app.use(bodyParser)
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230303-\351\207\215\346\236\204.md" "b/06\351\231\210\345\230\211\351\221\253/20230303-\351\207\215\346\236\204.md"
deleted file mode 100644
index fbb2d10223551e84628c930289a8da6bccd5509f..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230303-\351\207\215\346\236\204.md"
+++ /dev/null
@@ -1,59 +0,0 @@
-# 重构
-```
-现在，我们已经可以处理不同的URL了，但是看看app.js，总觉得还是有点不对劲。
-
-所有的URL处理函数都放到app.js里显得很乱，而且，每加一个URL，就需要修改app.js。随着URL越来越多，app.js就会越来越长。
-
-如果能把URL处理函数集中到某个js文件，或者某几个js文件中就好了，然后让app.js自动导入所有处理URL的函数。这样，代码一分离，逻辑就显得清楚了。
-```
-```
-1.建一个controllers文件夹
-2.里面建各种类型的js
-3.然后建一个主要js为导出的
-```
-```
-代码如下：
-const router = require('koa-router');
-const fs = require('fs');
-const bodyParse = require('koa-bodyparser');
-
-function findController(path){
-    path = path || './controllers';
-    let files = fs.readdirSync(path);
-    return files.filter(item=>{
-        return item !== 'index.js';
-    })
-}
-
-function registryRouter(obj){
-    for(key in obj){
-        let tmpArr = key.split(' ');
-        let method = tmpArr[0];
-        let url = tmpArr[1];
-        let fn = obj[key];
-        if(method==='get'){
-            router.get(url,fn);
-        }
-    }
-}
-
-function processRouter(app){
-    let files = findController();
-    files.forEach(element => {
-        let tmpModule = require('./'+element.replace('.js',''));
-        registryRouter(tmpModule);
-    });
-    app.use('koa-router');
-    app.use('koa-bodyparse');
-}
-module.exports = processRouter;
-```
-```
-最后用外面js引入
-const Koa = require('koa');
-let app = new Koa();
-let Controllers = require('./controllers');
-Controllers(app);
-app.listen(6000);
-
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230306-\345\260\201\350\243\205\345\206\215\345\260\201\350\243\205.md" "b/06\351\231\210\345\230\211\351\221\253/20230306-\345\260\201\350\243\205\345\206\215\345\260\201\350\243\205.md"
deleted file mode 100644
index c171667438792044d3298c32a59b55542592d264..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230306-\345\260\201\350\243\205\345\206\215\345\260\201\350\243\205.md"
+++ /dev/null
@@ -1,85 +0,0 @@
-# 重构再现
-## controllers模块
-### index.js
-```
-const router = require('koa-router')();
-let {findController,registryRouter} = require('../utils/ros');
-
-function processRouter(app){
-    let path = findController();
-    registryRouter(path,router);
-    app.use(router.routes())
-}
-
-module.exports = processRouter;
-
-```
-### roles.js
-```
-let roles = [
-    {
-        name:'好人',
-        id:1
-    },
-    {
-        name:'坏人',
-        id:2
-    },
-    {
-        name:'孙悟空',
-        id:3
-    }
-]
-
-async function getAll(ctx,next){
-    ctx.body = roles;
-}
-
-module.exports = {
-    'get /roles':getAll
-}
-
-```
-## utils工具模块
-### ros.js
-```
-const fs = require("fs")
-
-function findController(path){
-    path = path || './controllers/';
-    let file = fs.readdirSync(path);
-    return file.filter(item=>{
-        return item !== 'index.js';
-    })
-}
-
-
-function registryRouter(obj,router){
-    obj.forEach(item=>{
-        let tmpModule = require('../controllers/'+item.replace('.js',''));
-        for(let key in tmpModule){
-            let tmpArr = key.split(' ');
-            let method = tmpArr[0];
-            let url = tmpArr[1];
-            let fn = tmpModule[key];
-            if(method==='get'){
-                router.get(url,fn);
-            }
-        }
-    })
-}
-
-module.exports = {
-    findController,registryRouter
-}
-
-```
-## 主模块app.js
-```
-const koa = require('koa');
-let app = new koa();
-const controllers = require('./controllers');
-controllers(app);
-app.listen(8080);
-
-```
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230307-\347\256\200\345\215\225\346\270\262\346\237\223nujucks.md" "b/06\351\231\210\345\230\211\351\221\253/20230307-\347\256\200\345\215\225\346\270\262\346\237\223nujucks.md"
deleted file mode 100644
index 9bc78a47f5f1b76d4982380d0802e965d116971e..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230307-\347\256\200\345\215\225\346\270\262\346\237\223nujucks.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 简单渲染
-## index.html 模块
-```
-{{name}}
-```
-## js模块
-```
-const nunjucks = require('nunjucks');
-nunjucks.configure({
-    noCache:true,
-})
-let a = nunjucks.render('index.html',{name:'cjx'});
-console.log(a);
-```
\ No newline at end of file
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230308-koa\347\273\223\345\220\210nunjucks.md" "b/06\351\231\210\345\230\211\351\221\253/20230308-koa\347\273\223\345\220\210nunjucks.md"
deleted file mode 100644
index 7dd7167d700958d5889517bf2cc37d4c83bfe92b..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230308-koa\347\273\223\345\220\210nunjucks.md"
+++ /dev/null
@@ -1,24 +0,0 @@
-# 浏览器上渲染
-## index.html
-```
-{{name}}
-```
-## js模块
-```
-const Koa = require('koa');
-let app = new Koa();
-const nunjucks = require('nunjucks');
-nunjucks.configure({
-    noCache:true,
-})
-app.use(async (ctx,next)=>{
-    ctx.body = = nunjucks.render('index.html',{name:'cjx'});
-})
- 
-app.listen(10000)
-```
-## 显示
-```
-登入localhost：10000就能看见cjx
-```
-
diff --git "a/06\351\231\210\345\230\211\351\221\253/20230310-\345\244\204\347\220\206\351\235\231\346\200\201\345\233\276\347\211\207.md" "b/06\351\231\210\345\230\211\351\221\253/20230310-\345\244\204\347\220\206\351\235\231\346\200\201\345\233\276\347\211\207.md"
deleted file mode 100644
index 9398713099b54e75885b0c220544e410c6691147..0000000000000000000000000000000000000000
--- "a/06\351\231\210\345\230\211\351\221\253/20230310-\345\244\204\347\220\206\351\235\231\346\200\201\345\233\276\347\211\207.md"
+++ /dev/null
@@ -1,35 +0,0 @@
-# 没封装版
-## html模块
-```
-    <img src="{{iii}}">
-```
-## js模块
-```
-const Koa = require('koa');
-const router = require('koa-router')();
-const nunjucks = require('nunjucks');
-const fs = require('fs').promises;
-let app = new Koa();
-const mime = require('mime');
-
-router.get('/roles',async (ctx,next)=>{
-    await next();
-    ctx.body = nunjucks.render('roles.html',{iii:'./statics/imgs/ccc.jpg'});
-})
-
-app.use(async (ctx,next)=>{
-    await next();
-    let tmpUrl = ctx.request.url;
-    if(tmpUrl.startsWith('/statics')){
-        let fullUrl = __dirname + tmpUrl;
-        ctx.type = mime.getType(fullUrl);
-        ctx.body = await fs.readFile(fullUrl);
-    } 
-})
-app.use(router.routes());
-app.listen(8080);
-```
-## 显示
-```
-输入localhost:8080/roles
-```
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/001\345\274\200\345\255\246\347\254\254\344\270\200\350\257\276.md" "b/12\351\276\232\344\270\234\350\276\211/001\345\274\200\345\255\246\347\254\254\344\270\200\350\257\276.md"
deleted file mode 100644
index 4b36de4b00cd07c93871cbdd0cd77f64cfc46351..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/001\345\274\200\345\255\246\347\254\254\344\270\200\350\257\276.md"
+++ /dev/null
@@ -1,2 +0,0 @@
-# Hello Node!
-
diff --git "a/12\351\276\232\344\270\234\350\276\211/002nodeJS\346\250\241\345\235\227\345\214\226.md" "b/12\351\276\232\344\270\234\350\276\211/002nodeJS\346\250\241\345\235\227\345\214\226.md"
deleted file mode 100644
index d9f4676057052151ce966c5f3e5a3477cd7885af..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/002nodeJS\346\250\241\345\235\227\345\214\226.md"
+++ /dev/null
@@ -1,25 +0,0 @@
-## nodeJS模块化
-
-### 模块分类：
-
-- 内置模块
-  `由Node.js官方提供的，例如 fs、path、http等`
-
-- 自定义模块
-
-  `用户创建的js文件`
-
-- 第三方模块
-
-  `非官方提供的内置模块，使用前需download`
-
-### 加载模块
-
-`使用require()方法加载需要的模块,加载时会执行被加载模块的代码`
-
-
-
-### 导出模块
-
-`使用moduls.exports将模块内的成员共享出去`
-
diff --git "a/12\351\276\232\344\270\234\350\276\211/0030220\344\275\234\344\270\232.md" "b/12\351\276\232\344\270\234\350\276\211/0030220\344\275\234\344\270\232.md"
deleted file mode 100644
index baed1817fb187323396cb4e011f0bce34b5000f1..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/0030220\344\275\234\344\270\232.md"
+++ /dev/null
@@ -1,81 +0,0 @@
-```javascript
-
-'use strict' 
-/**
- * 在浏览器输入http://localhost:8080/时，会返回404，原因是程序识别出HTTP请求的不是文件
- * 而是目录。请修改file_server.js，如果遇到请求的路径是目录，
- * 则自动在目录下依次搜索index.html、default.html，如果找到了，就返回HTML文件的内容。
- * 
-*/
-let http = require('http') // 导入模块
-let fs = require('fs')  //文件模块
-//创建服务器
-let server = http.createServer((req,res)=>{
-    //  获取url路径 localhost：8080/{url}
-    let url = req.url;
-    // /url -> url
-    url = url.substring(1,url.length);
-    //查看url文件状态
-    fs.stat(url,(err,stat)=>{
-        // 访问 localhost:8080
-        if(url=="") {
-            res.end("welcome!");
-        }else if(err) {//未找到文件
-            res.end("not find");
-            return;
-        }else if(stat.isDirectory()){//不为空，并且有找到文件判断是否为目录
-            //在目录下依次搜索index.html、default.html
-            fs.readdir(url,(err,files)=>{//read dir 
-                let flag = true;
-                //查询有没有index.html
-                files.map(x=>{
-                    let path;
-                    if(x=="index.html"){
-                        path = `./${url}/${x}`;
-                        fs.readFile(path,"utf-8",(err,data)=>{
-                            res.end(data);
-                        });
-                        flag=false; //找到index.html，未找到默认为true
-                        return;
-                    }
-                });
-                //查询default.html
-                if(flag){
-                    let flag = true;
-                    files.map(x=>{
-                        let path;
-                        if(x=="default.html"){
-                            path = `./${url}/${x}`;
-                            fs.readFile(path,"utf-8",(err,data)=>{
-                                res.end(data);
-                            });
-                            flag = false;//找到default.html
-                            return;
-                        }
-                    });
-                    if(flag){
-                        res.end("404_Not_find")
-                    }
-                }
-            });
-            return;
-        }
-        //不是目录
-        fs.readFile(url,(err,data)=>{
-            if(err){
-                res.end("404");
-                return;
-            }
-            res.end(data);
-        })
-    })
-});
-server.listen("8080");
-
-
-
-
-
-
-
-```
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/003NodeJs.md" "b/12\351\276\232\344\270\234\350\276\211/003NodeJs.md"
deleted file mode 100644
index 422f7fcc972bfaed01715553eb32d3daa329aa28..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/003NodeJs.md"
+++ /dev/null
@@ -1,4 +0,0 @@
-## promise
-
-promise异步编程，太复杂，ES7新特性：async将普通函数转为promise，使用await 设置变量表示需要等待执行结果
-
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230227-koa\345\205\245\351\227\250URL\345\244\204\347\220\206.md" "b/12\351\276\232\344\270\234\350\276\211/20230227-koa\345\205\245\351\227\250URL\345\244\204\347\220\206.md"
deleted file mode 100644
index 223c2f4ae4e4ca65efef2875b5c9e1ae1687e8b3..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230227-koa\345\205\245\351\227\250URL\345\244\204\347\220\206.md"
+++ /dev/null
@@ -1,327 +0,0 @@
-# 处理URL
-
-在hello-koa工程中，我们处理http请求一律返回相同的HTML，这样虽然非常简单，但是用浏览器一测，随便输入任何URL都会返回相同的网页。
-
-
-正常情况下，我们应该对不同的URL调用不同的处理函数，这样才能返回不同的结果。例如像这样写：
-```
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/') {
-        ctx.response.body = 'index page';
-    } else {
-        await next();
-    }
-});
-
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/test') {
-        ctx.response.body = 'TEST page';
-    } else {
-        await next();
-    }
-});
-
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/error') {
-        ctx.response.body = 'ERROR page';
-    } else {
-        await next();
-    }
-});
-```
-这么写是可以运行的，但是好像有点蠢。
-
-应该有一个能集中处理URL的middleware，它根据不同的URL调用不同的处理函数，这样，我们才能专心为每个URL编写处理函数。
-
-## koa-router
-为了处理URL，我们需要引入koa-router这个middleware，让它负责处理URL映射。
-
-我们把上一节的hello-koa工程复制一份，重命名为url-koa。
-
-先在package.json中添加依赖项：
-```
-"koa-router": "7.0.0"
-```
-然后用npm install安装。
-
-接下来，我们修改app.js，使用koa-router来处理URL：
-```
-const Koa = require('koa');
-
-// 注意require('koa-router')返回的是函数:
-const router = require('koa-router')();
-
-const app = new Koa();
-
-// log request URL:
-app.use(async (ctx, next) => {
-    console.log(`Process ${ctx.request.method} ${ctx.request.url}...`);
-    await next();
-});
-
-// add url-route:
-router.get('/hello/:name', async (ctx, next) => {
-    var name = ctx.params.name;
-    ctx.response.body = `<h1>Hello, ${name}!</h1>`;
-});
-
-router.get('/', async (ctx, next) => {
-    ctx.response.body = '<h1>Index</h1>';
-});
-
-// add router middleware:
-app.use(router.routes());
-
-app.listen(3000);
-console.log('app started at port 3000...');
-```
-注意导入koa-router的语句最后的()是函数调用：
-```
-const router = require('koa-router')();
-```
-相当于：
-```
-const fn_router = require('koa-router');
-const router = fn_router();
-```
-然后，我们使用router.get('/path', async fn)来注册一个GET请求。可以在请求路径中使用带变量的/hello/:name，变量可以通过ctx.params.name访问。
-
-再运行app.js，我们就可以测试不同的URL：
-```
-输入首页：http://localhost:3000/
-```
-```
-输入：http://localhost:3000/hello/koa
-```
-
-## 处理post请求
-用router.get('/path', async fn)处理的是get请求。如果要处理post请求，可以用router.post('/path', async fn)。
-
-用post请求处理URL时，我们会遇到一个问题：post请求通常会发送一个表单，或者JSON，它作为request的body发送，但无论是Node.js提供的原始request对象，还是koa提供的request对象，都不提供解析request的body的功能！
-
-所以，我们又需要引入另一个middleware来解析原始request请求，然后，把解析后的参数，绑定到ctx.request.body中。
-
-koa-bodyparser就是用来干这个活的。
-
-我们在package.json中添加依赖项：
-```
-"koa-bodyparser": "3.2.0"
-```
-然后使用npm install安装。
-
-下面，修改app.js，引入koa-bodyparser：
-```
-const bodyParser = require('koa-bodyparser');
-```
-在合适的位置加上：
-```
-app.use(bodyParser());
-```
-由于middleware的顺序很重要，这个koa-bodyparser必须在router之前被注册到app对象上。
-
-现在我们就可以处理post请求了。写一个简单的登录表单：
-```
-router.get('/', async (ctx, next) => {
-    ctx.response.body = `<h1>Index</h1>
-        <form action="/signin" method="post">
-            <p>Name: <input name="name" value="koa"></p>
-            <p>Password: <input name="password" type="password"></p>
-            <p><input type="submit" value="Submit"></p>
-        </form>`;
-});
-
-router.post('/signin', async (ctx, next) => {
-    var
-        name = ctx.request.body.name || '',
-        password = ctx.request.body.password || '';
-    console.log(`signin with name: ${name}, password: ${password}`);
-    if (name === 'koa' && password === '12345') {
-        ctx.response.body = `<h1>Welcome, ${name}!</h1>`;
-    } else {
-        ctx.response.body = `<h1>Login failed!</h1>
-        <p><a href="/">Try again</a></p>`;
-    }
-});
-```
-注意到我们用var name = ctx.request.body.name || ''拿到表单的name字段，如果该字段不存在，默认值设置为''。
-
-类似的，put、delete、head请求也可以由router处理。
-
-## 重构
-现在，我们已经可以处理不同的URL了，但是看看app.js，总觉得还是有点不对劲。
-
-
-所有的URL处理函数都放到app.js里显得很乱，而且，每加一个URL，就需要修改app.js。随着URL越来越多，app.js就会越来越长。
-
-如果能把URL处理函数集中到某个js文件，或者某几个js文件中就好了，然后让app.js自动导入所有处理URL的函数。这样，代码一分离，逻辑就显得清楚了。最好是这样：
-```
-url2-koa/
-|
-+- .vscode/
-|  |
-|  +- launch.json <-- VSCode 配置文件
-|
-+- controllers/
-|  |
-|  +- login.js <-- 处理login相关URL
-|  |
-|  +- users.js <-- 处理用户管理相关URL
-|
-+- app.js <-- 使用koa的js
-|
-+- package.json <-- 项目描述文件
-|
-+- node_modules/ <-- npm安装的所有依赖包
-```
-于是我们把url-koa复制一份，重命名为url2-koa，准备重构这个项目。
-
-我们先在controllers目录下编写index.js：
-```
-var fn_index = async (ctx, next) => {
-    ctx.response.body = `<h1>Index</h1>
-        <form action="/signin" method="post">
-            <p>Name: <input name="name" value="koa"></p>
-            <p>Password: <input name="password" type="password"></p>
-            <p><input type="submit" value="Submit"></p>
-        </form>`;
-};
-
-var fn_signin = async (ctx, next) => {
-    var
-        name = ctx.request.body.name || '',
-        password = ctx.request.body.password || '';
-    console.log(`signin with name: ${name}, password: ${password}`);
-    if (name === 'koa' && password === '12345') {
-        ctx.response.body = `<h1>Welcome, ${name}!</h1>`;
-    } else {
-        ctx.response.body = `<h1>Login failed!</h1>
-        <p><a href="/">Try again</a></p>`;
-    }
-};
-
-module.exports = {
-    'GET /': fn_index,
-    'POST /signin': fn_signin
-};
-```
-
-这个index.js通过module.exports把两个URL处理函数暴露出来。
-
-类似的，hello.js把一个URL处理函数暴露出来：
-```
-var fn_hello = async (ctx, next) => {
-    var name = ctx.params.name;
-    ctx.response.body = `<h1>Hello, ${name}!</h1>`;
-};
-
-module.exports = {
-    'GET /hello/:name': fn_hello
-};
-```
-现在，我们修改app.js，让它自动扫描controllers目录，找到所有js文件，导入，然后注册每个URL：
-```
-// 先导入fs模块，然后用readdirSync列出文件
-// 这里可以用sync是因为启动时只运行一次，不存在性能问题:
-var files = fs.readdirSync(__dirname + '/controllers');
-
-// 过滤出.js文件:
-var js_files = files.filter((f)=>{
-    return f.endsWith('.js');
-});
-
-// 处理每个js文件:
-for (var f of js_files) {
-    console.log(`process controller: ${f}...`);
-    // 导入js文件:
-    let mapping = require(__dirname + '/controllers/' + f);
-    for (var url in mapping) {
-        if (url.startsWith('GET ')) {
-            // 如果url类似"GET xxx":
-            var path = url.substring(4);
-            router.get(path, mapping[url]);
-            console.log(`register URL mapping: GET ${path}`);
-        } else if (url.startsWith('POST ')) {
-            // 如果url类似"POST xxx":
-            var path = url.substring(5);
-            router.post(path, mapping[url]);
-            console.log(`register URL mapping: POST ${path}`);
-        } else {
-            // 无效的URL:
-            console.log(`invalid URL: ${url}`);
-        }
-    }
-}
-```
-
-如果上面的大段代码看起来还是有点费劲，那就把它拆成更小单元的函数：
-```
-function addMapping(router, mapping) {
-    for (var url in mapping) {
-        if (url.startsWith('GET ')) {
-            var path = url.substring(4);
-            router.get(path, mapping[url]);
-            console.log(`register URL mapping: GET ${path}`);
-        } else if (url.startsWith('POST ')) {
-            var path = url.substring(5);
-            router.post(path, mapping[url]);
-            console.log(`register URL mapping: POST ${path}`);
-        } else {
-            console.log(`invalid URL: ${url}`);
-        }
-    }
-}
-
-function addControllers(router) {
-    var files = fs.readdirSync(__dirname + '/controllers');
-    var js_files = files.filter((f) => {
-        return f.endsWith('.js');
-    });
-
-    for (var f of js_files) {
-        console.log(`process controller: ${f}...`);
-        let mapping = require(__dirname + '/controllers/' + f);
-        addMapping(router, mapping);
-    }
-}
-
-addControllers(router);
-```
-
-确保每个函数功能非常简单，一眼能看明白，是代码可维护的关键。
-
-## Controller Middleware
-最后，我们把扫描controllers目录和创建router的代码从app.js中提取出来，作为一个简单的middleware使用，命名为controller.js：
-```
-const fs = require('fs');
-
-function addMapping(router, mapping) {
-    ...
-}
-
-function addControllers(router, dir) {
-    ...
-}
-
-module.exports = function (dir) {
-    let
-        controllers_dir = dir || 'controllers', // 如果不传参数，扫描目录默认为'controllers'
-        router = require('koa-router')();
-    addControllers(router, controllers_dir);
-    return router.routes();
-};
-```
-这样一来，我们在app.js的代码又简化了：
-```
-...
-
-// 导入controller middleware:
-const controller = require('./controller');
-
-...
-
-// 使用middleware:
-app.use(controller());
-
-...
-```
-经过重新整理后的工程url2-koa目前具备非常好的模块化，所有处理URL的函数按功能组存放在controllers目录，今后我们也只需要不断往这个目录下加东西就可以了，app.js保持不变。
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230228-\345\244\204\347\220\206url.md" "b/12\351\276\232\344\270\234\350\276\211/20230228-\345\244\204\347\220\206url.md"
deleted file mode 100644
index 223c2f4ae4e4ca65efef2875b5c9e1ae1687e8b3..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230228-\345\244\204\347\220\206url.md"
+++ /dev/null
@@ -1,327 +0,0 @@
-# 处理URL
-
-在hello-koa工程中，我们处理http请求一律返回相同的HTML，这样虽然非常简单，但是用浏览器一测，随便输入任何URL都会返回相同的网页。
-
-
-正常情况下，我们应该对不同的URL调用不同的处理函数，这样才能返回不同的结果。例如像这样写：
-```
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/') {
-        ctx.response.body = 'index page';
-    } else {
-        await next();
-    }
-});
-
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/test') {
-        ctx.response.body = 'TEST page';
-    } else {
-        await next();
-    }
-});
-
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/error') {
-        ctx.response.body = 'ERROR page';
-    } else {
-        await next();
-    }
-});
-```
-这么写是可以运行的，但是好像有点蠢。
-
-应该有一个能集中处理URL的middleware，它根据不同的URL调用不同的处理函数，这样，我们才能专心为每个URL编写处理函数。
-
-## koa-router
-为了处理URL，我们需要引入koa-router这个middleware，让它负责处理URL映射。
-
-我们把上一节的hello-koa工程复制一份，重命名为url-koa。
-
-先在package.json中添加依赖项：
-```
-"koa-router": "7.0.0"
-```
-然后用npm install安装。
-
-接下来，我们修改app.js，使用koa-router来处理URL：
-```
-const Koa = require('koa');
-
-// 注意require('koa-router')返回的是函数:
-const router = require('koa-router')();
-
-const app = new Koa();
-
-// log request URL:
-app.use(async (ctx, next) => {
-    console.log(`Process ${ctx.request.method} ${ctx.request.url}...`);
-    await next();
-});
-
-// add url-route:
-router.get('/hello/:name', async (ctx, next) => {
-    var name = ctx.params.name;
-    ctx.response.body = `<h1>Hello, ${name}!</h1>`;
-});
-
-router.get('/', async (ctx, next) => {
-    ctx.response.body = '<h1>Index</h1>';
-});
-
-// add router middleware:
-app.use(router.routes());
-
-app.listen(3000);
-console.log('app started at port 3000...');
-```
-注意导入koa-router的语句最后的()是函数调用：
-```
-const router = require('koa-router')();
-```
-相当于：
-```
-const fn_router = require('koa-router');
-const router = fn_router();
-```
-然后，我们使用router.get('/path', async fn)来注册一个GET请求。可以在请求路径中使用带变量的/hello/:name，变量可以通过ctx.params.name访问。
-
-再运行app.js，我们就可以测试不同的URL：
-```
-输入首页：http://localhost:3000/
-```
-```
-输入：http://localhost:3000/hello/koa
-```
-
-## 处理post请求
-用router.get('/path', async fn)处理的是get请求。如果要处理post请求，可以用router.post('/path', async fn)。
-
-用post请求处理URL时，我们会遇到一个问题：post请求通常会发送一个表单，或者JSON，它作为request的body发送，但无论是Node.js提供的原始request对象，还是koa提供的request对象，都不提供解析request的body的功能！
-
-所以，我们又需要引入另一个middleware来解析原始request请求，然后，把解析后的参数，绑定到ctx.request.body中。
-
-koa-bodyparser就是用来干这个活的。
-
-我们在package.json中添加依赖项：
-```
-"koa-bodyparser": "3.2.0"
-```
-然后使用npm install安装。
-
-下面，修改app.js，引入koa-bodyparser：
-```
-const bodyParser = require('koa-bodyparser');
-```
-在合适的位置加上：
-```
-app.use(bodyParser());
-```
-由于middleware的顺序很重要，这个koa-bodyparser必须在router之前被注册到app对象上。
-
-现在我们就可以处理post请求了。写一个简单的登录表单：
-```
-router.get('/', async (ctx, next) => {
-    ctx.response.body = `<h1>Index</h1>
-        <form action="/signin" method="post">
-            <p>Name: <input name="name" value="koa"></p>
-            <p>Password: <input name="password" type="password"></p>
-            <p><input type="submit" value="Submit"></p>
-        </form>`;
-});
-
-router.post('/signin', async (ctx, next) => {
-    var
-        name = ctx.request.body.name || '',
-        password = ctx.request.body.password || '';
-    console.log(`signin with name: ${name}, password: ${password}`);
-    if (name === 'koa' && password === '12345') {
-        ctx.response.body = `<h1>Welcome, ${name}!</h1>`;
-    } else {
-        ctx.response.body = `<h1>Login failed!</h1>
-        <p><a href="/">Try again</a></p>`;
-    }
-});
-```
-注意到我们用var name = ctx.request.body.name || ''拿到表单的name字段，如果该字段不存在，默认值设置为''。
-
-类似的，put、delete、head请求也可以由router处理。
-
-## 重构
-现在，我们已经可以处理不同的URL了，但是看看app.js，总觉得还是有点不对劲。
-
-
-所有的URL处理函数都放到app.js里显得很乱，而且，每加一个URL，就需要修改app.js。随着URL越来越多，app.js就会越来越长。
-
-如果能把URL处理函数集中到某个js文件，或者某几个js文件中就好了，然后让app.js自动导入所有处理URL的函数。这样，代码一分离，逻辑就显得清楚了。最好是这样：
-```
-url2-koa/
-|
-+- .vscode/
-|  |
-|  +- launch.json <-- VSCode 配置文件
-|
-+- controllers/
-|  |
-|  +- login.js <-- 处理login相关URL
-|  |
-|  +- users.js <-- 处理用户管理相关URL
-|
-+- app.js <-- 使用koa的js
-|
-+- package.json <-- 项目描述文件
-|
-+- node_modules/ <-- npm安装的所有依赖包
-```
-于是我们把url-koa复制一份，重命名为url2-koa，准备重构这个项目。
-
-我们先在controllers目录下编写index.js：
-```
-var fn_index = async (ctx, next) => {
-    ctx.response.body = `<h1>Index</h1>
-        <form action="/signin" method="post">
-            <p>Name: <input name="name" value="koa"></p>
-            <p>Password: <input name="password" type="password"></p>
-            <p><input type="submit" value="Submit"></p>
-        </form>`;
-};
-
-var fn_signin = async (ctx, next) => {
-    var
-        name = ctx.request.body.name || '',
-        password = ctx.request.body.password || '';
-    console.log(`signin with name: ${name}, password: ${password}`);
-    if (name === 'koa' && password === '12345') {
-        ctx.response.body = `<h1>Welcome, ${name}!</h1>`;
-    } else {
-        ctx.response.body = `<h1>Login failed!</h1>
-        <p><a href="/">Try again</a></p>`;
-    }
-};
-
-module.exports = {
-    'GET /': fn_index,
-    'POST /signin': fn_signin
-};
-```
-
-这个index.js通过module.exports把两个URL处理函数暴露出来。
-
-类似的，hello.js把一个URL处理函数暴露出来：
-```
-var fn_hello = async (ctx, next) => {
-    var name = ctx.params.name;
-    ctx.response.body = `<h1>Hello, ${name}!</h1>`;
-};
-
-module.exports = {
-    'GET /hello/:name': fn_hello
-};
-```
-现在，我们修改app.js，让它自动扫描controllers目录，找到所有js文件，导入，然后注册每个URL：
-```
-// 先导入fs模块，然后用readdirSync列出文件
-// 这里可以用sync是因为启动时只运行一次，不存在性能问题:
-var files = fs.readdirSync(__dirname + '/controllers');
-
-// 过滤出.js文件:
-var js_files = files.filter((f)=>{
-    return f.endsWith('.js');
-});
-
-// 处理每个js文件:
-for (var f of js_files) {
-    console.log(`process controller: ${f}...`);
-    // 导入js文件:
-    let mapping = require(__dirname + '/controllers/' + f);
-    for (var url in mapping) {
-        if (url.startsWith('GET ')) {
-            // 如果url类似"GET xxx":
-            var path = url.substring(4);
-            router.get(path, mapping[url]);
-            console.log(`register URL mapping: GET ${path}`);
-        } else if (url.startsWith('POST ')) {
-            // 如果url类似"POST xxx":
-            var path = url.substring(5);
-            router.post(path, mapping[url]);
-            console.log(`register URL mapping: POST ${path}`);
-        } else {
-            // 无效的URL:
-            console.log(`invalid URL: ${url}`);
-        }
-    }
-}
-```
-
-如果上面的大段代码看起来还是有点费劲，那就把它拆成更小单元的函数：
-```
-function addMapping(router, mapping) {
-    for (var url in mapping) {
-        if (url.startsWith('GET ')) {
-            var path = url.substring(4);
-            router.get(path, mapping[url]);
-            console.log(`register URL mapping: GET ${path}`);
-        } else if (url.startsWith('POST ')) {
-            var path = url.substring(5);
-            router.post(path, mapping[url]);
-            console.log(`register URL mapping: POST ${path}`);
-        } else {
-            console.log(`invalid URL: ${url}`);
-        }
-    }
-}
-
-function addControllers(router) {
-    var files = fs.readdirSync(__dirname + '/controllers');
-    var js_files = files.filter((f) => {
-        return f.endsWith('.js');
-    });
-
-    for (var f of js_files) {
-        console.log(`process controller: ${f}...`);
-        let mapping = require(__dirname + '/controllers/' + f);
-        addMapping(router, mapping);
-    }
-}
-
-addControllers(router);
-```
-
-确保每个函数功能非常简单，一眼能看明白，是代码可维护的关键。
-
-## Controller Middleware
-最后，我们把扫描controllers目录和创建router的代码从app.js中提取出来，作为一个简单的middleware使用，命名为controller.js：
-```
-const fs = require('fs');
-
-function addMapping(router, mapping) {
-    ...
-}
-
-function addControllers(router, dir) {
-    ...
-}
-
-module.exports = function (dir) {
-    let
-        controllers_dir = dir || 'controllers', // 如果不传参数，扫描目录默认为'controllers'
-        router = require('koa-router')();
-    addControllers(router, controllers_dir);
-    return router.routes();
-};
-```
-这样一来，我们在app.js的代码又简化了：
-```
-...
-
-// 导入controller middleware:
-const controller = require('./controller');
-
-...
-
-// 使用middleware:
-app.use(controller());
-
-...
-```
-经过重新整理后的工程url2-koa目前具备非常好的模块化，所有处理URL的函数按功能组存放在controllers目录，今后我们也只需要不断往这个目录下加东西就可以了，app.js保持不变。
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230302-URL\345\244\204\347\220\206\350\257\267\346\261\202\345\222\214\351\241\271\347\233\256\351\207\215\346\236\204.md" "b/12\351\276\232\344\270\234\350\276\211/20230302-URL\345\244\204\347\220\206\350\257\267\346\261\202\345\222\214\351\241\271\347\233\256\351\207\215\346\236\204.md"
deleted file mode 100644
index 49dec6fa4edfd3f400db6a57a304c888fd1d56ec..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230302-URL\345\244\204\347\220\206\350\257\267\346\261\202\345\222\214\351\241\271\347\233\256\351\207\215\346\236\204.md"
+++ /dev/null
@@ -1,140 +0,0 @@
-**Node.js**——**URL处理请求和项目重构**
-===
-在一个**Node.js的web应用项目**里，**URL的处理**可以说是非常繁琐的，所以要去 *进行包装重构，这样能让代码更加简洁，逻辑更加清晰明了* ，创建一个文件夹去将这些不同页面访问URL处理进行封装成模块，只用去引用
-
-一 .url的处理请求：
----
-
-### 1 .http的请求方法：
-+ URL处理，http的请求方法：
-
-| **方法**：  | 描述：                                                       |
-| ----------- | ------------------------------------------------------------ |
-| **GET**     | 请求指定的页面信息，并返回实体主体                           |
-| **HEAD**    | 类似于 GET 请求，只不过返回的响应中没有具体的内容，用于获取报头 |
-| **POST**    | 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST 请求可能会导致新的资源的建立和/或已有资源的修改 |
-| **PUT**     | 从客户端向服务器传送的数据取代指定的文档的内容               |
-| **DELETE**  | 请求服务器删除指定的页面                                     |
-| **CONNECT** | HTTP/1.1 协议中预留给能够将连接改为管道方式的代理服务器      |
-| **OPTIONS** | 允许客户端查看服务器的性能                                   |
-| **TRACE**   | 回显服务器收到的请求，主要用于测试或诊断                     |
-| **PATCH**   | 是对 PUT 方法的补充，用来对已知资源进行局部更新              |
-
- > 常用的请求方法有**get、post、put、delete**这些请求,会常写这些请求的处理方法和模块
-
-### 2 .对URL处理引用的模块:
-+ 用Koa框架在对URL路由处理时，会引用到很多的模块
-    > 会引用到的模块代码：
-    ```js
-    const
-        Koa = require('Koa'),
-        router = require('kao-router')(),
-        bodyParser = require('koa-bodyparser');
-        fs = require('fs');
-    ```
-    > 这些模块的
-
-二 .项目模块扫描重构：
----
-+ 我们把项目重构，很多模块都存放在一个文件夹下，包装好，所以在调用的时候，将他们都扫描一遍，不用再去一个一个的调用，也是为了减少代码的写入量
-
-    > 现在，我们修改**主程序js文件**让它自动**扫描controllers目录**，*找到所有js文件，导入，然后注册每个URL* ：
-    ```js
-    // 先导入fs模块，然后用readdirSync列出文件
-    // 这里可以用sync是因为启动时只运行一次，不存在性能问题:
-        var files = fs.readdirSync(__dirname + '/controllers');
-        // 过滤出.js文件:
-        var js_files = files.filter((f)=>{
-            return f.endsWith('.js');
-        });
-    // 处理每个js文件:
-        for (var f of js_files) {
-            console.log(`process controller: ${f}...`);
-        // 导入js文件:
-            let mapping = require(__dirname + '/controllers/' + f);
-            for (var url in mapping) {
-                if (url.startsWith('GET ')) {
-                // 如果url类似"GET xxx":
-                    var path = url.substring(4);
-                    router.get(path, mapping[url]);
-                    console.log(`register URL mapping: GET ${path}`);
-                } else if (url.startsWith('POST ')) {
-                // 如果url类似"POST xxx":
-                    var path = url.substring(5);
-                    router.post(path, mapping[url]);
-                    console.log(`register URL mapping: POST ${path}`);
-                } else {
-                // 无效的URL:
-                    console.log(`invalid URL: ${url}`);
-                }
-            }
-        }
-    ```
-    > 如果上面的大段代码看起来还是有点费劲，那就把它拆成更小单元的函数：
-    ```js
-    function addMapping(router, mapping) {
-        for (var url in mapping) {
-            if (url.startsWith('GET ')) {
-                var path = url.substring(4);
-                router.get(path, mapping[url]);
-                console.log(`register URL mapping: GET ${path}`);
-            } else if (url.startsWith('POST ')) {
-                var path = url.substring(5);
-                router.post(path, mapping[url]);
-                console.log(`register URL mapping: POST ${path}`);
-            } else {
-                console.log(`invalid URL: ${url}`);
-            }
-        }
-    }
-    
-    function addControllers(router) {
-        var files = fs.readdirSync(__dirname + '/controllers');
-        var js_files = files.filter((f) => {
-            return f.endsWith('.js');
-        });
-    
-        for (var f of js_files) {
-            console.log(`process controller: ${f}...`);
-            let mapping = require(__dirname + '/controllers/' + f);
-            addMapping(router, mapping);
-        }
-    }
-    
-    addControllers(router);
-    ```
-    + 确保每个函数功能非常简单，一眼能看明白，是代码可维护的关键
-
-三 .设置 Middleware 
----
-将一些在**controllers目录和route要引入的模块封装好在一个模块中**，这样去减少主程序js文件中的繁琐代码
-+ 最后把扫描**controllers目录**和**创建router的代码**从 *入口js文件中提取出来，作为一个简单的middleware使用* ，命名为**index.js**存放在**controllers目录**：
-    ```js
-    const fs = require('fs');
-    
-    function addMapping(router, mapping) {
-        ...
-    }
-    function addControllers(router, dir) {            
-        ...
-    }
-    module.exports = function (dir) {
-        let
-            // 如果不传参数，扫描目录默认为'controllers'
-            controllers_dir = dir || 'controllers',            
-            router = require('koa-router')();
-            addControllers(router, controllers_dir);
-            return router.routes();
-        };
-    ```
-    > 这样一来，我们在**主程序的js文件代码**就又简化了：
-    ```js
-    ...
-    // 导入controller middleware:
-    const controller = require('./controller');
-    ...
-    // 使用middleware:
-    app.use(controller());
-    ...
-    ```
-+ 经过重新整理后的项目具备非常好的模块化，所有**处理URL**的***函数按功能组存放在controllers目录，今后我们也只需要不断往这个目录下加东西就可以了，主程序的js文件保持不变***
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230303-\351\207\215\346\236\204.md" "b/12\351\276\232\344\270\234\350\276\211/20230303-\351\207\215\346\236\204.md"
deleted file mode 100644
index a42640ecb01beb92866afc4d45abaa810a482aef..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230303-\351\207\215\346\236\204.md"
+++ /dev/null
@@ -1,36 +0,0 @@
-## Controller Middleware
-最后，我们把扫描controllers目录和创建router的代码从app.js中提取出来，作为一个简单的middleware使用，命名为controller.js：
-```
-const fs = require('fs');
-
-function addMapping(router, mapping) {
-    ...
-}
-
-function addControllers(router, dir) {
-    ...
-}
-
-module.exports = function (dir) {
-    let
-        controllers_dir = dir || 'controllers', // 如果不传参数，扫描目录默认为'controllers'
-        router = require('koa-router')();
-    addControllers(router, controllers_dir);
-    return router.routes();
-};
-```
-这样一来，我们在app.js的代码又简化了：
-```
-...
-
-// 导入controller middleware:
-const controller = require('./controller');
-
-...
-
-// 使用middleware:
-app.use(controller());
-
-...
-```
-经过重新整理后的工程url2-koa目前具备非常好的模块化，所有处理URL的函数按功能组存放在controllers目录，今后我们也只需要不断往这个目录下加东西就可以了，app.js保持不变。
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230306-\351\207\215\346\236\204\344\274\230\345\214\226.md" "b/12\351\276\232\344\270\234\350\276\211/20230306-\351\207\215\346\236\204\344\274\230\345\214\226.md"
deleted file mode 100644
index ea6a65d48170b09263d82bbf258464bf10bfda0e..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230306-\351\207\215\346\236\204\344\274\230\345\214\226.md"
+++ /dev/null
@@ -1,129 +0,0 @@
-# 重构优化
-
-简单来说就是新建一个工具文件，将可以复用的工具类代码放进去，看起来非常舒适
-
-## 代码：
-
-### app.js
-```js
-'use strict'
-const koa=require('koa');
-const controllers=require('./controllers')
-
-let app=new koa();
-
-controllers(app);
-
-let port=5000
-app.listen(port)
-console.log(`kk:http://localhost:${port}`);
-```
-
-### tools.js
-
-```js
-'use strict'
-const fs=require('fs');
-
-//1.找到所有路由
-function findAllRouter(path) {
-    path=path||'./controllers';
-
-    let files=fs.readdirSync(path)
-    return files.filter(
-        item=>{
-            return item!=='index.js'
-        }
-    )
-    
-}
-
-//遍历并注册路由
-
-function resign(obj,router) {
-    for (const key in obj) {
-        let sp=key.split(' ');
-        let rou=sp[0];
-        let url=sp[1];
-        let ff=obj[key];
-        if(rou=='get'){
-            router.get(url,ff)
-        }else if(rou=='post'){
-            router.post(url,ff)
-        }else if(rou=='put'){
-            router.put(url,ff)
-        }
-        else if(rou=='delete'){
-            router.delete(url,ff)
-        }
-    }
-        
-    ;
-}
-
-
-module.exports={
-    findAllRouter,resign
-}
-
-```
-
-
-### index.js
-```js
-'use strict'
-
-const router=require('koa-router')();
-const bodyparser=require('koa-bodyparser');
-const {findAllRouter,resign}=require('../utils/tools')
-
-function process(app) {
-    let files=findAllRouter();
-    files.forEach(
-        item=>{
-            let cons=require('../controllers/'+item.replace('.js',''))
-            resign(cons,router)
-        }
-    )
-    app.use(router.routes());
-    app.use(bodyparser())
-}
-
-module.exports=process
-
-```
-
-### 还是各种数据.js
-
-重复太多只放一个
-
-```js
-'use strict'
-
-function getAll(ctx,next) {
-    ctx.body='1111';
-}
-function getById(ctx,next) {
-    ctx.body='2222';
-}
-function insertItem(ctx,next) {
-    
-}
-function updateById(ctx,next) {
-    
-}
-function deleteById(ctx,next) {
-    
-}
-
-
-module.exports={
-    'get /student':getAll,
-    'get /student/:id':getById,
-    'post /student':insertItem,
-    'put /student/:id':updateById,
-    'delete /student/:id':deleteById
-
-}
-
-```
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230307-\346\250\241\345\235\227\345\274\225\346\223\216.md" "b/12\351\276\232\344\270\234\350\276\211/20230307-\346\250\241\345\235\227\345\274\225\346\223\216.md"
deleted file mode 100644
index c666e2b72f806d51d316551d12b238c9e7099f30..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230307-\346\250\241\345\235\227\345\274\225\346\223\216.md"
+++ /dev/null
@@ -1,214 +0,0 @@
-# 使用Nunjucks
-
-## Nunjucks
-Nunjucks是什么东东？其实它是一个模板引擎。
-
-那什么是模板引擎？
-
-模板引擎就是基于模板配合数据构造出字符串输出的一个组件。比如下面的函数就是一个模板引擎：
-```
-function examResult (data) {
-    return `${data.name}同学一年级期末考试语文${data.chinese}分，数学${data.math}分，位于年级第${data.ranking}名。`
-}
-```
-如果我们输入数据如下：
-```
-examResult({
-    name: '小明',
-    chinese: 78,
-    math: 87,
-    ranking: 999
-});
-```
-该模板引擎把模板字符串里面对应的变量替换以后，就可以得到以下输出：
-
-小明同学一年级期末考试语文78分，数学87分，位于年级第999名。
-
-模板引擎最常见的输出就是输出网页，也就是HTML文本。当然，也可以输出任意格式的文本，比如Text，XML，Markdown等等。
-
-有同学要问了：既然JavaScript的模板字符串可以实现模板功能，那为什么我们还需要另外的模板引擎？
-
-因为JavaScript的模板字符串必须写在JavaScript代码中，要想写出新浪首页这样复杂的页面，是非常困难的。
-
-输出HTML有几个特别重要的问题需要考虑：
-
-## 转义
-对特殊字符要转义，避免受到XSS攻击。比如，如果变量name的值不是小明，而是小明<script>...</script>，模板引擎输出的HTML到了浏览器，就会自动执行恶意JavaScript代码。
-
-## 格式化
-对不同类型的变量要格式化，比如，货币需要变成12,345.00这样的格式，日期需要变成2016-01-01这样的格式。
-
-## 简单逻辑
-模板还需要能执行一些简单逻辑，比如，要按条件输出内容，需要if实现如下输出：
-```
-{{ name }}同学，
-{% if score >= 90 %}
-    成绩优秀，应该奖励
-{% elif score >=60 %}
-    成绩良好，继续努力
-{% else %}
-    不及格，建议回家打屁股
-{% endif %}
-```
-所以，我们需要一个功能强大的模板引擎，来完成页面输出的功能。
-
-## Nunjucks
-我们选择Nunjucks作为模板引擎。Nunjucks是Mozilla开发的一个纯JavaScript编写的模板引擎，既可以用在Node环境下，又可以运行在浏览器端。但是，主要还是运行在Node环境下，因为浏览器端有更好的模板解决方案，例如MVVM框架。
-
-如果你使用过Python的模板引擎jinja2，那么使用Nunjucks就非常简单，两者的语法几乎是一模一样的，因为Nunjucks就是用JavaScript重新实现了jinjia2。
-
-从上面的例子我们可以看到，虽然模板引擎内部可能非常复杂，但是使用一个模板引擎是非常简单的，因为本质上我们只需要构造这样一个函数：
-```
-function render(view, model) {
-    // TODO:...
-}
-```
-其中，view是模板的名称（又称为视图），因为可能存在多个模板，需要选择其中一个。model就是数据，在JavaScript中，它就是一个简单的Object。render函数返回一个字符串，就是模板的输出。
-
-下面我们来使用Nunjucks这个模板引擎来编写几个HTML模板，并且用实际数据来渲染模板并获得最终的HTML输出。
-
-我们创建一个use-nunjucks的VS Code工程结构如下：
-```
-use-nunjucks/
-|
-+- .vscode/
-|  |
-|  +- launch.json <-- VSCode 配置文件
-|
-+- views/
-|  |
-|  +- hello.html <-- HTML模板文件
-|
-+- app.js <-- 入口js
-|
-+- package.json <-- 项目描述文件
-|
-+- node_modules/ <-- npm安装的所有依赖包
-```
-其中，模板文件存放在views目录中。
-
-我们先在package.json中添加nunjucks的依赖：
-```
-"nunjucks": "2.4.2"
-```
-注意，模板引擎是可以独立使用的，并不需要依赖koa。用npm install安装所有依赖包。
-
-紧接着，我们要编写使用Nunjucks的函数render。怎么写？方法是查看Nunjucks的官方文档，仔细阅读后，在app.js中编写代码如下：
-```
-const nunjucks = require('nunjucks');
-
-function createEnv(path, opts) {
-    var
-        autoescape = opts.autoescape === undefined ? true : opts.autoescape,
-        noCache = opts.noCache || false,
-        watch = opts.watch || false,
-        throwOnUndefined = opts.throwOnUndefined || false,
-        env = new nunjucks.Environment(
-            new nunjucks.FileSystemLoader('views', {
-                noCache: noCache,
-                watch: watch,
-            }), {
-                autoescape: autoescape,
-                throwOnUndefined: throwOnUndefined
-            });
-    if (opts.filters) {
-        for (var f in opts.filters) {
-            env.addFilter(f, opts.filters[f]);
-        }
-    }
-    return env;
-}
-
-var env = createEnv('views', {
-    watch: true,
-    filters: {
-        hex: function (n) {
-            return '0x' + n.toString(16);
-        }
-    }
-});
-```
-变量env就表示Nunjucks模板引擎对象，它有一个`render(view, model)`方法，正好传入view和model两个参数，并返回字符串。
-
-创建env需要的参数可以查看文档获知。我们用autoescape = opts.autoescape && true这样的代码给每个参数加上默认值，最后使用`new nunjucks.FileSystemLoader('views')`创建一个文件系统加载器，从views目录读取模板。
-
-我们编写一个`hello.html`模板文件，放到views目录下，内容如下：
-```
-<h1>Hello {{ name }}</h1>
-```
-然后，我们就可以用下面的代码来渲染这个模板：
-```
-var s = env.render('hello.html', { name: '小明' });
-console.log(s);
-```
-获得输出如下：
-```
-<h1>Hello 小明</h1>
-```
-咋一看，这和使用JavaScript模板字符串没啥区别嘛。不过，试试：
-```
-var s = env.render('hello.html', { name: '<script>alert("小明")</script>' });
-console.log(s);
-```
-获得输出如下：
-```
-<h1>Hello &lt;script&gt;alert("小明")&lt;/script&gt;</h1>
-```
-这样就避免了输出恶意脚本。
-
-此外，可以使用Nunjucks提供的功能强大的tag，编写条件判断、循环等功能，例如：
-```
-<!-- 循环输出名字 -->
-<body>
-    <h3>Fruits List</h3>
-    {% for f in fruits %}
-    <p>{{ f }}</p>
-    {% endfor %}
-</body>
-```
-Nunjucks模板引擎最强大的功能在于模板的继承。仔细观察各种网站可以发现，网站的结构实际上是类似的，头部、尾部都是固定格式，只有中间页面部分内容不同。如果每个模板都重复头尾，一旦要修改头部或尾部，那就需要改动所有模板。
-
-更好的方式是使用继承。先定义一个基本的网页框架base.html：
-```
-<html><body>
-{% block header %} <h3>Unnamed</h3> {% endblock %}
-{% block body %} <div>No body</div> {% endblock %}
-{% block footer %} <div>copyright</div> {% endblock %}
-</body>
-</html>
-```
-base.html定义了三个可编辑的块，分别命名为header、body和footer。子模板可以有选择地对块进行重新定义：
-```
-{% extends 'base.html' %}
-
-{% block header %}<h1>{{ header }}</h1>{% endblock %}
-
-{% block body %}<p>{{ body }}</p>{% endblock %}
-```
-然后，我们对子模板进行渲染：
-```
-console.log(env.render('extend.html', {
-    header: 'Hello',
-    body: 'bla bla bla...'
-}));
-```
-输出HTML如下：
-```
-<html><body>
-<h1>Hello</h1>
-<p>bla bla bla...</p>
-<div>copyright</div> <-- footer没有重定义，所以仍使用父模板的内容
-</body>
-```
-## 性能
-最后我们要考虑一下Nunjucks的性能。
-
-对于模板渲染本身来说，速度是非常非常快的，因为就是拼字符串嘛，纯CPU操作。
-
-性能问题主要出现在从文件读取模板内容这一步。这是一个IO操作，在Node.js环境中，我们知道，单线程的JavaScript最不能忍受的就是同步IO，但Nunjucks默认就使用同步IO读取模板文件。
-
-好消息是Nunjucks会缓存已读取的文件内容，也就是说，模板文件最多读取一次，就会放在内存中，后面的请求是不会再次读取文件的，只要我们指定了noCache: false这个参数。
-
-在开发环境下，可以关闭cache，这样每次重新加载模板，便于实时修改模板。在生产环境下，一定要打开cache，这样就不会有性能问题。
-
-Nunjucks也提供了异步读取的方式，但是这样写起来很麻烦，有简单的写法我们就不会考虑复杂的写法。保持代码简单是可维护性的关键。
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230309-MVC.md" "b/12\351\276\232\344\270\234\350\276\211/20230309-MVC.md"
deleted file mode 100644
index 2dccca086aee710b5ff00d9ab42805746fa9b6d4..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230309-MVC.md"
+++ /dev/null
@@ -1,327 +0,0 @@
-# 使用MVC
-
-## MVC
-我们已经可以用koa处理不同的URL，还可以用Nunjucks渲染模板。现在，是时候把这两者结合起来了！
-
-当用户通过浏览器请求一个URL时，koa将调用某个异步函数处理该URL。在这个异步函数内部，我们用一行代码：
-```
-ctx.render('home.html', { name: 'Michael' });
-```
-通过Nunjucks把数据用指定的模板渲染成HTML，然后输出给浏览器，用户就可以看到渲染后的页面了：
-
-## mvc
-
-这就是传说中的MVC：Model-View-Controller，中文名“模型-视图-控制器”。
-
-异步函数是C：Controller，Controller负责业务逻辑，比如检查用户名是否存在，取出用户信息等等；
-
-包含变量{{ name }}的模板就是V：View，View负责显示逻辑，通过简单地替换一些变量，View最终输出的就是用户看到的HTML。
-
-MVC中的Model在哪？Model是用来传给View的，这样View在替换变量的时候，就可以从Model中取出相应的数据。
-
-上面的例子中，Model就是一个JavaScript对象：
-```
-{ name: 'Michael' }
-```
-下面，我们根据原来的url2-koa创建工程view-koa，把koa2、Nunjucks整合起来，然后，把原来直接输出字符串的方式，改为ctx.render(view, model)的方式。
-
-工程view-koa结构如下：
-```
-view-koa/
-|
-+- .vscode/
-|  |
-|  +- launch.json <-- VSCode 配置文件
-|
-+- controllers/ <-- Controller
-|
-+- views/ <-- html模板文件
-|
-+- static/ <-- 静态资源文件
-|
-+- controller.js <-- 扫描注册Controller
-|
-+- app.js <-- 使用koa的js
-|
-+- package.json <-- 项目描述文件
-|
-+- node_modules/ <-- npm安装的所有依赖包
-```
-在package.json中，我们将要用到的依赖包有：
-```
-"koa": "2.0.0",
-"koa-bodyparser": "3.2.0",
-"koa-router": "7.0.0",
-"nunjucks": "2.4.2",
-"mime": "1.3.4",
-"mz": "2.4.0"
-```
-先用npm install安装依赖包。
-
-然后，我们准备编写以下两个Controller：
-
-1. 处理首页 GET /
-
-我们定义一个async函数处理首页URL/：
-```
-async (ctx, next) => {
-    ctx.render('index.html', {
-        title: 'Welcome'
-    });
-}
-```
-注意到koa并没有在ctx对象上提供render方法，这里我们假设应该这么使用，这样，我们在编写Controller的时候，最后一步调用ctx.render(view, model)就完成了页面输出。
-
-2. 处理登录请求 POST /signin
-我们再定义一个async函数处理登录请求/signin：
-```
-async (ctx, next) => {
-    var
-        email = ctx.request.body.email || '',
-        password = ctx.request.body.password || '';
-    if (email === 'admin@example.com' && password === '123456') {
-        // 登录成功:
-        ctx.render('signin-ok.html', {
-            title: 'Sign In OK',
-            name: 'Mr Node'
-        });
-    } else {
-        // 登录失败:
-        ctx.render('signin-failed.html', {
-            title: 'Sign In Failed'
-        });
-    }
-}
-```
-由于登录请求是一个POST，我们就用ctx.request.body.<name>拿到POST请求的数据，并给一个默认值。
-
-登录成功时我们用signin-ok.html渲染，登录失败时我们用signin-failed.html渲染，所以，我们一共需要以下3个View：
-```
-index.html
-signin-ok.html
-signin-failed.html
-```
-
-## 编写View
-在编写View的时候，我们实际上是在编写HTML页。为了让页面看起来美观大方，使用一个现成的CSS框架是非常有必要的。我们用Bootstrap这个CSS框架。从首页下载zip包后解压，我们把所有静态资源文件放到/static目录下：
-```
-view-koa/
-|
-+- static/
-   |
-   +- css/ <- 存放bootstrap.css等
-   |
-   +- fonts/ <- 存放字体文件
-   |
-   +- js/ <- 存放bootstrap.js等   
-```
-这样我们在编写HTML的时候，可以直接用Bootstrap的CSS，像这样：
-```
-<link rel="stylesheet" href="/static/css/bootstrap.css">
-```
-现在，在使用MVC之前，第一个问题来了，如何处理静态文件？
-
-我们把所有静态资源文件全部放入/static目录，目的就是能统一处理静态文件。在koa中，我们需要编写一个middleware，处理以/static/开头的URL。
-
-## 编写middleware
-我们来编写一个处理静态文件的middleware。编写middleware实际上一点也不复杂。我们先创建一个static-files.js的文件，编写一个能处理静态文件的middleware：
-```
-const path = require('path');
-const mime = require('mime');
-const fs = require('mz/fs');
-
-// url: 类似 '/static/'
-// dir: 类似 __dirname + '/static'
-function staticFiles(url, dir) {
-    return async (ctx, next) => {
-        let rpath = ctx.request.path;
-        // 判断是否以指定的url开头:
-        if (rpath.startsWith(url)) {
-            // 获取文件完整路径:
-            let fp = path.join(dir, rpath.substring(url.length));
-            // 判断文件是否存在:
-            if (await fs.exists(fp)) {
-                // 查找文件的mime:
-                ctx.response.type = mime.lookup(rpath);
-                // 读取文件内容并赋值给response.body:
-                ctx.response.body = await fs.readFile(fp);
-            } else {
-                // 文件不存在:
-                ctx.response.status = 404;
-            }
-        } else {
-            // 不是指定前缀的URL，继续处理下一个middleware:
-            await next();
-        }
-    };
-}
-
-module.exports = staticFiles;
-```
-staticFiles是一个普通函数，它接收两个参数：URL前缀和一个目录，然后返回一个async函数。这个async函数会判断当前的URL是否以指定前缀开头，如果是，就把URL的路径视为文件，并发送文件内容。如果不是，这个async函数就不做任何事情，而是简单地调用await next()让下一个middleware去处理请求。
-
-我们使用了一个mz的包，并通过require('mz/fs');导入。mz提供的API和Node.js的fs模块完全相同，但fs模块使用回调，而mz封装了fs对应的函数，并改为Promise。这样，我们就可以非常简单的用await调用mz的函数，而不需要任何回调。
-
-所有的第三方包都可以通过npm官网搜索并查看其文档：
-```
-https://www.npmjs.com/
-```
-最后，这个middleware使用起来也很简单，在app.js里加一行代码：
-```
-let staticFiles = require('./static-files');
-app.use(staticFiles('/static/', __dirname + '/static'));
-```
-注意：也可以去npm搜索能用于koa2的处理静态文件的包并直接使用。
-
-## 集成Nunjucks
-集成Nunjucks实际上也是编写一个middleware，这个middleware的作用是给ctx对象绑定一个render(view, model)的方法，这样，后面的Controller就可以调用这个方法来渲染模板了。
-
-我们创建一个templating.js来实现这个middleware：
-```
-const nunjucks = require('nunjucks');
-
-function createEnv(path, opts) {
-    var
-        autoescape = opts.autoescape === undefined ? true : opts.autoescape,
-        noCache = opts.noCache || false,
-        watch = opts.watch || false,
-        throwOnUndefined = opts.throwOnUndefined || false,
-        env = new nunjucks.Environment(
-            new nunjucks.FileSystemLoader(path || 'views', {
-                noCache: noCache,
-                watch: watch,
-            }), {
-                autoescape: autoescape,
-                throwOnUndefined: throwOnUndefined
-            });
-    if (opts.filters) {
-        for (var f in opts.filters) {
-            env.addFilter(f, opts.filters[f]);
-        }
-    }
-    return env;
-}
-
-function templating(path, opts) {
-    // 创建Nunjucks的env对象:
-    var env = createEnv(path, opts);
-    return async (ctx, next) => {
-        // 给ctx绑定render函数:
-        ctx.render = function (view, model) {
-            // 把render后的内容赋值给response.body:
-            ctx.response.body = env.render(view, Object.assign({}, ctx.state || {}, model || {}));
-            // 设置Content-Type:
-            ctx.response.type = 'text/html';
-        };
-        // 继续处理请求:
-        await next();
-    };
-}
-
-module.exports = templating;
-```
-注意到createEnv()函数和前面使用Nunjucks时编写的函数是一模一样的。我们主要关心tempating()函数，它会返回一个middleware，在这个middleware中，我们只给ctx“安装”了一个render()函数，其他什么事情也没干，就继续调用下一个middleware。
-
-使用的时候，我们在app.js添加如下代码：
-```
-const isProduction = process.env.NODE_ENV === 'production';
-
-app.use(templating('views', {
-    noCache: !isProduction,
-    watch: !isProduction
-}));
-```
-这里我们定义了一个常量isProduction，它判断当前环境是否是production环境。如果是，就使用缓存，如果不是，就关闭缓存。在开发环境下，关闭缓存后，我们修改View，可以直接刷新浏览器看到效果，否则，每次修改都必须重启Node程序，会极大地降低开发效率。
-
-Node.js在全局变量process中定义了一个环境变量env.NODE_ENV，为什么要使用该环境变量？因为我们在开发的时候，环境变量应该设置为'development'，而部署到服务器时，环境变量应该设置为'production'。在编写代码的时候，要根据当前环境作不同的判断。
-
-注意：生产环境上必须配置环境变量NODE_ENV = 'production'，而开发环境不需要配置，实际上NODE_ENV可能是undefined，所以判断的时候，不要用NODE_ENV === 'development'。
-
-类似的，我们在使用上面编写的处理静态文件的middleware时，也可以根据环境变量判断：
-```
-if (! isProduction) {
-    let staticFiles = require('./static-files');
-    app.use(staticFiles('/static/', __dirname + '/static'));
-}
-```
-这是因为在生产环境下，静态文件是由部署在最前面的反向代理服务器（如Nginx）处理的，Node程序不需要处理静态文件。而在开发环境下，我们希望koa能顺带处理静态文件，否则，就必须手动配置一个反向代理服务器，这样会导致开发环境非常复杂。
-
-## 编写View
-在编写View的时候，非常有必要先编写一个base.html作为骨架，其他模板都继承自base.html，这样，才能大大减少重复工作。
-
-编写HTML不在本教程的讨论范围之内。这里我们参考Bootstrap的官网简单编写了base.html。
-
-## 运行
-一切顺利的话，这个view-koa工程应该可以顺利运行。运行前，我们再检查一下app.js里的middleware的顺序：
-
-第一个middleware是记录URL以及页面执行时间：
-```
-app.use(async (ctx, next) => {
-    console.log(`Process ${ctx.request.method} ${ctx.request.url}...`);
-    var
-        start = new Date().getTime(),
-        execTime;
-    await next();
-    execTime = new Date().getTime() - start;
-    ctx.response.set('X-Response-Time', `${execTime}ms`);
-});
-```
-第二个middleware处理静态文件：
-```
-if (! isProduction) {
-    let staticFiles = require('./static-files');
-    app.use(staticFiles('/static/', __dirname + '/static'));
-}
-```
-第三个middleware解析POST请求：
-```
-app.use(bodyParser());
-```
-第四个middleware负责给ctx加上render()来使用Nunjucks：
-```
-app.use(templating('views', {
-    noCache: !isProduction,
-    watch: !isProduction
-}));
-```
-最后一个middleware处理URL路由：
-```
-app.use(controller());
-```
-
-现在，在VS Code中运行代码，不出意外的话，在浏览器输入localhost:3000/，可以看到首页内容.
-
-直接在首页登录，如果输入正确的Email和Password，进入登录成功的页面.
-
-如果输入的Email和Password不正确，进入登录失败的页面.
-
-怎么判断正确的Email和Password？目前我们在signin.js中是这么判断的：
-```
-if (email === 'admin@example.com' && password === '123456') {
-    ...
-}
-```
-当然，真实的网站会根据用户输入的Email和Password去数据库查询并判断登录是否成功，不过这需要涉及到Node.js环境如何操作数据库，我们后面再讨论。
-
-## 扩展
-注意到ctx.render内部渲染模板时，Model对象并不是传入的model变量，而是：
-```
-Object.assign({}, ctx.state || {}, model || {})
-```
-这个小技巧是为了扩展。
-
-首先，model || {}确保了即使传入undefined，model也会变为默认值{}。Object.assign()会把除第一个参数外的其他参数的所有属性复制到第一个参数中。第二个参数是ctx.state || {}，这个目的是为了能把一些公共的变量放入ctx.state并传给View。
-
-例如，某个middleware负责检查用户权限，它可以把当前用户放入ctx.state中：
-```
-app.use(async (ctx, next) => {
-    var user = tryGetUserFromCookie(ctx.request);
-    if (user) {
-        ctx.state.user = user;
-        await next();
-    } else {
-        ctx.response.status = 403;
-    }
-});
-```
-这样就没有必要在每个Controller的async函数中都把user变量放入model中。
\ No newline at end of file
diff --git "a/12\351\276\232\344\270\234\350\276\211/20230310-\350\277\236\346\216\245\346\225\260\346\215\256\345\272\223.md" "b/12\351\276\232\344\270\234\350\276\211/20230310-\350\277\236\346\216\245\346\225\260\346\215\256\345\272\223.md"
deleted file mode 100644
index 009769c4678fca4638448423e7fbd9c61f467be4..0000000000000000000000000000000000000000
--- "a/12\351\276\232\344\270\234\350\276\211/20230310-\350\277\236\346\216\245\346\225\260\346\215\256\345\272\223.md"
+++ /dev/null
@@ -1,284 +0,0 @@
-# 使用Sequelize
-
-## 访问MySQL
-当我们安装好MySQL后，Node.js程序如何访问MySQL数据库呢？
-
-访问MySQL数据库只有一种方法，就是通过网络发送SQL命令，然后，MySQL服务器执行后返回结果。
-
-我们可以在命令行窗口输入mysql -u root -p，然后输入root口令后，就连接到了MySQL服务器。因为没有指定--host参数，所以我们连接到的是localhost，也就是本机的MySQL服务器。
-
-在命令行窗口下，我们可以输入命令，操作MySQL服务器：
-```
-mysql> show databases;
-+--------------------+
-| Database           |
-+--------------------+
-| information_schema |
-| mysql              |
-| performance_schema |
-| test               |
-+--------------------+
-4 rows in set (0.05 sec)
-```
-输入exit退出MySQL命令行模式。
-
-对于Node.js程序，访问MySQL也是通过网络发送SQL命令给MySQL服务器。这个访问MySQL服务器的软件包通常称为MySQL驱动程序。不同的编程语言需要实现自己的驱动，MySQL官方提供了Java、.Net、Python、Node.js、C++和C的驱动程序，官方的Node.js驱动目前仅支持5.7以上版本，而我们上面使用的命令行程序实际上用的就是C驱动。
-
-目前使用最广泛的MySQL Node.js驱动程序是开源的mysql，可以直接使用npm安装。
-
-## ORM
-如果直接使用mysql包提供的接口，我们编写的代码就比较底层，例如，查询代码：
-```
-connection.query('SELECT * FROM users WHERE id = ?', ['123'], function(err, rows) {
-    if (err) {
-        // error
-    } else {
-        for (let row in rows) {
-            processRow(row);
-        }
-    }
-});
-```
-考虑到数据库表是一个二维表，包含多行多列，例如一个pets的表：
-```
-mysql> select * from pets;
-+----+--------+------------+
-| id | name   | birth      |
-+----+--------+------------+
-|  1 | Gaffey | 2007-07-07 |
-|  2 | Odie   | 2008-08-08 |
-+----+--------+------------+
-2 rows in set (0.00 sec)
-```
-每一行可以用一个JavaScript对象表示，例如第一行：
-```
-{
-    "id": 1,
-    "name": "Gaffey",
-    "birth": "2007-07-07"
-}
-```
-这就是传说中的ORM技术：Object-Relational Mapping，把关系数据库的表结构映射到对象上。是不是很简单？
-
-但是由谁来做这个转换呢？所以ORM框架应运而生。
-
-我们选择Node的ORM框架Sequelize来操作数据库。这样，我们读写的都是JavaScript对象，Sequelize帮我们把对象变成数据库中的行。
-
-用Sequelize查询pets表，代码像这样：
-```
-Pet.findAll()
-   .then(function (pets) {
-       for (let pet in pets) {
-           console.log(`${pet.id}: ${pet.name}`);
-       }
-   }).catch(function (err) {
-       // error
-   });
-```
-因为Sequelize返回的对象是Promise，所以我们可以用then()和catch()分别异步响应成功和失败。
-
-但是用then()和catch()仍然比较麻烦。有没有更简单的方法呢？
-
-可以用ES7的await来调用任何一个Promise对象，这样我们写出来的代码就变成了：
-```
-var pets = await Pet.findAll();
-```
-真的就是这么简单！
-
-await只有一个限制，就是必须在async函数中调用。上面的代码直接运行还差一点，我们可以改成：
-```
-(async () => {
-    var pets = await Pet.findAll();
-})();
-```
-考虑到koa的处理函数都是async函数，所以我们实际上将来在koa的async函数中直接写await访问数据库就可以了！
-
-这也是为什么我们选择Sequelize的原因：只要API返回Promise，就可以用await调用，写代码就非常简单！
-
-## 实战
-在使用Sequlize操作数据库之前，我们先在MySQL中创建一个表来测试。我们可以在test数据库中创建一个pets表。test数据库是MySQL安装后自动创建的用于测试的数据库。在MySQL命令行执行下列命令：
-```
-grant all privileges on test.* to 'www'@'%' identified by 'www';
-
-use test;
-
-create table pets (
-    id varchar(50) not null,
-    name varchar(100) not null,
-    gender bool not null,
-    birth varchar(10) not null,
-    createdAt bigint not null,
-    updatedAt bigint not null,
-    version bigint not null,
-    primary key (id)
-) engine=innodb;
-```
-第一条grant命令是创建MySQL的用户名和口令，均为www，并赋予操作test数据库的所有权限。
-
-第二条use命令把当前数据库切换为test。
-
-第三条命令创建了pets表。
-
-然后，我们根据前面的工程结构创建hello-sequelize工程，结构如下：
-```
-hello-sequelize/
-|
-+- .vscode/
-|  |
-|  +- launch.json <-- VSCode 配置文件
-|
-+- init.txt <-- 初始化SQL命令
-|
-+- config.js <-- MySQL配置文件
-|
-+- app.js <-- 使用koa的js
-|
-+- package.json <-- 项目描述文件
-|
-+- node_modules/ <-- npm安装的所有依赖包
-```
-然后，添加如下依赖包：
-```
-"sequelize": "3.24.1",
-"mysql": "2.11.1"
-```
-注意mysql是驱动，我们不直接使用，但是sequelize会用。
-
-## 用npm install安装。
-
-config.js实际上是一个简单的配置文件：
-```
-var config = {
-    database: 'test', // 使用哪个数据库
-    username: 'www', // 用户名
-    password: 'www', // 口令
-    host: 'localhost', // 主机名
-    port: 3306 // 端口号，MySQL默认3306
-};
-
-module.exports = config;
-```
-下面，我们就可以在app.js中操作数据库了。使用Sequelize操作MySQL需要先做两件准备工作：
-
-第一步，创建一个sequelize对象实例：
-```
-const Sequelize = require('sequelize');
-const config = require('./config');
-
-var sequelize = new Sequelize(config.database, config.username, config.password, {
-    host: config.host,
-    dialect: 'mysql',
-    pool: {
-        max: 5,
-        min: 0,
-        idle: 30000
-    }
-});
-```
-第二步，定义模型Pet，告诉Sequelize如何映射数据库表：
-```
-var Pet = sequelize.define('pet', {
-    id: {
-        type: Sequelize.STRING(50),
-        primaryKey: true
-    },
-    name: Sequelize.STRING(100),
-    gender: Sequelize.BOOLEAN,
-    birth: Sequelize.STRING(10),
-    createdAt: Sequelize.BIGINT,
-    updatedAt: Sequelize.BIGINT,
-    version: Sequelize.BIGINT
-}, {
-        timestamps: false
-    });
-```
-用sequelize.define()定义Model时，传入名称pet，默认的表名就是pets。第二个参数指定列名和数据类型，如果是主键，需要更详细地指定。第三个参数是额外的配置，我们传入{ timestamps: false }是为了关闭Sequelize的自动添加timestamp的功能。所有的ORM框架都有一种很不好的风气，总是自作聪明地加上所谓“自动化”的功能，但是会让人感到完全摸不着头脑。
-
-接下来，我们就可以往数据库中塞一些数据了。我们可以用Promise的方式写：
-```
-var now = Date.now();
-
-Pet.create({
-    id: 'g-' + now,
-    name: 'Gaffey',
-    gender: false,
-    birth: '2007-07-07',
-    createdAt: now,
-    updatedAt: now,
-    version: 0
-}).then(function (p) {
-    console.log('created.' + JSON.stringify(p));
-}).catch(function (err) {
-    console.log('failed: ' + err);
-});
-```
-也可以用await写：
-```
-(async () => {
-    var dog = await Pet.create({
-        id: 'd-' + now,
-        name: 'Odie',
-        gender: false,
-        birth: '2008-08-08',
-        createdAt: now,
-        updatedAt: now,
-        version: 0
-    });
-    console.log('created: ' + JSON.stringify(dog));
-})();
-```
-显然await代码更胜一筹。
-
-查询数据时，用await写法如下：
-```
-(async () => {
-    var pets = await Pet.findAll({
-        where: {
-            name: 'Gaffey'
-        }
-    });
-    console.log(`find ${pets.length} pets:`);
-    for (let p of pets) {
-        console.log(JSON.stringify(p));
-    }
-})();
-```
-如果要更新数据，可以对查询到的实例调用save()方法：
-```
-(async () => {
-    var p = await queryFromSomewhere();
-    p.gender = true;
-    p.updatedAt = Date.now();
-    p.version ++;
-    await p.save();
-})();
-```
-如果要删除数据，可以对查询到的实例调用destroy()方法：
-```
-(async () => {
-    var p = await queryFromSomewhere();
-    await p.destroy();
-})();
-```
-运行代码，可以看到Sequelize打印出的每一个SQL语句，便于我们查看：
-```
-Executing (default): INSERT INTO `pets` (`id`,`name`,`gender`,`birth`,`createdAt`,`updatedAt`,`version`) VALUES ('g-1471961204219','Gaffey',false,'2007-07-07',1471961204219,1471961204219,0);
-```
-
-## Model
-我们把通过sequelize.define()返回的Pet称为Model，它表示一个数据模型。
-
-我们把通过Pet.findAll()返回的一个或一组对象称为Model实例，每个实例都可以直接通过JSON.stringify序列化为JSON字符串。但是它们和普通JSON对象相比，多了一些由Sequelize添加的方法，比如save()和destroy()。调用这些方法我们可以执行更新或者删除操作。
-
-所以，使用Sequelize操作数据库的一般步骤就是：
-
-首先，通过某个Model对象的findAll()方法获取实例；
-
-如果要更新实例，先对实例属性赋新值，再调用save()方法；
-
-如果要删除实例，直接调用destroy()方法。
-
-注意findAll()方法可以接收where、order这些参数，这和将要生成的SQL语句是对应的。
-
-## 文档
-Sequelize的API可以参考官方文档。
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230213-\345\274\200\345\255\246.md" "b/33\347\211\233\346\226\207\350\275\251/20230213-\345\274\200\345\255\246.md"
deleted file mode 100644
index 6c7758ff7b15b0bb22bb721fd1da62cebf629eb5..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230213-\345\274\200\345\255\246.md"
+++ /dev/null
@@ -1,2 +0,0 @@
-开学第一课，终于回到了学校。
-开始本学期的专业课课程，第一门课node.js,第二门课vue.js
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230214-\346\220\255\345\273\272\347\216\257\345\242\203launch.md" "b/33\347\211\233\346\226\207\350\275\251/20230214-\346\220\255\345\273\272\347\216\257\345\242\203launch.md"
deleted file mode 100644
index 07a6d1dd8d584bb83a8f3f18afad650db1d4ec8d..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230214-\346\220\255\345\273\272\347\216\257\345\242\203launch.md"
+++ /dev/null
@@ -1,33 +0,0 @@
-```
-{
-    // 使用 IntelliSense 了解相关属性。 
-    // 悬停以查看现有属性的描述。
-    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Launch Program",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "program": "${workspaceFolder}\\index.js"
-        }
-    ]
-}
-```
-
-```
-'use strict'
-
-
-var fs=require('./greet');
-kunkun.readfile('kunkun.txt','utf-8',function(err,data){
-    if (err) {
-        console.log(err);
-    }else{
-       console.log(data);
-    }
-});
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230216-\346\250\241\345\235\227.md" "b/33\347\211\233\346\226\207\350\275\251/20230216-\346\250\241\345\235\227.md"
deleted file mode 100644
index 65c0b9740fc1746ce495b7be4291c69d4fec2316..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230216-\346\250\241\345\235\227.md"
+++ /dev/null
@@ -1,25 +0,0 @@
-创建一个函数，这样我们就可以在其他地方调用这个函数：
-```
-'use strict';
-
-var s = 'Hello';
-
-function greet(name) {
-    console.log(s + ', ' + name + '!');
-}
-
-module.exports = greet;
-```
-
-
-编写一个main.js文件，调用hello模块的greet函数：
-```
-'use strict';
-
-// 引入hello模块:
-var greet = require('./hello');
-
-var s = 'Michael';
-
-greet(s); // Hello, Michael!
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230217-\345\210\233\345\273\272\347\275\221\347\253\231.md" "b/33\347\211\233\346\226\207\350\275\251/20230217-\345\210\233\345\273\272\347\275\221\347\253\231.md"
deleted file mode 100644
index 0f83490085cb9d44251fc9eab094f2b73f3786b8..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230217-\345\210\233\345\273\272\347\275\221\347\253\231.md"
+++ /dev/null
@@ -1,71 +0,0 @@
-服务器创建笔记
-pt upgrade -y  更新数据
-
-apt install nginx -y  安装 nginx服务器
-
-systemct1 status 面板服务，执行服务器确保没问题
-
-systemct1 enable nginx 自启动开机nginx系统
-
-systemct1 status nginx 查看 nginx系统 状态
-
-systemct1 stop nginx   结束状态
-
-ssh root@hd.changex.top
-
-cd /var/www  进入 这个目录才能使用进入变量等等操作      访问方便
-
-mkdir hd.changex.top   创建目录
-
-rmdir hd.changex.top  删除目录
-
-ls 查看目录
-
-ls -al 查看当前目录信息
-
-vim ~/.bashrc 进入环境变量
-
-source ~/.bashrc 刷新变量
-
- :wq!  退出环境变量
-
- ll  查看当前状态
- ll -a 查看更多的当前状态
-
-cd hd.change.top 进入创建的目录
-
- 11月7日视频42分钟 上传内容
-
-在最普通的模式下打(root@iZwz9fhv99le48i6gtgwovZ:~#):后面打 cd /etc/nginx/conf.d/   网站配置文件
-
-vim hd.changex.top.conf  进入配置文件，创建配置文件 然后打o字母
-
-进入配置文件后
-server {
-              listen 80;
-              server_name hd.changex.top;
- 
-    location / { 
-                        root  /var/www/hd.changex.top/文件名
-                        index index.html;
-
-  }
-
-
-}
-
-nginx -t  检查语法是否错误
-
-nginx -s reload  重新加载配置，保存配置
-
-cd   返回上级指令
-
-vim /root/.bashrc   进入root的环境变量
-
-apt install -y git    安装git
-
-scp -r 文件名 root@hd.changex.top:/var/www/hd.changex.top    上传文件夹的
-
- rm -f 文件      删除文件
-
- rm -r 文件夹   删除文件夹+
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230220-\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md" "b/33\347\211\233\346\226\207\350\275\251/20230220-\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"
deleted file mode 100644
index 6becd3dd59f86be901bb83755520aa2c76bebd3b..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230220-\346\226\207\344\273\266\346\234\215\345\212\241\345\231\250.md"
+++ /dev/null
@@ -1,28 +0,0 @@
-##### 解析URL需要用到Node.js提供的url模块，它使用起来非常简单，通过parse()将一个字符串解析为一个Url对象：
-```
-Url {
-  protocol: 'http:',
-  slashes: true,
-  auth: 'user:pass',
-  host: 'host.com:8080',
-  port: '8080',
-  hostname: 'host.com',
-  hash: '#hash',
-  search: '?query=string',
-  query: 'query=string',
-  pathname: '/path/to/file',
-  path: '/path/to/file?query=string',
-  href: 'http://user:pass@host.com:8080/path/to/file?query=string#hash' }
-```
-处理本地文件目录需要使用Node.js提供的path模块，它可以方便地构造目录：
-```
-'use strict';
-
-var path = require('path');
-
-// 解析当前目录:
-var workDir = path.resolve('.'); // '/Users/michael'
-
-// 组合完整的文件路径:当前目录+'pub'+'index.html':
-var filePath = path.join(workDir, 'pub', 'index.html');
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230221-promise.md" "b/33\347\211\233\346\226\207\350\275\251/20230221-promise.md"
deleted file mode 100644
index a9262e15c14cfa8e1a4713896d7824c286b99b5c..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230221-promise.md"
+++ /dev/null
@@ -1,36 +0,0 @@
-### Promise是JS中进行异步编程的新的解决方案
-
-#### promise 是一个构造函数
-#### Promise 的构造函数接收一个函数为参数，并且传入两个参数：resolve，reject，分别表示异步操作执行成功后的回调函数和异步操作执行失败后的回调函数。
-#### 指定回调函数的方法更加灵活
-#### 支持链式调用 ，可以解决回调函数问题
-
-### 基础定义
-#### Promise 构造函数: Promise (excutor) {} 
-#### excutor 函数: 同步执行 (resolve, reject) => {}
-#### resolve 函数: 内部定义成功时我们调用的函数 value => {} 
-#### reject 函数: 内部定义失败时我们调用的函数 reason => {}
-
-### .then() 方法用来预先指定成功和失败的回调函数，调用 .then() 方法时，成功的回调函数是必选的，失败的回调函数是可选的
-#### 返回一个新的 promise 对象
-
-```
-Promise.prototype.then(onResolved, onRejected) => {}`
-onResolved 函数: 成功的回调函数 (value) => {} 
-onRejected 函数: 失败的回调函数 (reason) => {} 
-```
-
-### Promise.resolve 方法:
-### 说明：返回一个 成功/失败 的 promise 对象
-```
-Promise.resolve(value) => {}` 
-value: 成功的数据或 promise 对象
-```
-
-### Promise.reject 方法:
-```
-说明：返回一个 失败 的 promise 对象
-Promise.reject(reason) => {} `
-reason: 失败的原因  
-```
-
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230224-\347\273\203\344\271\240.md" "b/33\347\211\233\346\226\207\350\275\251/20230224-\347\273\203\344\271\240.md"
deleted file mode 100644
index c3114fe06130555aaf3938730ac04bbbdac7c27e..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230224-\347\273\203\344\271\240.md"
+++ /dev/null
@@ -1,57 +0,0 @@
-'use strict'
-var http = require('http');
-var fs = require('fs');//引入文件读取模块
-
-var server= http.createServer(function(req,res){
-  
-  //客户端输入的url，例如如果输入localhost:8888/index.html  
-  var url = '.'+ req.url;
-  console.log(url);
-  if (fs.existsSync (url) ) {
-    if (fs.existsSync (url+'/index.html')) {
-      url=url+'/index.html';}
-  }else if (fs.existsSync (url+'.html') ) {
-    url=url+'.html';
-  }else if (fs.existsSync(url+'.txt')) {
-    url=url+'.txt';
-  }else if (fs.existsSync(url+'.md')) {
-    url=url+'.md';
-  }else if(url='/'){
-    url='./index.html';
-  }
-
- 
-
-  fs.readFile( url ,'utf-8', function(err,data){
-    
-  /*
-
-    一参为文件路径
-
-    二参为回调函数
-
-      回调函数的一参为读取错误返回的信息，返回空就没有错误
-
-      二参为读取成功返回的文本内容
-
-  */
-
-    if(err){
-      res.writeHeader(404,{
-        'content-type' : 'text/html;charset="utf-8"'
-      });
-      res.write('<h1>404错误</h1><p>你要找的页面不存在</p>');
-      res.end();
-    }else{
-      res.writeHeader(200,{
-        'content-type' : 'text/html;charset="utf-8"'
-      });
-      res.write(data);//将index.html显示在客户端
-      res.end();
-
-    }
-  });
-
-}).listen(8888);
-
-console.log('http://127.0.0.1:8888');
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230225-koa.md" "b/33\347\211\233\346\226\207\350\275\251/20230225-koa.md"
deleted file mode 100644
index 6470551788ac4ce75684d1ad5750c8b9934a65c4..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230225-koa.md"
+++ /dev/null
@@ -1,9 +0,0 @@
-koa是Express的下一代基于Node.js的web框架，
-```
-app.use(async (ctx, next) => {
-    await next();
-    var data = await doReadFile();
-    ctx.response.type = 'text/plain';
-    ctx.response.body = data;
-});
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230227-\350\267\257\347\224\261.md" "b/33\347\211\233\346\226\207\350\275\251/20230227-\350\267\257\347\224\261.md"
deleted file mode 100644
index 4aa4278f58bebe264a3b3c4c4df37ee2258bd6b3..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230227-\350\267\257\347\224\261.md"
+++ /dev/null
@@ -1,26 +0,0 @@
-```
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/') {
-        ctx.response.body = 'index page';
-    } else {
-        await next();
-    }
-});
-
-
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/test') {
-        ctx.response.body = 'TEST page';
-    } else {
-        await next();
-    }
-});
-
-app.use(async (ctx, next) => {
-    if (ctx.request.path === '/error') {
-        ctx.response.body = 'ERROR page';
-    } else {
-        await next();
-    }
-});
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230228-router.md" "b/33\347\211\233\346\226\207\350\275\251/20230228-router.md"
deleted file mode 100644
index f91624b8d132637c81d304615adac5fe420f28bc..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230228-router.md"
+++ /dev/null
@@ -1,21 +0,0 @@
-```
-'use strict'
-
-const koa=require('koa');
-const router=require('router')();
-console.log(router);
-const app=new koa();
-
-router.get('/abc',async(ctx,next)=>{
-    ctx.body='我是abc';
-})
-router.get('/def',async(ctx,next)=>{
-    ctx.body='我是def';
-})
-
-app.use(router,router());
-let port=3000;
-app.listen(port);
-
-console.log(`http://localhost:${port}`);
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230302-\351\207\215\346\236\204.md" "b/33\347\211\233\346\226\207\350\275\251/20230302-\351\207\215\346\236\204.md"
deleted file mode 100644
index 0a1559ac767604fca43ae6ee2c9f2e67e55175e9..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230302-\351\207\215\346\236\204.md"
+++ /dev/null
@@ -1,34 +0,0 @@
-Controller Middleware
-最后，我们把扫描controllers目录和创建router的代码从app.js中提取出来，作为一个简单的middleware使用，命名为controller.js：
-
-const fs = require('fs');
-
-function addMapping(router, mapping) {
-    ...
-}
-
-function addControllers(router, dir) {
-    ...
-}
-
-module.exports = function (dir) {
-    let
-        controllers_dir = dir || 'controllers', // 如果不传参数，扫描目录默认为'controllers'
-        router = require('koa-router')();
-    addControllers(router, controllers_dir);
-    return router.routes();
-};
-这样一来，我们在app.js的代码又简化了：
-
-...
-
-// 导入controller middleware:
-const controller = require('./controller');
-
-...
-
-// 使用middleware:
-app.use(controller());
-
-...
-经过重新整理后的工程url2-koa目前具备非常好的模块化，所有处理URL的函数按功能组存放在controllers目录，今后我们也只需要不断往这个目录下加东西就可以了，app.js保持不变。
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230303-url\345\244\204\347\220\206.md" "b/33\347\211\233\346\226\207\350\275\251/20230303-url\345\244\204\347\220\206.md"
deleted file mode 100644
index 989b2034d29c2bbafb5592b73837899364ca5d21..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230303-url\345\244\204\347\220\206.md"
+++ /dev/null
@@ -1,18 +0,0 @@
-```
-const fs = require('fs'); // 文件模块
-const Koa = require('koa');
-const router = require('koa-router')(); // 处理url与express一样 都需要引入相关的处理模块
-const bodyParser = require('koa-bodyparser'); // 处理原始请求json字符串解析模块
-const app = new Koa(); // 实例化koa，K大写代表引入的是koa2
-app.use(bodyParser()); 
-app.use(router.routes()); // URL处理模块
-
-app.use(async (ctx, next) => { // ctx 你可以理解为客户端 存储着所有的信息 username path 等信息
-  console.log(ctx.request.path, 'asdsad'); // 获取浏览器地址信息 判断是否路径为/index
-  if (ctx.request.path === '/index') {
-    ctx.response.body = 'index page';  // 发送数据Index page
-  } else {
-    await next();
-  }
-});
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230306-\345\260\201\350\243\205.md" "b/33\347\211\233\346\226\207\350\275\251/20230306-\345\260\201\350\243\205.md"
deleted file mode 100644
index b37f54463bdd106dffc20e6f028f503e731fc8e0..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230306-\345\260\201\350\243\205.md"
+++ /dev/null
@@ -1,123 +0,0 @@
-# 封装
-
-文件app.js
-```js
-'use strict'
-const Koa = require('koa');
-const controllers = require('./controller')
-
-let app = new Koa();
-controllers(app)
-
-let port = 8088;
-app.listen(port);
-console.log(`http://localhost:${port}`);
-```
-
-index.js
-```js
-'use strict'
-
-
-const router = require('koa-router')();
-const bodyparser = require('koa-bodyparser');
-const {findControllers,registryRouter} = require('../utils/tools')
-
-//处理路由
-function processRouter(app) {
-
-    //1、找到所有路由文件
-    let controllers = findControllers()
-    //2、遍历注册所有路由
-
-    registryRouter(controllers,router)
-
-    app.use(bodyparser())
-    app.use(router.routes());
-
-}
-module.exports = processRouter
-```
-
-tools.js
-```js
-'use strict'
-
-const fs = require('fs')
-
-//1、找到所有路由文件
-function findControllers(path) {
-    path = path || './controller/';
-    console.log(path);
-    let files = fs.readdirSync(path)
-    // console.log(files);
-    return files.filter(item => {
-        return item !== 'index.js'
-    })
-}
-
-//2、遍历注册所有路由
-function registryRouter(controllerFiles,router) {
-    controllerFiles.forEach(item => {
-        let tmpModule = require('../controller/' + item.replace('.js', ''));
-        console.log(tmpModule);
-        for (let key in tmpModule) {
-            let tmpArr = key.split(' ');
-
-            let method = tmpArr[0];
-            let url = tmpArr[1];
-            let fn = tmpModule[key];
-
-            if (method === 'get') {
-                router.get(url,fn)
-            } else if (method === 'post') {
-                router.post(url,fn)
-            } else if (method === 'put') {
-                router.put(url,fn)
-            } else if (method === 'delete') {
-                router.delete(url,fn)
-            }
-
-        }
-    })
-}
-
-module.exports = {
-    findControllers,
-    registryRouter
-}
-```
-
-users.js
-```js
-'use strict'
-
-
-async function getAll(ctx, next) {
-    ctx.body = '这里是getAll'
-}
-
-async function getById(ctx, next) {
-    ctx.body = '这里是getById'
-}
-
-async function addItem(ctx, next) {
-    ctx.body = '这里是addItem'
-}
-
-async function updateItem(ctx, next) {
-
-}
-
-async function delItem(ctx, next) {
-
-}
-
-module.exports = {
-    'get /users':getAll,
-    'get /users/:id':getById,
-    'post /users':addItem,
-    'put /users/:id':updateItem,
-    'delete /users/:id':delItem
-}
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230307-Nunjucks.md" "b/33\347\211\233\346\226\207\350\275\251/20230307-Nunjucks.md"
deleted file mode 100644
index a506af243452b3b996e4321ae4743d886fc181ac..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230307-Nunjucks.md"
+++ /dev/null
@@ -1,174 +0,0 @@
-# Nunjucks
-
-Nunjucks是什么东东？其实它是一个模板引擎。
-
-那什么是模板引擎？
-
-模板引擎就是基于模板配合数据构造出字符串输出的一个组件。比如下面的函数就是一个模板引擎：
-```
-function examResult (data) {
-    return `${data.name}同学一年级期末考试语文${data.chinese}分，数学${data.math}分，位于年级第${data.ranking}名。`
-}
-```
-如果我们输入数据如下：
-```
-examResult({
-    name: '小明',
-    chinese: 78,
-    math: 87,
-    ranking: 999
-});
-```
-该模板引擎把模板字符串里面对应的变量替换以后，就可以得到以下输出：
-
-小明同学一年级期末考试语文78分，数学87分，位于年级第999名。
-
-
-## 简单逻辑
-模板还需要能执行一些简单逻辑，比如，要按条件输出内容，需要if实现如下输出：
-```
-{{ name }}同学，
-{% if score >= 90 %}
-    成绩优秀，应该奖励
-{% elif score >=60 %}
-    成绩良好，继续努力
-{% else %}
-    不及格，建议回家打屁股
-{% endif %}
-```
-所以，我们需要一个功能强大的模板引擎，来完成页面输出的功能。
-
-
-我们创建一个use-nunjucks的VS Code工程结构如下：
-```
-use-nunjucks/
-|
-+- .vscode/
-|  |
-|  +- launch.json <-- VSCode 配置文件
-|
-+- views/
-|  |
-|  +- hello.html <-- HTML模板文件
-|
-+- app.js <-- 入口js
-|
-+- package.json <-- 项目描述文件
-|
-+- node_modules/ <-- npm安装的所有依赖包
-```
-其中，模板文件存放在views目录中。
-
-我们先在package.json中添加nunjucks的依赖：
-```
-"nunjucks": "2.4.2"
-```
-注意，模板引擎是可以独立使用的，并不需要依赖koa。用npm install安装所有依赖包。
-
-紧接着，我们要编写使用Nunjucks的函数render。怎么写？方法是查看Nunjucks的官方文档，仔细阅读后，在app.js中编写代码如下：
-```
-const nunjucks = require('nunjucks');
-
-function createEnv(path, opts) {
-    var
-        autoescape = opts.autoescape === undefined ? true : opts.autoescape,
-        noCache = opts.noCache || false,
-        watch = opts.watch || false,
-        throwOnUndefined = opts.throwOnUndefined || false,
-        env = new nunjucks.Environment(
-            new nunjucks.FileSystemLoader('views', {
-                noCache: noCache,
-                watch: watch,
-            }), {
-                autoescape: autoescape,
-                throwOnUndefined: throwOnUndefined
-            });
-    if (opts.filters) {
-        for (var f in opts.filters) {
-            env.addFilter(f, opts.filters[f]);
-        }
-    }
-    return env;
-}
-
-var env = createEnv('views', {
-    watch: true,
-    filters: {
-        hex: function (n) {
-            return '0x' + n.toString(16);
-        }
-    }
-});
-```
-变量env就表示Nunjucks模板引擎对象，它有一个`render(view, model)`方法，正好传入view和model两个参数，并返回字符串。
-
-创建env需要的参数可以查看文档获知。我们用autoescape = opts.autoescape && true这样的代码给每个参数加上默认值，最后使用`new nunjucks.FileSystemLoader('views')`创建一个文件系统加载器，从views目录读取模板。
-
-我们编写一个`hello.html`模板文件，放到views目录下，内容如下：
-```
-<h1>Hello {{ name }}</h1>
-```
-然后，我们就可以用下面的代码来渲染这个模板：
-```
-var s = env.render('hello.html', { name: '小明' });
-console.log(s);
-```
-获得输出如下：
-```
-<h1>Hello 小明</h1>
-```
-咋一看，这和使用JavaScript模板字符串没啥区别嘛。不过，试试：
-```
-var s = env.render('hello.html', { name: '<script>alert("小明")</script>' });
-console.log(s);
-```
-获得输出如下：
-```
-<h1>Hello &lt;script&gt;alert("小明")&lt;/script&gt;</h1>
-```
-这样就避免了输出恶意脚本。
-
-此外，可以使用Nunjucks提供的功能强大的tag，编写条件判断、循环等功能，例如：
-```
-<!-- 循环输出名字 -->
-<body>
-    <h3>Fruits List</h3>
-    {% for f in fruits %}
-    <p>{{ f }}</p>
-    {% endfor %}
-</body>
-```
-Nunjucks模板引擎最强大的功能在于模板的继承。仔细观察各种网站可以发现，网站的结构实际上是类似的，头部、尾部都是固定格式，只有中间页面部分内容不同。如果每个模板都重复头尾，一旦要修改头部或尾部，那就需要改动所有模板。
-
-更好的方式是使用继承。先定义一个基本的网页框架base.html：
-```
-<html><body>
-{% block header %} <h3>Unnamed</h3> {% endblock %}
-{% block body %} <div>No body</div> {% endblock %}
-{% block footer %} <div>copyright</div> {% endblock %}
-</body>
-</html>
-```
-base.html定义了三个可编辑的块，分别命名为header、body和footer。子模板可以有选择地对块进行重新定义：
-```
-{% extends 'base.html' %}
-
-{% block header %}<h1>{{ header }}</h1>{% endblock %}
-
-{% block body %}<p>{{ body }}</p>{% endblock %}
-```
-然后，我们对子模板进行渲染：
-```
-console.log(env.render('extend.html', {
-    header: 'Hello',
-    body: 'bla bla bla...'
-}));
-```
-输出HTML如下：
-```
-<html><body>
-<h1>Hello</h1>
-<p>bla bla bla...</p>
-<div>copyright</div> <-- footer没有重定义，所以仍使用父模板的内容
-</body>
-```
\ No newline at end of file
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230309-MVC.md" "b/33\347\211\233\346\226\207\350\275\251/20230309-MVC.md"
deleted file mode 100644
index 8f9cbd57b8d468c3076c1f34eb332200e85503e9..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230309-MVC.md"
+++ /dev/null
@@ -1,173 +0,0 @@
-
-## MVC
-我们已经可以用koa处理不同的URL，还可以用Nunjucks渲染模板。现在，是时候把这两者结合起来了！
-
-当用户通过浏览器请求一个URL时，koa将调用某个异步函数处理该URL。在这个异步函数内部，我们用一行代码：
-```
-ctx.render('home.html', { name: 'Michael' });
-```
-通过Nunjucks把数据用指定的模板渲染成HTML，然后输出给浏览器，用户就可以看到渲染后的页面了：
-
-## mvc
-
-这就是传说中的MVC：Model-View-Controller，中文名“模型-视图-控制器”。
-
-异步函数是C：Controller，Controller负责业务逻辑，比如检查用户名是否存在，取出用户信息等等；
-
-包含变量{{ name }}的模板就是V：View，View负责显示逻辑，通过简单地替换一些变量，View最终输出的就是用户看到的HTML。
-
-MVC中的Model在哪？Model是用来传给View的，这样View在替换变量的时候，就可以从Model中取出相应的数据。
-
-上面的例子中，Model就是一个JavaScript对象：
-```
-{ name: 'Michael' }
-```
-下面，我们根据原来的url2-koa创建工程view-koa，把koa2、Nunjucks整合起来，然后，把原来直接输出字符串的方式，改为ctx.render(view, model)的方式。
-
-工程view-koa结构如下：
-```
-view-koa/
-|
-+- .vscode/
-|  |
-|  +- launch.json <-- VSCode 配置文件
-|
-+- controllers/ <-- Controller
-|
-+- views/ <-- html模板文件
-|
-+- static/ <-- 静态资源文件
-|
-+- controller.js <-- 扫描注册Controller
-|
-+- app.js <-- 使用koa的js
-|
-+- package.json <-- 项目描述文件
-|
-+- node_modules/ <-- npm安装的所有依赖包
-```
-在package.json中，我们将要用到的依赖包有：
-```
-"koa": "2.0.0",
-"koa-bodyparser": "3.2.0",
-"koa-router": "7.0.0",
-"nunjucks": "2.4.2",
-"mime": "1.3.4",
-"mz": "2.4.0"
-```
-先用npm install安装依赖包。
-
-然后，我们准备编写以下两个Controller：
-
-1. 处理首页 GET /
-
-我们定义一个async函数处理首页URL/：
-```
-async (ctx, next) => {
-    ctx.render('index.html', {
-        title: 'Welcome'
-    });
-}
-```
-注意到koa并没有在ctx对象上提供render方法，这里我们假设应该这么使用，这样，我们在编写Controller的时候，最后一步调用ctx.render(view, model)就完成了页面输出。
-
-2. 处理登录请求 POST /signin
-我们再定义一个async函数处理登录请求/signin：
-```
-async (ctx, next) => {
-    var
-        email = ctx.request.body.email || '',
-        password = ctx.request.body.password || '';
-    if (email === 'admin@example.com' && password === '123456') {
-        // 登录成功:
-        ctx.render('signin-ok.html', {
-            title: 'Sign In OK',
-            name: 'Mr Node'
-        });
-    } else {
-        // 登录失败:
-        ctx.render('signin-failed.html', {
-            title: 'Sign In Failed'
-        });
-    }
-}
-```
-由于登录请求是一个POST，我们就用ctx.request.body.<name>拿到POST请求的数据，并给一个默认值。
-
-登录成功时我们用signin-ok.html渲染，登录失败时我们用signin-failed.html渲染，所以，我们一共需要以下3个View：
-```
-index.html
-signin-ok.html
-signin-failed.html
-```
-
-## 编写View
-在编写View的时候，我们实际上是在编写HTML页。为了让页面看起来美观大方，使用一个现成的CSS框架是非常有必要的。我们用Bootstrap这个CSS框架。从首页下载zip包后解压，我们把所有静态资源文件放到/static目录下：
-```
-view-koa/
-|
-+- static/
-   |
-   +- css/ <- 存放bootstrap.css等
-   |
-   +- fonts/ <- 存放字体文件
-   |
-   +- js/ <- 存放bootstrap.js等   
-```
-这样我们在编写HTML的时候，可以直接用Bootstrap的CSS，像这样：
-```
-<link rel="stylesheet" href="/static/css/bootstrap.css">
-```
-现在，在使用MVC之前，第一个问题来了，如何处理静态文件？
-
-我们把所有静态资源文件全部放入/static目录，目的就是能统一处理静态文件。在koa中，我们需要编写一个middleware，处理以/static/开头的URL。
-
-## 编写middleware
-我们来编写一个处理静态文件的middleware。编写middleware实际上一点也不复杂。我们先创建一个static-files.js的文件，编写一个能处理静态文件的middleware：
-```
-const path = require('path');
-const mime = require('mime');
-const fs = require('mz/fs');
-
-// url: 类似 '/static/'
-// dir: 类似 __dirname + '/static'
-function staticFiles(url, dir) {
-    return async (ctx, next) => {
-        let rpath = ctx.request.path;
-        // 判断是否以指定的url开头:
-        if (rpath.startsWith(url)) {
-            // 获取文件完整路径:
-            let fp = path.join(dir, rpath.substring(url.length));
-            // 判断文件是否存在:
-            if (await fs.exists(fp)) {
-                // 查找文件的mime:
-                ctx.response.type = mime.lookup(rpath);
-                // 读取文件内容并赋值给response.body:
-                ctx.response.body = await fs.readFile(fp);
-            } else {
-                // 文件不存在:
-                ctx.response.status = 404;
-            }
-        } else {
-            // 不是指定前缀的URL，继续处理下一个middleware:
-            await next();
-        }
-    };
-}
-
-module.exports = staticFiles;
-```
-staticFiles是一个普通函数，它接收两个参数：URL前缀和一个目录，然后返回一个async函数。这个async函数会判断当前的URL是否以指定前缀开头，如果是，就把URL的路径视为文件，并发送文件内容。如果不是，这个async函数就不做任何事情，而是简单地调用await next()让下一个middleware去处理请求。
-
-我们使用了一个mz的包，并通过require('mz/fs');导入。mz提供的API和Node.js的fs模块完全相同，但fs模块使用回调，而mz封装了fs对应的函数，并改为Promise。这样，我们就可以非常简单的用await调用mz的函数，而不需要任何回调。
-
-所有的第三方包都可以通过npm官网搜索并查看其文档：
-```
-https://www.npmjs.com/
-```
-最后，这个middleware使用起来也很简单，在app.js里加一行代码：
-```
-let staticFiles = require('./static-files');
-app.use(staticFiles('/static/', __dirname + '/static'));
-```
-注意：也可以去npm搜索能用于koa2的处理静态文件的包并直接使用。
diff --git "a/33\347\211\233\346\226\207\350\275\251/20230310-\346\225\260\346\215\256\345\272\223.md" "b/33\347\211\233\346\226\207\350\275\251/20230310-\346\225\260\346\215\256\345\272\223.md"
deleted file mode 100644
index f7fea44ac4d8f6b29d5e836297d206276061bf0f..0000000000000000000000000000000000000000
--- "a/33\347\211\233\346\226\207\350\275\251/20230310-\346\225\260\346\215\256\345\272\223.md"
+++ /dev/null
@@ -1,82 +0,0 @@
-# 使用Sequelize
-
-## 安装
-Sequelize 的使用可以通过 npm (或 yarn).
-```
-# 使用 npm
-npm i sequelize # 这将安装最新版本的 Sequelize
-# 使用 yarn
-yarn add sequelize
-```
-你还必须手动为所选数据库安装驱动程序：
-```
-# 使用 npm
-npm i pg pg-hstore # PostgreSQL
-npm i mysql2 # MySQL
-npm i mariadb # MariaDB
-npm i sqlite3 # SQLite
-npm i tedious # Microsoft SQL Server
-npm i ibm_db # DB2
-# 使用 yarn
-yarn add pg pg-hstore # PostgreSQL
-yarn add mysql2 # MySQL
-yarn add mariadb # MariaDB
-yarn add sqlite3 # SQLite
-yarn add tedious # Microsoft SQL Server
-yarn add ibm_db # DB2
-```
-
-## 连接到数据库
-要连接到数据库,必须创建一个 Sequelize 实例. 这可以通过将连接参数分别传递到 Sequelize 构造函数或通过传递一个连接 URI 来完成：
-```
-const { Sequelize } = require('sequelize');
-
-// 方法 1: 传递一个连接 URI
-const sequelize = new Sequelize('sqlite::memory:') // Sqlite 示例
-const sequelize = new Sequelize('postgres://user:pass@example.com:5432/dbname') // Postgres 示例
-
-// 方法 2: 分别传递参数 (sqlite)
-const sequelize = new Sequelize({
-  dialect: 'sqlite',
-  storage: 'path/to/database.sqlite'
-});
-
-// 方法 3: 分别传递参数 (其它数据库)
-const sequelize = new Sequelize('database', 'username', 'password', {
-  host: 'localhost',
-  dialect: /* 选择 'mysql' | 'mariadb' | 'postgres' | 'mssql' 其一 */
-});
-```
-## 测试连接
-你可以使用 .authenticate() 函数测试连接是否正常：
-```
-try {
-  await sequelize.authenticate();
-  console.log('Connection has been established successfully.');
-} catch (error) {
-  console.error('Unable to connect to the database:', error);
-}
-```
-
-## 使用 sequelize.define:
-```
-const { Sequelize, DataTypes } = require('sequelize');
-const sequelize = new Sequelize('sqlite::memory:');
-
-const User = sequelize.define('User', {
-  // 在这里定义模型属性
-  firstName: {
-    type: DataTypes.STRING,
-    allowNull: false
-  },
-  lastName: {
-    type: DataTypes.STRING
-    // allowNull 默认为 true
-  }
-}, {
-  // 这是其他模型参数
-});
-
-// `sequelize.define` 会返回模型
-console.log(User === sequelize.models.User); // true
-```
\ No newline at end of file
diff --git "a/47\346\235\216\345\201\245/.keep" "b/47\346\235\216\345\201\245/.keep"
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000