开源地址：https://github.com/bfirsh/jsnes

一、简介：

Jsnes是一个用 JavaScript 实现的 NES 模拟器；这是一个可以在浏览器和 Node.js 中使用的库，浏览器的用户界面可以在 https://github.com/bfirsh/jsnes-web 中找到。

二、Installation 安装
1.  对于 Node.js 或 Webpack:

$ npm install jsnes

或者使用

$ yarn add jsnes

2.在浏览器中，你可以使用 unpkg:

<script type="text/javascript" src="https://unpkg.com/jsnes/dist/jsnes.min.js"></script>

三、Usage 用法

// Initialize and set up outputs

var nes = new jsnes.NES({

  onFrame: function(frameBuffer) {

    // ... write frameBuffer to screen

  },

  onAudioSample: function(left, right) {

    // ... play audio sample

  }

});



// Read ROM data from disk (using Node.js APIs, for the sake of this example)

const fs = require('fs');

var romData = fs.readFileSync('path/to/rom.nes', {encoding: 'binary'});



// Load ROM data as a string or byte array

nes.loadROM(romData);



// Run frames at 60 fps, or as fast as you can.

// You are responsible for reliable timing as best you can on your platform.

nes.frame();

nes.frame();

// ...



// Hook up whatever input device you have to the controller.

nes.buttonDown(1, jsnes.Controller.BUTTON_A);

nes.frame();

nes.buttonUp(1, jsnes.Controller.BUTTON_A);

nes.frame();

// ...

四、Build 构建

如果想要构建好一个发布版，可以执行：

$ yarn run build

（这会在目录下创建 dist/jsnes.min.js  文件）

五、Running tests 运行测试

$ yarn test

六、以下是演示链接，兼容PC端、移动端：

http://fc.255615.cn/

Redis的作者Salvatore Sanfilippo曾经对这两种基于内存的数据存储系统进行过比较：

1 Redis支持服务器端的数据操作：Redis相比Memcached来说，拥有更多的数据结构和并支持更丰富的数据操作，通常在Memcached里，你需要将数据拿到客户端来进行类似的修改再set回去。这大大增加了网络IO的次数和数据体积。

在Redis中，这些复杂的操作通常和一般的GET/SET一样高效。所以，如果需要缓存能够支持更复杂的结构和操作，那么Redis会是不错的选择。

2 内存使用效率对比：使用简单的key-value存储的话，Memcached的内存利用率更高，而如果Redis采用hash结构来做key-value存储，由于其组合式的压缩，其内存利用率会高于Memcached。

3 性能对比：由于Redis只使用单核，而Memcached可以使用多核，所以平均每一个核上Redis在存储小数据时比Memcached性能更高。

而在100k以上的数据中，Memcached性能要高于Redis，虽然Redis最近也在存储大数据的性能上进行优化，但是比起Memcached，还是稍有逊色。

数据类型支持不同

与Memcached仅支持简单的key-value结构的数据记录不同，Redis支持的数据类型要丰富得多。

最为常用的数据类型主要由五种：String、Hash、List、Set和Sorted Set。Redis内部使用一个redisObject对象来表示所有的key和value。redisObject最主要的信息如图所示：

type代表一个value对象具体是何种数据类型，encoding是不同数据类型在redis内部的存储方式，比如：type=string代表value存储的是一个普通字符串，那么对应的encoding可以是raw或者是int，如果是int则代表实际redis内部是按数值型类存储和表示这个字符串的，当然前提是这个字符串本身可以用数值表示，比如:”123″ “456”这样的字符串。

只有打开了Redis的虚拟内存功能，vm字段字段才会真正的分配内存，该功能默认是关闭状态的。

String

1 常用命令：set/get/decr/incr/mget等；

2 应用场景：String是最常用的一种数据类型，普通的key/value存储都可以归为此类；

3 实现方式：String在redis内部存储默认就是一个字符串，被redisObject所引用，当遇到incr、decr等操作时会转成数值型进行计算，此时redisObject的encoding字段为int。

Hash

1 常用命令：hget/hset/hgetall等

2 应用场景：我们要存储一个用户信息对象数据，其中包括用户ID、用户姓名、年龄和生日，通过用户ID我们希望获取该用户的姓名或者年龄或者生日；

3 实现方式：Redis的Hash实际是内部存储的Value为一个HashMap，并提供了直接存取这个Map成员的接口。

如图所示，Key是用户ID, value是一个Map。这个Map的key是成员的属性名，value是属性值。

这样对数据的修改和存取都可以直接通过其内部Map的Key(Redis里称内部Map的key为field), 也就是通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据。

当前HashMap的实现有两种方式：当HashMap的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会采用真正的HashMap结构，这时对应的value的redisObject的encoding为zipmap，当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。

List

1常用命令：lpush/rpush/lpop/rpop/lrange等；

2 应用场景：Redis list的应用场景非常多，也是Redis最重要的数据结构之一，比如twitter的关注列表，粉丝列表等都可以用Redis的list结构来实现；

3 实现方式：Redis list的实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，Redis内部的很多实现，包括发送缓冲队列等也都是用的这个数据结构。

Set

1 常用命令：sadd/spop/smembers/sunion等；

2 应用场景：Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的；

3 实现方式：set 的内部实现是一个 value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的，这也是set能提供判断一个成员是否在集合内的原因。

这段时间面试官都挺忙的，频频出现在博客文章标题，虽然我不是特别想蹭热度，但是实在想不到好的标题了-。-，蹭蹭就蹭蹭 :)

事实上我在面试的时候确实被问到了这个问题，而且是一道在线 coding 的编程题，当时虽然思路正确，可惜最终也并不算完全答对

结束后花了一段时间整理了下思路，那么究竟该如何实现一个大文件上传，以及在上传中如何实现断点续传的功能呢？

本文将从零搭建前端和服务端，实现一个大文件上传和断点续传的 demo

前端：vue element-ui

服务端：nodejs

文章有误解的地方，欢迎指出，将在第一时间改正，有更好的实现方式希望留下你的评论

大文件上传

整体思路

前端

前端大文件上传网上的大部分文章已经给出了解决方案，核心是利用 Blob.prototype.slice 方法，和数组的 slice 方法相似，调用的 slice 方法可以返回原文件的某个切片

这样我们就可以根据预先设置好的切片最大数量将文件切分为一个个切片，然后借助 http 的可并发性，同时上传多个切片，这样从原本传一个大文件，变成了同时传多个小的文件切片，可以大大减少上传时间

另外由于是并发，传输到服务端的顺序可能会发生变化，所以我们还需要给每个切片记录顺序

服务端

服务端需要负责接受这些切片，并在接收到所有切片后合并切片

这里又引伸出两个问题

1. 何时合并切片，即切片什么时候传输完成
2. 如何合并切片

第一个问题需要前端进行配合，前端在每个切片中都携带切片最大数量的信息，当服务端接受到这个数量的切片时自动合并，也可以额外发一个请求主动通知服务端进行切片的合并

第二个问题，具体如何合并切片呢？这里可以使用 nodejs 的 api fs.appendFileSync，它可以同步地将数据追加到指定文件，也就是说，当服务端接受到所有切片后，先创建一个最终的文件，然后将所有切片逐步合并到这个文件中

talk is cheap,show me the code，接着我们用代码实现上面的思路

前端部分

前端使用 Vue 作为开发框架，对界面没有太大要求，原生也可以，考虑到美观使用 element-ui 作为 UI 框架

上传控件

首先创建选择文件的控件，监听 change 事件以及上传按钮。“vue”:

<template>
   <div>
    <input type="file" @change="handleFileChange" />
    <el-button @click="handleUpload">上传</el-button>
  </div>
</template>

<script>
export default {
  data: () => ({
    container: {
      file: null
    }
  }),
  methods: {
     handleFileChange(e) {
      const [file] = e.target.files;
      if (!file) return;
      Object.assign(this.$data, this.$options.data());
      this.container.file = file;
    },
    async handleUpload() {}
  }
};
</script>

请求逻辑

考虑到通用性，这里没有用第三方的请求库，而是用原生 XMLHttpRequest 做一层简单的封装来发请求

request({
      url,
      method = "post",
      data,
      headers = {},
      requestList
    }) {
      return new Promise(resolve => {
        const xhr = new XMLHttpRequest();
        xhr.open(method, url);
        Object.keys(headers).forEach(key =>
          xhr.setRequestHeader(key, headers[key])
        );
        xhr.send(data);
        xhr.onload = e => {
          resolve({
            data: e.target.response
          });
        };
      });
    }

上传切片

接着实现比较重要的上传功能，上传需要做两件事

• 对文件进行切片
• 将切片传输给服务端

"diff":
<template>
  <div>
    <input type="file" @change="handleFileChange" />
    <el-button @click="handleUpload">上传</el-button>
  </div>
</template>

<script>
+ const LENGTH = 10; // 切片数量

export default {
  data: () => ({
    container: {
      file: null,
+     data: []
    }
  }),
  methods: {
    request() {},
    handleFileChange() {},
+    // 生成文件切片
+    createFileChunk(file, length = LENGTH) {
+      const fileChunkList = [];
+      const chunkSize = Math.ceil(file.size / length);
+      let cur = 0;
+      while (cur < file.size) {
+        fileChunkList.push({ file: file.slice(cur, cur + chunkSize) });
+        cur += chunkSize;
+      }
+      return fileChunkList;
+    },
+   // 上传切片
+    async uploadChunks() {
+      const requestList = this.data
+        .map(({ chunk，hash }) => {
+          const formData = new FormData();
+          formData.append("chunk", chunk);
+    formData.append("hash", hash);
+          formData.append("filename", this.container.file.name);
+          return { formData };
+        })
+        .map(async ({ formData }) =>
+          this.request({
+            url: "http://localhost:3000",
+            data: formData
+          })
+        );
+      await Promise.all(requestList); // 并发切片
+    },
+    async handleUpload() {
+      if (!this.container.file) return;
+      const fileChunkList = this.createFileChunk(this.container.file);
+      this.data = fileChunkList.map(({ file }，index) => ({
+        chunk: file,
+        hash: this.container.file.name + "-" + index // 文件名 + 数组下标
+      }));
+      await this.uploadChunks();
+    }
  }
};
</script>

当点击上传按钮时，调用 createFileChunk 将文件切片，切片数量通过一个常量 Length 控制，这里设置为 10，即将文件分成 10 个切片上传

createFileChunk 内使用 while 循环和 slice 方法将切片放入 fileChunkList 数组中返回

在生成文件切片时，需要给每个切片一个标识作为 hash，这里暂时使用文件名 + 下标，这样后端可以知道当前切片是第几个切片，用于之后的合并切片

随后调用 uploadChunks 上传所有的文件切片，将文件切片，切片 hash，以及文件名放入 FormData 中，再调用上一步的 request 函数返回一个 proimise，最后调用 Promise.all 并发上传所有的切片

发送合并请求

这里使用整体思路中提到的第二种合并切片的方式，即前端主动通知服务端进行合并，所以前端还需要额外发请求，服务端接受到这个请求时主动合并切片"diff":

<template>
  <div>
    <input type="file" @change="handleFileChange" />
    <el-button @click="handleUpload">上传</el-button>
  </div>
</template>

<script>
export default {
  data: () => ({
    container: {
      file: null
    },
    data: []
  }),
  methods: {
    request() {},
    handleFileChange() {},
    createFileChunk() {},
    // 上传切片，同时过滤已上传的切片
    async uploadChunks() {
      const requestList = this.data
        .map(({ chunk，hash }) => {
          const formData = new FormData();
          formData.append("chunk", chunk);
          formData.append("hash", hash);
          formData.append("filename", this.container.file.name);
          return { formData };
        })
        .map(async ({ formData }) =>
          this.request({
            url: "http://localhost:3000",
            data: formData
          })
        );
      await Promise.all(requestList);
+      // 合并切片
+     await this.mergeRequest();
    },
+    async mergeRequest() {
+      await this.request({
+        url: "http://localhost:3000/merge",
+        headers: {
+          "content-type": "application/json"
+        },
+        data: JSON.stringify({
+          filename: this.container.file.name
+        })
+      });
+    },    
    async handleUpload() {}
  }
};
</script>

服务端部分

简单使用 http 模块搭建服务端

const http = require("http");
const server = http.createServer();

server.on("request", async (req, res) => {
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Headers", "*");
  if (req.method === "OPTIONS") {
    res.status = 200;
    res.end();
    return;
  }
});

server.listen(3000, () => console.log("正在监听 3000 端口"));

 

接受切片

使用 multiparty 包处理前端传来的 FormData

在 multiparty.parse 的回调中，files 参数保存了 FormData 中文件，fields 参数保存了 FormData 中非文件的字段

const http = require("http");
const path = require("path");
const fse = require("fs-extra");
const multiparty = require("multiparty");

const server = http.createServer();
+ const UPLOAD_DIR = path.resolve(__dirname, "..", "target"); // 大文件存储目录

server.on("request", async (req, res) => {
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Headers", "*");
  if (req.method === "OPTIONS") {
    res.status = 200;
    res.end();
    return;
  }

+  const multipart = new multiparty.Form();

+  multipart.parse(req, async (err, fields, files) => {
+    if (err) {
+      return;
+    }
+    const [chunk] = files.chunk;
+    const [hash] = fields.hash;
+    const [filename] = fields.filename;
+    const chunkDir = `${UPLOAD_DIR}/${filename}`;

+   // 切片目录不存在，创建切片目录
+    if (!fse.existsSync(chunkDir)) {
+      await fse.mkdirs(chunkDir);
+    }

+      // fs-extra 专用方法，类似 fs.rename 并且跨平台
+      // fs-extra 的 rename 方法 windows 平台会有权限问题
+      // https://github.com/meteor/meteor/issues/7852#issuecomment-255767835
+      await fse.move(chunk.path, `${chunkDir}/${hash}`);
+    res.end("received file chunk");
+  });
});

server.listen(3000, () => console.log("正在监听 3000 端口")); 

查看 multiparty 处理后的 chunk 对象，path 是存储临时文件的路径，size 是临时文件大小，在 multiparty 文档中提到可以使用 fs.rename(由于我用的是 fs-extra，它的 rename 方法 windows 平台权限问题，所以换成了 fse.move) 移动临时文件，即移动文件切片

在接受文件切片时，需要先创建存储切片的文件夹，由于前端在发送每个切片时额外携带了唯一值 hash，所以以 hash 作为文件名，将切片从临时路径移动切片文件夹中，最后的结果如下

合并切片

在接收到前端发送的合并请求后，服务端将文件夹下的所有切片进行合并。

“diff”：
const http = require("http");
const path = require("path");
const fse = require("fs-extra");

const server = http.createServer();
const UPLOAD_DIR = path.resolve(__dirname, "..", "target"); // 大文件存储目录

+ const resolvePost = req =>
+   new Promise(resolve => {
+     let chunk = "";
+     req.on("data", data => {
+       chunk += data;
+     });
+     req.on("end", () => {
+       resolve(JSON.parse(chunk));
+     });
+   });

+ // 合并切片
+ const mergeFileChunk = async (filePath, filename) => {
+   const chunkDir = `${UPLOAD_DIR}/${filename}`;
+   const chunkPaths = await fse.readdir(chunkDir);
+   await fse.writeFile(filePath, "");
+   chunkPaths.forEach(chunkPath => {
+     fse.appendFileSync(filePath, fse.readFileSync(`${chunkDir}/${chunkPath}`));
+     fse.unlinkSync(`${chunkDir}/${chunkPath}`);
+   });
+   fse.rmdirSync(chunkDir); // 合并后删除保存切片的目录
+ };

server.on("request", async (req, res) => {
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Headers", "*");
  if (req.method === "OPTIONS") {
    res.status = 200;
    res.end();
    return;
  }

+   if (req.url === "/merge") {
+     const data = await resolvePost(req);
+     const { filename } = data;
+     const filePath = `${UPLOAD_DIR}/${filename}`;
+     await mergeFileChunk(filePath, filename);
+     res.end(
+       JSON.stringify({
+         code: 0,
+         message: "file merged success"
+       })
+     );
+   }

});

server.listen(3000, () => console.log("正在监听 3000 端口")); 

由于前端在发送合并请求时会携带文件名，服务端根据文件名可以找到上一步创建的切片文件夹

接着使用 fs.writeFileSync 先创建一个空文件，这个空文件的文件名就是切片文件夹名 + 后缀名组合而成，随后通过 fs.appendFileSync 从切片文件夹中不断将切片合并到空文件中，每次合并完成后删除这个切片，等所有切片都合并完毕后最后删除切片文件夹

至此一个简单的大文件上传就完成了，接下来我们再此基础上扩展一些额外的功能

显示上传进度条

上传进度分两种，一个是每个切片的上传进度，另一个是整个文件的上传进度，而整个文件的上传进度是基于每个切片上传进度计算而来，所以我们先实现切片的上传进度

切片进度条

XMLHttpRequest 原生支持上传进度的监听，只需要监听 upload.onprogress 即可，我们在原来的 request 基础上传入 onProgress 参数，给 XMLHttpRequest 注册监听事件。

“diff”：
 // xhr
    request({
      url,
      method = "post",
      data,
      headers = {},
+      onProgress = e => e,
      requestList
    }) {
      return new Promise(resolve => {
        const xhr = new XMLHttpRequest();
+       xhr.upload.onprogress = onProgress;
        xhr.open(method, url);
        Object.keys(headers).forEach(key =>
          xhr.setRequestHeader(key, headers[key])
        );
        xhr.send(data);
        xhr.onload = e => {
          resolve({
            data: e.target.response
          });
        };
      });
    } 

由于每个切片都需要触发独立的监听事件，所以还需要一个工厂函数，根据传入的切片返回不同的监听函数

在原先的前端上传逻辑中新增监听函数部分。

“diff”：
    // 上传切片，同时过滤已上传的切片
    async uploadChunks(uploadedList = []) {
      const requestList = this.data
+       .map(({ chunk,hash,index }) => {
          const formData = new FormData();
          formData.append("chunk", chunk);
          formData.append("hash", hash);
          formData.append("filename", this.container.file.name);
+         return { formData,index };
        })
+       .map(async ({ formData,index }) =>
          this.request({
            url: "http://localhost:3000",
            data: formData，
+           onProgress: this.createProgressHandler(this.data[index]),
          })
        );
      await Promise.all(requestList);
       // 合并切片
      await this.mergeRequest();
    },
    async handleUpload() {
      if (!this.container.file) return;
      const fileChunkList = this.createFileChunk(this.container.file);
      this.data = fileChunkList.map(({ file }，index) => ({
        chunk: file,
+       index,
        hash: this.container.file.name + "-" + index
+       percentage:0
      }));
      await this.uploadChunks();
    }    
+   createProgressHandler(item) {
+      return e => {
+        item.percentage = parseInt(String((e.loaded / e.total) * 100));
+      };
+    } 

每个切片在上传时都会通过监听函数更新 data 数组对应元素的 percentage 属性，之后把将 data 数组放到视图中展示即可

文件进度条

将每个切片已上传的部分累加，除以整个文件的大小，就能得出当前文件的上传进度，所以这里使用 Vue 计算属性

  computed: {
       uploadPercentage() {
          if (!this.container.file || !this.data.length) return 0;
          const loaded = this.data
            .map(item => item.size * item.percentage)
            .reduce((acc, cur) => acc + cur);
          return parseInt((loaded / this.container.file.size).toFixed(2));
        }
 } 

最终视图如下

断点续传

断点续传的原理在于前端/服务端需要记住已上传的切片，这样下次上传就可以跳过之前已上传的部分，有两种方案实现记忆的功能

• 前端使用 localStorage 记录已上传的切片 hash
• 服务端保存已上传的切片 hash，前端每次上传前向服务端获取已上传的切片

第一种是前端的解决方案，第二种是服务端，而前端方案有一个缺陷，如果换了个浏览器就失去了记忆的效果，所以这里选取后者

生成 hash

无论是前端还是服务端，都必须要生成文件和切片的 hash，之前我们使用文件名 + 切片下标作为切片 hash，这样做文件名一旦修改就失去了效果，而事实上只要文件内容不变，hash 就不应该变化，所以正确的做法是根据文件内容生成 hash，所以我们修改一下 hash 的生成规则

这里用到另一个库 spark-md5，它可以根据文件内容计算出文件的 hash 值，另外考虑到如果上传一个超大文件，读取文件内容计算 hash 是非常耗费时间的，并且会引起 UI 的阻塞，导致页面假死状态，所以我们使用 web-worker 在 worker 线程计算 hash，这样用户仍可以在主界面正常的交互

由于实例化 web-worker 时，参数是一个 js 文件路径且不能跨域，所以我们单独创建一个 hash.js 文件放在 public 目录下，另外在 worker 中也是不允许访问 dom 的，但它提供了importScripts 函数用于导入外部脚本，通过它导入 spark-md5

// /public/hash.js
self.importScripts("/spark-md5.min.js"); // 导入脚本

// 生成文件 hash
self.onmessage = e => {
  const { fileChunkList } = e.data;
  const spark = new self.SparkMD5.ArrayBuffer();
  let percentage = 0;
  let count = 0;
  const loadNext = index => {
    const reader = new FileReader();
    reader.readAsArrayBuffer(fileChunkList[index].file);
    reader.onload = e => {
      count++;
      spark.append(e.target.result);
      if (count === fileChunkList.length) {
        self.postMessage({
          percentage: 100,
          hash: spark.end()
        });
        self.close();
      } else {
        percentage += 100 / fileChunkList.length;
        self.postMessage({
          percentage
        });
        // 递归计算下一个切片
        loadNext(count);
      }
    };
  };
  loadNext(0);
};

 

在 worker 线程中，接受文件切片 fileChunkList，利用 FileReader 读取每个切片的 ArrayBuffer 并不断传入 spark-md5 中，每计算完一个切片通过 postMessage 向主线程发送一个进度事件，全部完成后将最终的 hash 发送给主线程

spark-md5 需要根据所有切片才能算出一个 hash 值，不能直接将整个文件放入计算，否则即使不同文件也会有相同的 hash，具体可以看官方文档

spark-md5

接着编写主线程与 worker 线程通讯的逻辑。

“diff”：
+    // 生成文件 hash（web-worker）
+    calculateHash(fileChunkList) {
+      return new Promise(resolve => {
+       // 添加 worker 属性
+        this.container.worker = new Worker("/hash.js");
+        this.container.worker.postMessage({ fileChunkList });
+        this.container.worker.onmessage = e => {
+          const { percentage, hash } = e.data;
+          this.hashPercentage = percentage;
+          if (hash) {
+            resolve(hash);
+          }
+        };
+      });
    },
    async handleUpload() {
      if (!this.container.file) return;
      const fileChunkList = this.createFileChunk(this.container.file);
+     this.container.hash = await this.calculateHash(fileChunkList);
      this.data = fileChunkList.map(({ file }，index) => ({
+       fileHash: this.container.hash,
        chunk: file,
        hash: this.container.file.name + "-" + index, // 文件名 + 数组下标
        percentage:0
      }));
      await this.uploadChunks();
    }  

主线程使用 postMessage 给 worker 线程传入所有切片 fileChunkList，并监听 worker 线程发出的 postMessage 事件拿到文件 hash

加上显示计算 hash 的进度条，看起来像这样

至此前端需要将之前用文件名作为 hash 的地方改写为 workder 返回的这个 hash

服务端则使用 hash 作为切片文件夹名，hash + 下标作为切片名，hash + 扩展名作为文件名，没有新增的逻辑

文件秒传

在实现断点续传前先简单介绍一下文件秒传

所谓的文件秒传，即在服务端已经存在了上传的资源，所以当用户再次上传时会直接提示上传成功

文件秒传需要依赖上一步生成的 hash，即在上传前，先计算出文件 hash，并把 hash 发送给服务端进行验证，由于 hash 的唯一性，所以一旦服务端能找到 hash 相同的文件，则直接返回上传成功的信息即可。

“diff”：
+    async verifyUpload(filename, fileHash) {
+       const { data } = await this.request({
+         url: "http://localhost:3000/verify",
+         headers: {
+           "content-type": "application/json"
+         },
+         data: JSON.stringify({
+           filename,
+           fileHash
+         })
+       });
+       return JSON.parse(data);
+     },
   async handleUpload() {
      if (!this.container.file) return;
      const fileChunkList = this.createFileChunk(this.container.file);
      this.container.hash = await this.calculateHash(fileChunkList);
+     const { shouldUpload } = await this.verifyUpload(
+       this.container.file.name,
+       this.container.hash
+     );
+     if (!shouldUpload) {
+       this.$message.success("秒传：上传成功");
+       return;
+    }
     this.data = fileChunkList.map(({ file }, index) => ({
        fileHash: this.container.hash,
        index,
        hash: this.container.hash + "-" + index,
        chunk: file,
        percentage: 0
      }));
      await this.uploadChunks();
    }  

秒传其实就是给用户看的障眼法，实质上根本没有上传

:)

服务端的逻辑非常简单，新增一个验证接口，验证文件是否存在即可。

“diff”：
+ const extractExt = filename =>
+  filename.slice(filename.lastIndexOf("."), filename.length); // 提取后缀名
const UPLOAD_DIR = path.resolve(__dirname, "..", "target"); // 大文件存储目录

const resolvePost = req =>
  new Promise(resolve => {
    let chunk = "";
    req.on("data", data => {
      chunk += data;
    });
    req.on("end", () => {
      resolve(JSON.parse(chunk));
    });
  });

server.on("request", async (req, res) => {
  if (req.url === "/verify") {
+    const data = await resolvePost(req);
+    const { fileHash, filename } = data;
+    const ext = extractExt(filename);
+    const filePath = `${UPLOAD_DIR}/${fileHash}${ext}`;
+    if (fse.existsSync(filePath)) {
+      res.end(
+        JSON.stringify({
+          shouldUpload: false
+        })
+      );
+    } else {
+      res.end(
+        JSON.stringify({
+          shouldUpload: true
+        })
+      );
+    }
  }
});
server.listen(3000, () => console.log("正在监听 3000 端口"));

暂停上传

讲完了生成 hash 和文件秒传，回到断点续传

断点续传顾名思义即断点 + 续传，所以我们第一步先实现“断点”，也就是暂停上传

原理是使用 XMLHttpRequest 的 abort 方法，可以取消一个 xhr 请求的发送，为此我们需要将上传每个切片的 xhr 对象保存起来，我们再改造一下 request 方法。

“diff”：
   request({
      url,
      method = "post",
      data,
      headers = {},
      onProgress = e => e,
+     requestList
    }) {
      return new Promise(resolve => {
        const xhr = new XMLHttpRequest();
        xhr.upload.onprogress = onProgress;
        xhr.open(method, url);
        Object.keys(headers).forEach(key =>
          xhr.setRequestHeader(key, headers[key])
        );
        xhr.send(data);
        xhr.onload = e => {
+          // 将请求成功的 xhr 从列表中删除
+          if (requestList) {
+            const xhrIndex = requestList.findIndex(item => item === xhr);
+            requestList.splice(xhrIndex, 1);
+          }
          resolve({
            data: e.target.response
          });
        };
+        // 暴露当前 xhr 给外部
+        requestList?.push(xhr);
      });
    },

这样在上传切片时传入 requestList 数组作为参数，request 方法就会将所有的 xhr 保存在数组中了

每当一个切片上传成功时，将对应的 xhr 从 requestList 中删除，所以 requestList 中只保存正在上传切片的 xhr

之后新建一个暂停按钮，当点击按钮时，调用保存在 requestList 中 xhr 的 abort 方法，即取消并清空所有正在上传的切片

 handlePause() {
    this.requestList.forEach(xhr => xhr?.abort());
    this.requestList = [];
} 

点击暂停按钮可以看到 xhr 都被取消了

恢复上传

之前在介绍断点续传的时提到使用第二种服务端存储的方式实现续传

由于当文件切片上传后，服务端会建立一个文件夹存储所有上传的切片，所以每次前端上传前可以调用一个接口，服务端将已上传的切片的切片名返回，前端再跳过这些已经上传切片，这样就实现了“续传”的效果

而这个接口可以和之前秒传的验证接口合并，前端每次上传前发送一个验证的请求，返回两种结果

• 服务端已存在该文件，不需要再次上传
• 服务端不存在该文件或者已上传部分文件切片，通知前端进行上传，并把已上传的文件切片返回给前端

所以我们改造一下之前文件秒传的服务端验证接口。

const extractExt = filename =>
  filename.slice(filename.lastIndexOf("."), filename.length); // 提取后缀名
const UPLOAD_DIR = path.resolve(__dirname, "..", "target"); // 大文件存储目录

const resolvePost = req =>
  new Promise(resolve => {
    let chunk = "";
    req.on("data", data => {
      chunk += data;
    });
    req.on("end", () => {
      resolve(JSON.parse(chunk));
    });
  });
  
+  // 返回已经上传切片名列表
+ const createUploadedList = async fileHash =>
+   fse.existsSync(`${UPLOAD_DIR}/${fileHash}`)
+    ? await fse.readdir(`${UPLOAD_DIR}/${fileHash}`)
+    : [];

server.on("request", async (req, res) => {
  if (req.url === "/verify") {
    const data = await resolvePost(req);
    const { fileHash, filename } = data;
    const ext = extractExt(filename);
    const filePath = `${UPLOAD_DIR}/${fileHash}${ext}`;
    if (fse.existsSync(filePath)) {
      res.end(
        JSON.stringify({
          shouldUpload: false
        })
      );
    } else {
      res.end(
        JSON.stringify({
          shouldUpload: true，
+         uploadedList: await createUploadedList(fileHash)
        })
      );
    }
  }
});
server.listen(3000, () => console.log("正在监听 3000 端口"));

接着回到前端，前端有两个地方需要调用验证的接口

• 点击上传时，检查是否需要上传和已上传的切片
• 点击暂停后的恢复上传，返回已上传的切片

新增恢复按钮并改造原来上传切片的逻辑。

“diff”：
<template>
  <div id="app">
      <input
        type="file"
        @change="handleFileChange"
      />
       <el-button @click="handleUpload">上传</el-button>
       <el-button @click="handlePause" v-if="isPaused">暂停</el-button>
+      <el-button @click="handleResume" v-else>恢复</el-button>
      //...
    </div>
</template>

+   async handleResume() {
+      const { uploadedList } = await this.verifyUpload(
+        this.container.file.name,
+        this.container.hash
+      );
+      await this.uploadChunks(uploadedList);
    },
    async handleUpload() {
      if (!this.container.file) return;
      const fileChunkList = this.createFileChunk(this.container.file);
      this.container.hash = await this.calculateHash(fileChunkList);

+     const { shouldUpload, uploadedList } = await this.verifyUpload(
        this.container.file.name,
        this.container.hash
      );
      if (!shouldUpload) {
        this.$message.success("秒传：上传成功");
        return;
      }

      this.data = fileChunkList.map(({ file }, index) => ({
        fileHash: this.container.hash,
        index,
        hash: this.container.hash + "-" + index,
        chunk: file，
        percentage: 0
      }));

+      await this.uploadChunks(uploadedList);
    },
   // 上传切片，同时过滤已上传的切片
+   async uploadChunks(uploadedList = []) {
      const requestList = this.data
+        .filter(({ hash }) => !uploadedList.includes(hash))
        .map(({ chunk, hash, index }) => {
          const formData = new FormData();
          formData.append("chunk", chunk);
          formData.append("hash", hash);
          formData.append("filename", this.container.file.name);
          formData.append("fileHash", this.container.hash);
          return { formData, index };
        })
        .map(async ({ formData, index }) =>
          this.request({
            url: "http://localhost:3000",
            data: formData,
            onProgress: this.createProgressHandler(this.data[index]),
            requestList: this.requestList
          })
        );
      await Promise.all(requestList);
      // 之前上传的切片数量 + 本次上传的切片数量 = 所有切片数量时
      // 合并切片
+      if (uploadedList.length + requestList.length === this.data.length) {
         await this.mergeRequest();
+      }
    }

这里给原来上传切片的函数新增 uploadedList 参数，即上图中服务端返回的切片名列表，通过 filter 过滤掉已上传的切片，并且由于新增了已上传的部分，所以之前合并接口的触发条件做了一些改动

到这里断点续传的功能基本完成了

进度条改进

虽然实现了断点续传，但还需要修改一下进度条的显示规则，否则在暂停上传/接收到已上传切片时的进度条会出现偏差

切片进度条

由于在点击上传/恢复上传时，会调用验证接口返回已上传的切片，所以需要将已上传切片的进度变成 100%。

“diff”：
   async handleUpload() {
      if (!this.container.file) return;
      const fileChunkList = this.createFileChunk(this.container.file);
      this.container.hash = await this.calculateHash(fileChunkList);
      const { shouldUpload, uploadedList } = await this.verifyUpload(
        this.container.file.name,
        this.container.hash
      );
      if (!shouldUpload) {
        this.$message.success("秒传：上传成功");
        return;
      }
      this.data = fileChunkList.map(({ file }, index) => ({
        fileHash: this.container.hash,
        index,
        hash: this.container.hash + "-" + index,
        chunk: file,
+       percentage: uploadedList.includes(index) ? 100 : 0
      }));
      await this.uploadChunks(uploadedList);
    }, 

uploadedList 会返回已上传的切片，在遍历所有切片时判断当前切片是否在已上传列表里即可

文件进度条

之前说到文件进度条是一个计算属性，根据所有切片的上传进度计算而来，这就遇到了一个问题

点击暂停会取消并清空切片的 xhr 请求，此时如果已经上传了一部分，就会发现文件进度条有倒退的现象

当点击恢复时，由于重新创建了 xhr 导致切片进度清零，所以总进度条就会倒退

解决方案是创建一个“假”的进度条，这个假进度条基于文件进度条，但只会停止和增加，然后给用户展示这个假的进度条

这里我们使用 Vue 的监听属性。

“diff”：
  data: () => ({
+    fakeUploadPercentage: 0
  }),
  computed: {
    uploadPercentage() {
      if (!this.container.file || !this.data.length) return 0;
      const loaded = this.data
        .map(item => item.size * item.percentage)
        .reduce((acc, cur) => acc + cur);
      return parseInt((loaded / this.container.file.size).toFixed(2));
    }
  },  
  watch: {
+    uploadPercentage(now) {
+      if (now > this.fakeUploadPercentage) {
+        this.fakeUploadPercentage = now;
+      }
    }
  },

当 uploadPercentage 即真的文件进度条增加时，fakeUploadPercentage 也增加，一旦文件进度条后退，假的进度条只需停止即可

至此一个大文件上传 + 断点续传的解决方案就完成了

总结

大文件上传

• 前端上传大文件时使用 Blob.prototype.slice 将文件切片，并发上传多个切片，最后发送一个合并的请求通知服务端合并切片
• 服务端接收切片并存储，收到合并请求后使用 fs.appendFileSync 对多个切片进行合并
• 原生 XMLHttpRequest 的 upload.onprogress 对切片上传进度的监听
• 使用 Vue 计算属性根据每个切片的进度算出整个文件的上传进度

断点续传

• 使用 spark-md5 根据文件内容算出文件 hash
• 通过 hash 可以判断服务端是否已经上传该文件，从而直接提示用户上传成功（秒传）
• 通过 XMLHttpRequest 的 abort 方法暂停切片的上传
• 上传前服务端返回已经上传的切片名，前端跳过这些切片的上传

反馈的问题

部分功能由于不方便测试，这里列出评论区收集到的一些问题

• 应使用文件大小切片，而并非文件数量
• 没有做切片上传失败的处理
• 使用 web socket 由服务端发送进度信息
• 打开页面没有自动获取上传切片，而需要主动再次上传一次后才显示

设计人：张钦颖

学号：1414080901218

一、      实验环境：

1、硬件环境：个人机，CPU主频：4.01Ghz  内存：16G

2、软件环境：操作系统：win10

编程语言：C++

二、      实验任务解决方案：

1、          Dijkstra最短路径算法的流程图。

（1）   创建一组sptSet（最短路径数组），它存的是已经在SPT里的节点，也就是这些是已经计算过的，确定的最小值，一开始这里是空的。

（2）   给所有的给定图中的节点一个指定的距离值。将所有的距离值初始化为无限，将源节点初始为0。

（3）   当另一个（保存未放入SPT的节点的那个）不为空时：

①  选择一个不在SPTset中一个离源点距离最小的节点

②  把它加入SPTset

③  更新所有于这个节点临近的节点的距离值。为了更距离值，遍历这个点所有的相邻点。对于每一个相邻的节点，如果这临近点u的距离值（从源节点开始的和）比v（新加入的）小，就把v的距离值更新

例如：

        一开始SPTset是空的，并且它初始化的距离值是{0，INF，INF，INF，INF，INF，INF，INF}，其中INF表示无限。现在选择最小距离值的顶点。我们选了节点0，将它加入到sptSet。所以sptSet变为{0}。加入0至sptSet后，更新其相邻顶点的距离值。0相邻的节点为1和6，他们的距离值便被更新成3和4。图中标示出在SPT的顶点显示为绿色。

        然后我们选择一个不包含在SPT里一个路径值为最小的一个节点，节点1被选了而且被加入到了sptSET，所以sptSET现在变为了{0,1}更新1临近节点的距离值，临近节点为2跟8，节点2跟8的距离值便变成了3+6=9、3+16=19。

        像上面一样选一个，我们选了节点6，加入到sptSet，所以sptSet变成了{0,1,6}，更新节点6的临近节点的距离值，临近节点是5和7，更新后5：4+20=24，7：4+10=14.

            然后我们再选一个2加入，sptSet又新来了一个数字2，2的临近节点3和8便更新为11和26.

一直重复这些事儿直到sptset包含所有的节点：

最后，我们终于得到了一棵完整的最短路径树

2、Dijkstra最短路径算法实现的关键代码。

#include <stdio.h>

#include <limits.h>

// Number of vertices in the graph

#define V 9

// A utility function to find the vertex with minimum distance value, from

// the set of vertices not yet included in shortest path tree

int minDistance(int dist[], bool sptSet[])

{

      // Initialize min value

      int min = INT_MAX, min_index;

      for (int v = 0; v < V; v++)

      if (sptSet[v] == false && dist[v] < min)

           min = dist[v], min_index = v;

      return min_index;

}

// A utility function to print the constructed distance array

void printSolution(int dist[], int n)

{

      printf("顶点\t\t距离源点的最短路径\n");

      for (int i = 0; i < V; i++)

           printf("%d \t\t%d\n", i, dist[i]);

}

// Funtion that implements Dijkstra's single source shortest path algorithm

// for a graph represented using adjacency matrix representation

void dijkstra(int graph[V][V], int src)

{

      int dist[V];     // The output array.  dist[i] will hold the shortest

      // distance from src to i

      bool sptSet[V]; // sptSet[i] will true if vertex i is included in shortest

      // path tree or shortest distance from src to i is finalized

      // Initialize all distances as INFINITE and stpSet[] as false

      for (int i = 0; i < V; i++)

           dist[i] = INT_MAX, sptSet[i] = false;

      // Distance of source vertex from itself is always 0

      dist[src] = 0;

      // Find shortest path for all vertices

      for (int count = 0; count < V - 1; count++)

      {

           // Pick the minimum distance vertex from the set of vertices not

           // yet processed. u is always equal to src in first iteration.

           int u = minDistance(dist, sptSet);

           // Mark the picked vertex as processed

           sptSet[u] = true;

           // Update dist value of the adjacent vertices of the picked vertex.

           for (int v = 0; v < V; v++)

                 // Update dist[v] only if distance to v is not in sptSet, there

                 // is an edge from u to v, and total weight of path from src to

                 // v through u is smaller than dist[v]

           if (!sptSet[v] && graph[u][v] && dist[u] + graph[u][v] < dist[v])

                 dist[v] = dist[u] + graph[u][v];

      }

      // print the constructed distance array

      printSolution(dist, V);

}

// driver program to test above function

int main()

{

      /* Let us create the example graph discussed above */

      int graph[V][V] = {

           { 0, 3, 0, 0, 0, 0, 4, 0, 0 },

           { 3, 0, 6, 0, 0, 0, 0, 0, 16 },

           { 0, 6, 0, 2, 0, 0, 0, 0, 17 },

           { 0, 0, 2, 0, 4, 0, 0, 0, 9 },

           { 0, 0, 0, 4, 0, 11, 0, 7, 0 },

           { 0, 0, 0, 0, 11, 0, 20, 0, 0 },

           { 4, 0, 0, 0, 0, 20, 0, 10, 0 },

           { 0, 0, 0, 0, 7, 0, 10, 0, 1 },

           { 0, 16, 17, 9, 0, 0, 0, 1, 0 }

      };

      dijkstra(graph, 0);

      return 0;

}

三、      Dijkstra最短路径算法的计算复杂度分析（最好、最差、平均情况复杂度）：

（1） 最好的情况：每个顶点第一次检测到就是路径值就是最短路径。复杂度最低。

复杂度为：2n²+6n

（2） 最坏情况：顶点被检测了1次以上，并且每次检测都更新路径值为最小，即每次找的都不是最短路径，直到最后一次检测。复杂度最高

复杂度为：3n²+6n

（3） 平均情况复杂度：时间复杂度为O(n²)

四、      总结综合实验心得体会：

本次的Dijkstra最短路径算法在数据结构的课程上也接触过，所以感觉这个不成问题，选用的例子是自己随手画出来的，然后按照Dijkstra最短路径算法把流程步骤分别画了出来。然后其他部分参考了一下wiki以及geek论坛等国外大神的论文。还有很多东西老师在课堂上也给我们又讲了一遍，所以从算法思想上就不成多大问题了，主要是代码，而且必须得了解了算法才能mark得出代码来，否则根本无从下手。

设计人：张钦颖

学号：1414080901218

一、      实验环境：

1、硬件环境：个人机，CPU主频：4.01Ghz     内存：16G

2、软件环境：操作系统：win10

                     编程语言：C++

二、      实验任务解决方案：

1、          矩阵变换算法的流程图。

实验原理：

设两个无向图G=（V，E），G'=（V'，E'），当且仅当两图的邻接矩阵、行间同或矩阵、行间异或矩阵具有相同的行行置换时GG '同构。

矩阵算法步骤：

（1） 根据定义求出同型矩阵。

（2） 计算出行间同或矩阵，行间异或矩阵。

（3） 以图G=（v，E）的行间异或矩阵为参照，对行间异或矩阵的每一行，从异或矩阵搜索所有行，找到一个匹配。

①、   若不匹配，则两图不同构；

②、   若匹配，则继续往下判断执行。

（4） 判断邻接矩阵、行间同或矩阵中是否存在同样的匹配。

      ①、  若匹配存在，调整邻接矩阵、行间异或矩阵、行间同或矩阵，对应的行和列。

      ②、  若不匹配，则两图不同构。

2、矩阵变换算法实现的关键代码。

//冒泡排序

void wensen_mp(int mp[],int n)

{

 int t;

 for(int i=0;i<n-1;i++)

 {

  for(int j=0;j<n-1-i;j++)

  {

   if(mp[j]>mp[j+1])

   {

    t=mp[j];

    mp[j]=mp[j+1];

    mp[j+1]=t;

   }

  }

 }

}

/////////////////////////核心代码

//异或矩阵行转换

void wensen_hx(int **p1,int **p13,int **p14,int **p2,int **p23,int **p24,int n)

{

 int *p77=new int[n];//用于替换的临时一维数组存放p13

 int *p88=new int[n];//用于替换的临时一维数组存放p23

 int *p33=new int[n];//用于替换的临时一维数组存放p1

 int *p44=new int[n];//用于替换的临时一维数组存放p14

 int *p55=new int[n];//用于替换的临时一维数组存放p2

 int *p66=new int[n];//用于替换的临时一维数组存放p24

 int *p99=new int[n];//用于行行替换的临时数组

 int t;

 int tt;//进行跳转判断

 int ttt=0;//进行跳转判断

 //行行替换

 for( int i=0;i<n;i++)

 {

  //首先进行行赋值给另外一个数组p13

  for(int i77=0;i77<n;i77++)

  {

   p77[i77]=p13[i][i77];

  }

  //首先进行行赋值给另外一个数组p1

  for(int i33=0;i33<n;i33++)

  {

   p33[i33]=p1[i][i33];

  }

  //首先进行行赋值给另外一个数组

  for(int i44=0;i44<n;i44++)

  {

   p44[i44]=p14[i][i44];

  }

  //p77,p33,p44冒泡排序

  wensen_mp(p77,n);

  wensen_mp(p33,n);

  wensen_mp(p44,n);

  //开始进行比较,p12的每一行与p23的每一行进行比较

  for(int y=i;y<n;y++)

  {

   tt=0;

    //首先进行行赋值给另外一个数组

   for(int i88=0;i88<n;i88++)

   {

    p88[i88]=p23[y][i88];

   }

    //首先进行行赋值给另外一个数组

   for(int i55=0;i55<n;i55++)

   {

    p55[i55]=p2[y][i55];

   }

     //首先进行行赋值给另外一个数组

   for(int i66=0;i66<n;i66++)

   {

    p66[i66]=p24[y][i66];

   }

   //p88,p55,p66冒泡排序

   wensen_mp(p88,n);

   wensen_mp(p55,n);

   wensen_mp(p66,n);

   //开始比较

   for(int a=0;a<n;a++)

   {

    if(p77[a]==p88[a])

    {

     tt=a;

     if(a==n-1)//也就是各个都相等,找到匹配

     {

      //开始进行邻接矩阵对应位置比较

      for(int b=0;b<n;b++)

      {

       if(p33[b]==p55[b])

         {

        continue;

       }

       else if(b<n-1)

       {

        cout<<"不同构\n";

        return;

       }

      }

      //开始进行同或矩阵

      for(int c=0;c<n;c++)

      {

       if(p44[c]==p66[c])

       {

        continue;

       }

       else if(c<n-1)

       {

        cout<<"不同构\n";

        return;

       }

      }

      ttt++;//表示成功匹配一行

      //进行行行转换p2

      for(int u1=0;u1<n;u1++)

      { 

       t=p2[i][u1];

       p2[i][u1]=p2[y][u1];

       p2[y][u1]=t;

      }

      for(int u11=0;u11<n;u11++)

      {

       t=p2[u11][i];

       p2[u11][i]=p2[u11][y];

       p2[u11][y]=t;

      }

       //进行行行转换p23

      for(int u2=0;u2<n;u2++)

      {

       t=p23[i][u2];

       p23[i][u2]=p23[y][u2];

       p23[y][u2]=t;

      }

      for(int u22=0;u22<n;u22++)

      {

       t=p23[u22][i];

       p23[u22][i]=p23[u22][y];

       p23[u22][y]=t;

      }

       //进行行行转换p24

      for(int u3=0;u3<n;u3++)

      {

       t=p24[i][u3];

       p24[i][u3]=p24[y][u3];

       p24[y][u3]=t;

      }

      for(int u33=0;u33<n;u33++)

      {

       t=p24[u33][i];

         p24[u33][i]=p24[u33][y];

       p24[u33][y]=t;

      }

     break;

     }

     else

     {

      continue;

     }

    }

    else if(y==n-1)//一直循环到最后都未找到匹配

    {

     cout<<"不同构\n";

     return;

    }

    else

    {   

     break;

    }

   }

   //上面的匹配没有问题则进行行替换

   if(tt==n-1)

   {

    if(ttt==n)

    {

           cout<<"同构\n";

           return;

    }

    else

    {

      break; //成功跳出循环判断下一行

    }

   }

  }

 }

}

三、矩阵变换算法的计算复杂度分析（最好、最差、平均情况复杂度）：

       （1） 最好情况：n²+5*3n+32=O(n²)

      （2） 最差情况：5n³+15*6n²+88*5n+18=O(n³)

      （3） 平均复杂度：O(n²)

四、总结综合实验心得体会：

       同构图我们课上讲过许多，利用暴力法识别同构图我们也上过课，但是基于矩阵变换算法的图同构识别我就不会。由于矩阵变换算法为什么能识别同构图一点都不了解，所以我查阅了很多资料，当且仅当两图的邻接矩阵、行间同或矩阵、行间异或矩阵具有相同的行行置换时两个图是同构图，所以利用该原理，查阅了资料参考着写了代码。最后把该实验做了出来。

下面补充各种矩阵的定义：

本实验主要简单介绍了Wireshark的使用，通过本实验可以掌握如何通过Wireshark抓取网络传输中的明文密码。

1.2实验环境

服务器配置：Windows xp + FileZilla Server ftp服务器

密码信息： ftp用户名/密码   root/roottoor      

1.3实验步骤

1.打开Wireshark，点击“ 列出可用的抓包接口“按钮，在弹出的对话框中，选择你正在使用的网卡，并点击Start开始抓包

2.打开cmd对话框，访问服务器x.x.x.x上的ftp服务，并输入正确的用户名和密码后，和服务器断开连接。

3.单击“停止”按钮停止抓包。

4. 由于我们知道ftp客户端首先与服务器的21端口建立连接并完成认证后再打开数据通道，所以我们只需要关注TCP 21端口的数据包即可。在过滤器中输入 “tcp.port==21”，即可以过滤出与tcp 21端口有关的所有数据包。如图所示。(按Enter键或点击Apply(应用)按钮使过滤规则生 效)

5.对任意一个FTP数据包右击选择“跟踪TCP码流”（Fllow TCP Stream），即可以在弹出的窗口中看到整个FTP控制通道的数据交互内容，从中可以看到我们登陆FTP服务器的明文用户名与密码。

        如果想要修改联系方式的可以自己在index.html中手动编辑成自己的联系方式哦！

分享码密码为：[cv]7zgr54p0[/cv]