第三：TCP/IP协议

一.TCP/IP协议是什么

1.TCP/IP是一组用于互联网通信的网络协议，它定义数据在网络中的传输方式和规则

2.作为前端工程师熟悉TCP/IP协议对于理解网络通信原理和调试网络问题非常重要

二.什么是TCP/IP协议

1.TCP/IP是网络通信协议，它由两个独立的协议组成TCP和IP
1.1.TCP/IP协议套件是互联网通信的基础，也是现代网络通信的标准

2.TCP/IP协议提供一种可靠的、端到端的数据传输方式
2.1.使得在不同计算机和网络之间的数据交换变得可能
2.2.它定义数据如何分割、传输、路由和重新组装
2.2.1.确保数据在网络中可靠地传输和交付

三.TCP/IP协议的主要组成部分

1.TCP/IP协议由多个层级组成，每个层级负责不同的功能和任务

2.物理层：定义网络硬件设备的电气和物理特性，它负责将比特流传输到物理介质上
2.1.例如网线、光纤和网络接口卡等

3.数据链路层：数据链路层负责在直接相连的节点之间传输数据
3.1.它将原始的比特流组织成数据帧，通过物理连接传输，并提供错误检测和纠正功能

4.网络层：网络层使用IP协议定义数据的传输路径和地址方案
4.1.它负责将数据分组（数据包）从源主机发送到目标主机
4.1.1.通过路由选择算法决定数据的最佳路径

5.传输层：传输层使用TCP或UDP协议提供端到端的数据传输服务
5.1.TCP协议提供可靠的、面向连接的数据传输，保证数据的有序性和可靠性
5.2.UDP协议提供无连接的数据传输，适用于实时性要求较高的场景

6.会话层：会话层负责建立、管理和终止网络会话
6.1.它定义不同主机之间的通信规则和会话控制机制

7.表示层：表示层处理数据的表示和转换，确保不同主机的数据格式能够互相理解

8.应用层：应用层是最靠近用户的一层，提供网络应用程序和用户交互的接口
8.1.包括各种网络协议，如HTTP、FTP、SMTP等，用于不同类型的数据传输和应用需求

应用层	HTTP、SMTP、SNMP、FTP、Telnet、SIP、SSH、NFS、RTSP、XMPP、Whois、ENRP等等
表示层	XDR、ASN.1、SMB、AFP、NCP等等
会话层	ASAP、SSH、RPC、NetBIOS、ASP、Winsock、BSD Sockets等等
传输层	TCP、UDP、TLS、RTP、SCTP、SPX、ATP、IL等等
网络层	IP、ICMP、IGMP、IPX、BGP、OSPF、RIP、IGRP、EIGRP、ARP、RARP、X.25等等
数据链路层	以太网、令牌环、HDLC、帧中继、ISDN、ATM、IEEE 802.11、FDDI、PPP等等
物理层	例如铜缆、网线、光缆、无线电等等

四.TCP/IP协议的工作原理

1.TCP/IP协议通过分层的方式进行工作，每个层级负责特定的功能
1.1.上层利用下层提供的服务实现数据的传输和交互

2.在数据传输过程中，发送方的应用程序将数据传递给应用层
2.1.然后逐层向下传递，每层在数据上添加相应的协议头信息

3.在接收方，每层根据协议头信息进行解析和处理，并将数据逐层向上传递给应用程序

五.三次握手过程

1.第一次握手：Client进入SYN_SENT状态，发送一个SYN帧来主动打开传输通道

1.1.该帧的SYN标志位被设置为1，同时会带上Client分配好的SN序列号

1.2.该SN是根据时间产生的一个随机值，通常情况下每间隔4ms会加1

1.3.除此之外，SYN帧还会带一个MSS（最大报文段长度）可选项的值
1.3.1.表示客户端发送出去的最大数据块的长度

2.第二次握手：Server端在收到SYN帧之后，会进入SYN_RCVD状态
2.1.同时返回SYN+ACK帧给Client

2.2.主要目的在于通知Client，Server端已经收到SYN消息，现在需要进行确认

2.3.Server端发出的SYN+ACK帧的ACK标志位被设置为1
2.3.1.其确认序号AN值被设置为Client的SN+1

2.4.SYN+ACK帧的SYN标志位被设置为1，SN值为Server端生成的SN序号

2.5.SYN+ACK帧的MSS（最大报文段长度）表示的是Server端的最大数据块长度

3.第三次握手：Client在收到Server的第二次握手SYN+ACK确认帧之后

3.1.首先将自己的状态会从SYN_SENT变成ESTABLISHED
3.1.1.表示自己方向的连接通道已经建立成功，Client可以发送数据给Server端

3.2.然后Client发ACK帧给Server端，该ACK帧的ACK标志位被设置为1
3.2.1.其确认序号AN值被设置为Server端的SN序列号+1

3.3.还有一种情况，Client可能会将ACK帧和第一帧要发送的数据
3.3.1.合并到一起发送给Server端

4.Server端在收到Client的ACK帧之后，会从SYN_RCVD状态会进入ESTABLISHED状态

4.1.至此，Server方向的通道连接建立成功，Server可以发送数据给Client
4.1.1.TCP的全双工连接建立完成

5.三次握手的交互过程：Client和Server完成三次握手后
5.1.双方就进入了数据传输的阶段

5.2.数据传输完成后，连接将断开，连接断开的过程需要经历四次挥手

六.TCP的四次挥手

1.业务数据通信完成之后，TCP连接开始断开（或者拆接）的过程

1.1.在这个过程中连接的每个端的都能独立地、主动的发起，断开的过程TCP协议使用了四路挥手操作

七.四次挥手过程

1.第一次挥手：主动断开方（可以是客户端，也可以是服务器端）

1.1.向对方发送一个FIN结束请求报文，此报文的FIN位被设置为1
1.1.1.并且正确设置SN（序列号）和AN（确认号）

1.2.发送完成后，主动断开方进入FIN_WAIT_1状态
1.2.1.这表示主动断开方没有业务数据要发送给对方，准备关闭SOCKET连接

2.第二次挥手：在收到主动断开方发送的FIN断开请求报文后

2.1.被动断开方会发送一个ACK响应报文，报文的AN值为断开请求报文的SN加1

2.2.该ACK确认报文的含义是：我同意你的连接断开请求
2.2.1.之后，被动断开方就进入CLOSE-WAIT（关闭等待）状态

2.3.TCP协议服务会通知高层的应用进程，对方向本地方向的连接已经关闭

2.4.对方已经没有数据要发送，若本地还要发送数据给对方，对方依然会接受
2.5.被动断开方的CLOSE-WAIT（关闭等待）还要持续一段时间
2.5.1.也就是整个CLOSE-WAIT状态持续的时间

2.6.主动断开方在收到了ACK报文后，由FIN_WAIT_1转换成FIN_WAIT_2状态

3.第三次挥手：在发送完成ACK报文后，被动断开方还可以继续完成业务数据的发送
3.1.待剩余数据发送完成后

3.1.或者CLOSE-WAIT（关闭等待）截止后
3.1.1.被动断开方会向主动断开方发送FIN+ACK结束响应报文
3.1.2.表示被动断开方的数据都发送完

3.2.然后，被动断开方进入LAST_ACK状态

4.第四次挥手：主动断开方收在到FIN+ACK断开响应报文后，还需要进行最后的确认
4.1.向被动断开方发送一个ACK确认报文

4.1.然后自己就进入TIME_WAIT状态，等待超时后最终关闭连接

4.2.处于TIME_WAIT状态的主动断开方，在等待完成2MSL的时间后
4.2.1.如果期间没有收到其他报文，则证明对方已正常关闭，主动断开方的连接最终关闭

5.被动断开方在收到主动断开方的最后的ACK报文以后，最终关闭连接，自己啥也不管

6.处于TIME_WAIT状态的主动断开方，在等待完成2MSL的时间后
6.1.才真正关闭连接通道，其等待的时间为什么是2MSL呢？

6.2.2MSL就是两倍的MSL，MSL指的是TCP报文片段在网络中最大的存活时间
6.3.2MSL是对应于一次消息的来回（一个发送和一个回复）所需的最大时间
6.4.如果直到2MSL，主动断开方都没有再次收到对方的报文
6.4.1.则可以推断ACK已经被对方成功接收
6.5.此时主动断开方将最终结束自己的TCP连接
6.5.1.所以TCP的TIME_WAIT状态也称为2MSL等待状态

6.5.有关MSL的具体的时间长度，在RFC1122协议中推荐为2分钟
6.6.在SICS开发的小型开源的TCP/IP协议栈——LwIP开源协议栈中MSL默认为1分钟
6.7.在源自Berkeley的TCP协议栈实现中MSL默认长度为30秒

6.8.总体来说，TIME_WAIT（2MSL）等待状态的时间长度，一般维持在1-4分钟之间

7.通过三次握手建立连接和四次挥手断开连接
7.1.一次TCP的连接建立及断开，至少进行7次通信，可见其成本是很高的

五.TCP/IP协议的特点

1.可靠性
1.1.TCP协议提供可靠的数据传输，通过序号、确认应答、重传机制和流量控制等机制
1.1.1.保证数据的可靠性和完整性

2.连接性
2.1.TCP协议是面向连接的，通过三次握手建立连接
2.2.确保通信双方的可靠性和数据传输的有序性

3.无连接性：IP协议是无连接的，每个数据包独立发送，无需事先建立连接

4.分组交换：TCP/IP协议将数据分割成较小的数据包进行传输
4.1.可以更高效地利用网络资源

六.总结

1.TCP/IP协议是互联网通信的基础协议，定义数据在网络中的传输方式和规则

2.它由TCP和IP等多个协议组成，每个协议层级负责不同的功能

3.TCP/IP协议通过分层的方式工作，提供可靠的、端到端的数据传输服务

4.对于前端来说
4.1.熟悉TCP/IP协议对于理解网络通信、调试网络问题以及优化网络传输等方面非常重要

5.通过深入熟悉TCP/IP协议，前端可以更好地理解前端与后端之间的数据传输过程
5.1.并在开发中优化网络请求、提高性能和用户体验

七.扫雷实例

<!DOCTYPE html>
<html>
<head>
  <title>扫雷游戏</title>
  <style>
    .cell {
      display: inline-block;
      width: 30px;
      height: 30px;
      border: 1px solid #ccc;
      text-align: center;
      vertical-align: middle;
      font-weight: bold;
      cursor: pointer;
    }
  </style>
</head>
<body>
  <h1>扫雷游戏</h1>
  <div id="game-board"></div>
  
  <script>
    const boardSize = 10;
    const mineCount = 10;
    
    let gameBoard = document.getElementById('game-board');
    let cells = [];
    let mines = [];
    let revealed = [];
    
    // 创建游戏面板
    function createBoard() {
      for (let i = 0; i < boardSize; i++) {
        let row = document.createElement('div');
        row.classList.add('row');
        gameBoard.appendChild(row);
        
        let cellRow = [];
        let revealedRow = [];
        
        for (let j = 0; j < boardSize; j++) {
          let cell = document.createElement('div');
          cell.classList.add('cell');
          cell.setAttribute('data-row', i);
          cell.setAttribute('data-col', j);
          cell.addEventListener('click', handleCellClick);
          row.appendChild(cell);
          
          cellRow.push(cell);
          revealedRow.push(false);
        }
        
        cells.push(cellRow);
        revealed.push(revealedRow);
      }
    }
    
    // 随机布置地雷
    function placeMines() {
      let count = 0;
      
      while (count < mineCount) {
        let row = Math.floor(Math.random() * boardSize);
        let col = Math.floor(Math.random() * boardSize);
        
        if (!mines[row][col]) {
          mines[row][col] = true;
          count++;
        }
      }
    }
    
    // 计算相邻地雷数量
    function calculateAdjacentMines(row, col) {
      let count = 0;
      
      for (let i = -1; i <= 1; i++) {
        for (let j = -1; j <= 1; j++) {
          let newRow = row + i;
          let newCol = col + j;
          
          if (newRow >= 0 && newRow < boardSize && newCol >= 0 && newCol < boardSize) {
            if (mines[newRow][newCol]) {
              count++;
            }
          }
        }
      }
      
      return count;
    }
    
    // 点击格子事件处理函数
    function handleCellClick(event) {
      let row = parseInt(event.target.getAttribute('data-row'));
      let col = parseInt(event.target.getAttribute('data-col'));
      
      if (mines[row][col]) {
        event.target.style.backgroundColor = 'red';
        event.target.textContent = 'X';
        revealMines();
        gameOver();
      } else {
        let count = calculateAdjacentMines(row, col);
        
        if (count > 0) {
          event.target.style.backgroundColor = 'lightgray';
          event.target.textContent = count;
        } else {
          event.target.style.backgroundColor = 'lightgray';
          event.target.textContent = '';
          revealEmptyCells(row, col);
        }
        
        revealed[row][col] = true;
        
        if (checkWin()) {
          gameWin();
        }
      }
      
      event.target.removeEventListener('click', handleCellClick);
    }
    
    // 揭示周围空白格子
    function revealEmptyCells(row, col) {
      let queue = [];
      queue.push({ row, col });

      while (queue.length > 0) {
        const { row, col } = queue.shift();

        for (let i = -1; i <= 1; i++) {
          for (let j = -1; j <= 1; j++) {
            let newRow = row + i;
            let newCol = col + j;

            if (
              newRow >= 0 &&
              newRow < boardSize &&
              newCol >= 0 &&
              newCol < boardSize &&
              !revealed[newRow][newCol]
            ) {
              let count = calculateAdjacentMines(newRow, newCol);

              if (count > 0) {
                cells[newRow][newCol].style.backgroundColor = 'lightgray';
                cells[newRow][newCol].textContent = count;
              } else {
                cells[newRow][newCol].style.backgroundColor = 'lightgray';
                cells[newRow][newCol].textContent = '';
                queue.push({ row: newRow, col: newCol });
              }

              revealed[newRow][newCol] = true;
              cells[newRow][newCol].removeEventListener('click', handleCellClick);
            }
          }
        }
      }
    }
    
    // 揭示所有地雷
    function revealMines() {
      for (let i = 0; i < boardSize; i++) {
        for (let j = 0; j < boardSize; j++) {
          if (mines[i][j]) {
            cells[i][j].style.backgroundColor = 'red';
            cells[i][j].textContent = 'X';
          }
        }
      }
    }
    
    // 检查是否胜利
    function checkWin() {
      for (let i = 0; i < boardSize; i++) {
        for (let j = 0; j < boardSize; j++) {
          if (!mines[i][j] && !revealed[i][j]) {
            return false;
          }
        }
      }
      
      return true;
    }
    
    // 游戏结束
    function gameOver() {
      for (let i = 0; i < boardSize; i++) {
        for (let j = 0; j < boardSize; j++) {
          cells[i][j].removeEventListener('click', handleCellClick);
        }
      }
    }
    
    // 游戏胜利
    function gameWin() {
      alert('恭喜！你赢了！');
      gameOver();
    }
    
    // 初始化游戏
    function initGame() {
      mines = [];
      revealed = [];
      
      for (let i = 0; i < boardSize; i++) {
        mines.push(new Array(boardSize).fill(false));
        revealed.push(new Array(boardSize).fill(false));
      }
      
      createBoard();
      placeMines();
    }
    
    // 开始游戏
    initGame();
  </script>
</body>
</html>