// 安裝axios（接口請求）、spark-md5（文件哈希計算）
npm install axios spark-md5

import SparkMD5 from 'spark-md5';
import axios from 'axios';

// 核心配置（可根據(jù)企業(yè)需求微調(diào)）
export const UPLOAD_CONFIG = {
  chunkSize: 2 * 1024 * 1024, // 分片大小：2MB（適配大多數(shù)場景）
  baseUrl: 'http://localhost:3000', // 后端接口地址
  maxRetry: 3, // 分片失敗最大重試次數(shù)（企業(yè)級常用配置）
  concurrency: 3, // 并發(fā)上傳數(shù)量（避免請求過多壓垮服務(wù)器）
  retryDelay: 1000 // 失敗重試延遲（1秒，避免頻繁重試）
};

// 切割文件為分片
export function createFileChunk(file) {
  const chunks = [];
  let current = 0;
  while (current< file.size) {
    chunks.push({
      chunk: file.slice(current, current + UPLOAD_CONFIG.chunkSize),
      index: chunks.length,
      progress: 0 // 單個分片進度
    });
    current += UPLOAD_CONFIG.chunkSize;
  }
  return chunks;
}

// 計算文件哈希值（秒傳/斷點續(xù)傳校驗用，優(yōu)化計算速度）
export async function calculateFileHash(file, chunks) {
  return new Promise((resolve, reject) => {
    const spark = new SparkMD5.ArrayBuffer();
    const fileReader = new FileReader();
    let currentChunk = 0;

    const loadNextChunk = () => {
      if (currentChunk >= chunks.length) {
        resolve(spark.end()); // 計算完成，返回哈希值
        return;
      }
      // 讀取當前分片（ArrayBuffer格式，計算哈希更高效）
      fileReader.readAsArrayBuffer(chunks[currentChunk].chunk);
      currentChunk++;
    };

    fileReader.onload = (e) => spark.append(e.target.result);
    fileReader.onloadend = loadNextChunk;
    fileReader.onerror = (err) => reject(`哈希計算失?。?{err.message}`);

    loadNextChunk(); // 開始讀取第一個分片
  });
}

// 校驗文件（秒傳、斷點續(xù)傳核心接口）
export async function checkFile(fileHash, filename) {
  try {
    const res = await axios.post(`${UPLOAD_CONFIG.baseUrl}/check`, { fileHash, filename });
    return res.data; // 后端返回：{ isExist: boolean, uploadedChunks: [] }
  } catch (err) {
    console.error('文件校驗失敗', err);
    return { isExist: false, uploadedChunks: [] };
  }
}

// 單個分片上傳（帶失敗自動重試）
export async function uploadSingleChunk(chunkInfo, fileHash, retryCount = 0) {
  const { chunk, index, total } = chunkInfo;
  const formData = new FormData();
  formData.append('chunk', chunk);
  formData.append('fileHash', fileHash);
  formData.append('index', index);
  formData.append('total', total);

  try {
    const res = await axios.post(`${UPLOAD_CONFIG.baseUrl}/upload`, formData, {
      onUploadProgress: (e) => {
        // 實時更新單個分片進度
        chunkInfo.progress = (e.loaded / e.total) * 100;
      },
      timeout: 30000 // 超時時間30秒，適配大分片上傳
    });
    return res.data;
  } catch (err) {
    // 失敗自動重試（未超過最大重試次數(shù)）
    if (retryCount < UPLOAD_CONFIG.maxRetry) {
      await new Promise(resolve => setTimeout(resolve, UPLOAD_CONFIG.retryDelay));
      console.log(`分片${index}重試（${retryCount + 1}/${UPLOAD_CONFIG.maxRetry}）`);
      return uploadSingleChunk(chunkInfo, fileHash, retryCount + 1);
    }
    throw new Error(`分片${index}上傳失敗，已超過最大重試次數(shù)`);
  }
}

// 合并分片（所有分片上傳完成后調(diào)用）
export async function mergeChunks(fileHash, filename) {
  try {
    const res = await axios.post(`${UPLOAD_CONFIG.baseUrl}/merge`, { fileHash, filename });
    return res.data;
  } catch (err) {
    console.error('分片合并失敗', err);
    throw new Error('分片合并失敗，請重試');
  }
}

// 取消上傳（刪除后端臨時分片）
export async function cancelUpload(fileHash) {
  try {
    await axios.post(`${UPLOAD_CONFIG.baseUrl}/cancel`, { fileHash });
    return { code: 0, msg: '取消上傳成功' };
  } catch (err) {
    console.error('取消上傳失敗', err);
    return { code: 1, msg: '取消上傳失敗' };
  }
}

<template>
  <div style="padding: 30px; max-width: 1000px; margin: 0 auto">
    <h3>Vue大文件上傳（企業(yè)級完整版）</h3>
    <!-- 文件選擇（支持多文件） -->
    <div style="margin: 20px 0">
      <input
        type="file"
        @change="handleFileChange"
        multiple
        :disabled="isAllUploading"
      />
      <span style="margin-left: 10px; font-size: 14px; color: #666">
        支持多文件上傳，單個文件建議不超過10GB
      </span>
    </div>
    <!-- 上傳隊列管理 -->
    <div v-if="uploadQueue.length > 0" style="margin: 20px 0">
      <h4 style="margin-bottom: 10px">上傳隊列（{{ uploadQueue.length }}個文件）</h4>
      <div 
        v-for="(item, index) in uploadQueue" 
        :key="item.fileHash"
        style="border: 1px solid #eee; padding: 15px; border-radius: 4px; margin-bottom: 10px"
      >
        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px">
          <div>
            <span>文件：{{ item.file.name }}</span>
            <span style="margin-left: 10px; color: #666">
              大小：{{ (item.file.size / 1024 / 1024).toFixed(2) }} MB
            </span>
          </div>
          <div>
            <!-- 隊列操作：刪除 -->
            <button 
              @click="removeFromQueue(index)"
              :disabled="item.uploading"
              style="margin-right: 10px; color: #f44336; border: none; background: transparent; cursor: pointer"
            >
              刪除
            </button>
            <!-- 上傳操作：暫停/繼續(xù)/取消 -->
            <button 
              @click="handleItemPauseResume(item)"
              :disabled="item.isCompleted || item.isCanceled"
              style="margin-right: 10px; border: none; padding: 4px 8px; border-radius: 4px; cursor: pointer"
              :style="{ background: item.paused ? '#2196f3' : '#f5a623', color: '#fff' }"
            >
              {{ item.paused ? '繼續(xù)' : '暫停' }}
            </button>
            <button 
              @click="handleItemCancel(item)"
              :disabled="item.isCompleted || item.isCanceled"
              style="border: none; padding: 4px 8px; border-radius: 4px; cursor: pointer; background: #f44336; color: #fff"
            >
              取消
            </button>
          </div>
        </div>
        <!-- 單個文件進度條 -->
        <div v-if="item.totalProgress > 0 || item.uploading || item.paused">
          <div style="display: flex; justify-content: space-between; font-size: 14px; margin-bottom: 5px">
            <span>進度：{{ item.totalProgress.toFixed(2) }}%</span>
            <span>狀態(tài)：{{ getStatusText(item) }}</span>
          </div>
          <div style="height: 8px; background: #eee; border-radius: 4px">
            <div
              style="height: 100%; background: #42b983; border-radius: 4px; transition: width 0.3s ease"
              :style="{ width: `${item.totalProgress}%` }"
            ></div>
          </div>
          <div style="font-size: 12px; color: #666; margin-top: 5px">
            已上傳：{{ item.uploadedChunkCount }}/{{ item.totalChunkCount }} 個分片
          </div>
        </div>
        <!-- 提示信息 -->
        <div 
          v-if="item.message" 
          style="margin-top: 10px; padding: 6px; border-radius: 4px; font-size: 12px"
          :style="{ background: item.isSuccess ? '#e8f5e9' : '#ffebee', color: item.isSuccess ? '#2e7d32' : '#c62828' }"
        >
          {{ item.message }}
        </div>
      </div>
    </div>
    <!-- 批量操作按鈕 -->
    <div v-if="uploadQueue.length > 0" style="margin: 10px 0">
      <button 
        @click="handleStartAll"
        :disabled="isAllUploading || isAllCompleted || isAllCanceled"
        style="margin-right: 10px; border: none; padding: 6px 12px; border-radius: 4px; background: #42b983; color: #fff; cursor: pointer"
      >
        開始所有上傳
      </button>
      <button 
        @click="handlePauseAll"
        :disabled="!hasUploading || isAllPaused"
        style="margin-right: 10px; border: none; padding: 6px 12px; border-radius: 4px; background: #f5a623; color: #fff; cursor: pointer"
      >
        暫停所有上傳
      </button>
      <button 
        @click="handleResumeAll"
        :disabled="!hasPaused"
        style="margin-right: 10px; border: none; padding: 6px 12px; border-radius: 4px; background: #2196f3; color: #fff; cursor: pointer"
      >
        繼續(xù)所有上傳
      </button>
      <button 
        @click="handleCancelAll"
        :disabled="isAllCompleted || isAllCanceled"
        style="border: none; padding: 6px 12px; border-radius: 4px; background: #f44336; color: #fff; cursor: pointer"
      >
        取消所有上傳
      </button>
    </div>
   <!-- 空隊列提示 -->
    <div v-if="uploadQueue.length === 0" style="padding: 20px; text-align: center; color: #666">
      暫無上傳文件，請選擇文件添加到隊列
    </div>
  </div>
</template>
<script setup>
import { ref, watch, computed } from 'vue';
import {
  createFileChunk,
  calculateFileHash,
  checkFile,
  uploadSingleChunk,
  mergeChunks,
  cancelUpload,
  UPLOAD_CONFIG
} from '@/utils/upload';
// 上傳隊列（多文件管理核心）
const uploadQueue = ref([]);
// 隊列狀態(tài)計算（批量操作使用）
const isAllUploading = computed(() => uploadQueue.value.every(item => item.uploading));
const isAllCompleted = computed(() => uploadQueue.value.every(item => item.isCompleted));
const isAllCanceled = computed(() => uploadQueue.value.every(item => item.isCanceled));
const isAllPaused = computed(() => uploadQueue.value.every(item => item.paused && !item.isCompleted && !item.isCanceled));
const hasUploading = computed(() => uploadQueue.value.some(item => item.uploading));
const hasPaused = computed(() => uploadQueue.value.some(item => item.paused && !item.isCompleted && !item.isCanceled));
// 選擇多文件，添加到上傳隊列
const handleFileChange = async (e) => {
  const selectedFiles = e.target.files;
  if (!selectedFiles || selectedFiles.length === 0) return;
  // 遍歷選中的文件，添加到隊列（去重：相同文件哈希不重復添加）
  for (const file of selectedFiles) {
    // 先切割分片，計算哈希（用于去重和后續(xù)上傳）
    const chunks = createFileChunk(file);
    const fileHash = await calculateFileHash(file, chunks);
    // 去重：判斷隊列中是否已存在該文件（通過哈希值）
    const isExistInQueue = uploadQueue.value.some(item => item.fileHash === fileHash);
    if (isExistInQueue) {
      alert(`文件${file.name}已在上傳隊列中，無需重復添加`);
      continue;
    }
    // 添加到上傳隊列，初始化狀態(tài)
    uploadQueue.value.push({
      file,
      fileHash,
      chunks,
      totalChunkCount: chunks.length,
      uploadedChunkCount: 0,
      totalProgress: 0,
      uploading: false,
      paused: false,
      isCompleted: false,
      isCanceled: false,
      message: '',
      isSuccess: false,
      isError: false
    });
  }
  // 清空input值，避免重復選擇同一文件
  e.target.value = '';
};
// 獲取文件狀態(tài)文本
const getStatusText = (item) => {
  if (item.isCompleted) return '上傳完成';
  if (item.isCanceled) return '已取消';
  if (item.uploading) return '上傳中';
  if (item.paused) return '已暫停';
  return '待上傳';
};
// 單個文件：開始/繼續(xù)上傳（核心方法，支持斷點續(xù)傳）
const handleItemUpload = async (item) => {
  if (item.uploading || item.isCompleted || item.isCanceled) return;
  try {
    item.uploading = true;
    item.paused = false;
    item.message = '準備上傳（校驗文件+計算哈希）...';
    // 1. 校驗文件（秒傳、斷點續(xù)傳）
    const checkResult = await checkFile(item.fileHash, item.file.name);
    if (checkResult.isExist) {
      // 秒傳：文件已存在，直接標記完成
      item.message = '文件已存在，秒傳成功！';
      item.isSuccess = true;
      item.isCompleted = true;
      item.totalProgress = 100;
      item.uploading = false;
      return;
    }
    // 2. 過濾已上傳分片（斷點續(xù)傳：刷新頁面/斷網(wǎng)后恢復）
    const unUploadedChunks = item.chunks.filter(
      (chunk) => !checkResult.uploadedChunks.includes(chunk.index)
    );
    item.uploadedChunkCount = item.chunks.length - unUploadedChunks.length;
    item.totalProgress = (item.uploadedChunkCount / item.totalChunkCount) * 100;
    // 3. 所有分片已上傳，直接合并
    if (unUploadedChunks.length === 0) {
      await mergeChunks(item.fileHash, item.file.name);
      item.message = '所有分片已上傳，合并完成！';
      item.isSuccess = true;
      item.isCompleted = true;
      item.totalProgress = 100;
      item.uploading = false;
      return;
    }
    // 4. 并發(fā)上傳未完成的分片（帶失敗自動重試）
    item.message = '開始上傳分片...';
    await uploadChunksConcurrently(unUploadedChunks, item);
    // 5. 合并分片
    item.message = '分片上傳完成，正在合并文件...';
    await mergeChunks(item.fileHash, item.file.name);
    // 上傳成功
    item.message = '文件上傳成功！';
    item.isSuccess = true;
    item.isCompleted = true;
    item.totalProgress = 100;
  } catch (err) {
    item.message = `上傳失敗：${err.message}`;
    item.isError = true;
    item.paused = true; // 失敗后自動暫停，方便用戶重試
  } finally {
    item.uploading = false;
  }
};
// 并發(fā)上傳分片（控制并發(fā)數(shù)量，監(jiān)聽進度）
const uploadChunksConcurrently = async (unUploadedChunks, item) => {
  // 給分片添加總分片數(shù)，用于上傳接口
  const chunksWithMeta = unUploadedChunks.map(chunk => ({
    ...chunk,
    total: item.totalChunkCount
  }));
  // 監(jiān)聽分片進度，更新文件總進度
  watch(
    () => chunksWithMeta.map(chunk => chunk.progress),
    () => {
      const totalLoaded = chunksWithMeta.reduce((sum, chunk) => sum + chunk.progress, 0);
      item.totalProgress = (item.uploadedChunkCount / item.totalChunkCount) * 100 + (totalLoaded / item.totalChunkCount / 100);
    },
    { deep: true }
  );
  // 并發(fā)控制：每次最多上傳UPLOAD_CONFIG.concurrency個分片
  for (let i = 0; i < chunksWithMeta.length; i += UPLOAD_CONFIG.concurrency) {
    // 暫停狀態(tài)時，等待繼續(xù)上傳
    if (item.paused) {
      await new Promise(resolve => {
        const watcher = watch(() => item.paused, (newVal) => {
          if (!newVal) {
            watcher(); // 取消監(jiān)聽
            resolve();
          }
        });
      });
    }
    // 取消上傳時，終止當前批量上傳
    if (item.isCanceled) break;
    const batch = chunksWithMeta.slice(i, i + UPLOAD_CONFIG.concurrency);
    await Promise.all(batch.map(chunk => uploadSingleChunk(chunk, item.fileHash)));
    item.uploadedChunkCount += batch.length;
  }
};
// 單個文件：暫停/繼續(xù)上傳
const handleItemPauseResume = (item) => {
  if (item.uploading) {
    // 暫停上傳
    item.paused = true;
    item.uploading = false;
    item.message = '上傳已暫停，點擊繼續(xù)可恢復';
  } else if (item.paused && !item.isCompleted && !item.isCanceled) {
    // 繼續(xù)上傳
    handleItemUpload(item);
  }
};
// 單個文件：取消上傳
const handleItemCancel = async (item) => {
  if (item.isCompleted || item.isCanceled) return;
  // 取消后端臨時分片
  await cancelUpload(item.fileHash);
  // 更新文件狀態(tài)
  item.isCanceled = true;
  item.uploading = false;
  item.paused = false;
  item.message = '已取消上傳';
  item.isError = true;
};
// 從隊列中刪除文件
const removeFromQueue = (index) => {
  const item = uploadQueue.value[index];
  if (item.uploading) {
    alert('當前文件正在上傳，無法刪除，請先暫停或取消上傳');
    return;
  }
  uploadQueue.value.splice(index, 1);
};
// 批量操作：開始所有文件上傳
const handleStartAll = () => {
  uploadQueue.value.forEach(item => {
    if (!item.uploading && !item.isCompleted && !item.isCanceled && !item.paused) {
      handleItemUpload(item);
    }
  });
};
// 批量操作：暫停所有文件上傳
const handlePauseAll = () => {
  uploadQueue.value.forEach(item => {
    if (item.uploading) {
      item.paused = true;
      item.uploading = false;
      item.message = '上傳已暫停，點擊繼續(xù)可恢復';
    }
  });
};
// 批量操作：繼續(xù)所有文件上傳
const handleResumeAll = () => {
  uploadQueue.value.forEach(item => {
    if (item.paused && !item.isCompleted && !item.isCanceled) {
      handleItemUpload(item);
    }
  });
};
// 批量操作：取消所有文件上傳
const handleCancelAll = async () => {
  for (const item of uploadQueue.value) {
    if (!item.isCompleted && !item.isCanceled) {
      await cancelUpload(item.fileHash);
      item.isCanceled = true;
      item.uploading = false;
      item.paused = false;
      item.message = '已取消上傳';
      item.isError = true;
    }
  }
};
// 頁面刷新時，恢復未完成的上傳（斷點續(xù)傳核心：刷新頁面不丟失進度）
const restoreUploadProgress = async () => {
  // 這里可根據(jù)實際需求，從localStorage讀取未完成的文件信息（示例邏輯）
  const savedQueue = localStorage.getItem('uploadQueue');
  if (!savedQueue) return;
  const parsedQueue = JSON.parse(savedQueue);
  for (const savedItem of parsedQueue) {
    if (savedItem.isCompleted || savedItem.isCanceled) continue;
    // 重新讀取文件（注：瀏覽器無法直接從哈?；謴臀募?，需用戶重新選擇，此處為示例）
    // 實際企業(yè)級場景可結(jié)合后端存儲，通過哈希重新獲取文件信息
    alert(`檢測到未完成的上傳：${savedItem.file.name}，請重新選擇該文件以恢復進度`);
  }
};
// 監(jiān)聽隊列變化，保存到localStorage（刷新頁面恢復進度）
watch(
  () => uploadQueue.value,
  (newQueue) => {
    // 只保存未完成、未取消的文件信息
    const savedQueue = newQueue.filter(item => !item.isCompleted && !item.isCanceled).map(item => ({
      fileHash: item.fileHash,
      file: { name: item.file.name, size: item.file.size },
      totalChunkCount: item.totalChunkCount,
      uploadedChunkCount: item.uploadedChunkCount,
      totalProgress: item.totalProgress,
      isCompleted: item.isCompleted,
      isCanceled: item.isCanceled
    }));
    localStorage.setItem('uploadQueue', JSON.stringify(savedQueue));
  },
  { deep: true }
);
// 頁面初始化時，恢復未完成的上傳
restoreUploadProgress();
</script>

// 新建server文件夾，執(zhí)行以下命令
mkdir server && cd server
npm init -y
npm install express cors fs-extra multer

const express = require('express');
const cors = require('cors');
const fs = require('fs-extra');
const path = require('path');
const multer = require('multer');

const app = express();
const PORT = 3000;

// 中間件配置（適配企業(yè)級跨域、請求解析）
app.use(cors({
  origin: '*', // 生產(chǎn)環(huán)境需替換為前端實際域名，提升安全性
  methods: ['GET', 'POST'],
  allowedHeaders: ['Content-Type']
}));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 存儲目錄配置（企業(yè)級建議掛載獨立磁盤或云存儲）
const UPLOAD_DIR = path.resolve(__dirname, 'upload'); // 最終文件存儲目錄
const CHUNK_DIR = path.resolve(__dirname, 'chunks'); // 臨時分片存儲目錄

// 確保目錄存在（不存在則創(chuàng)建）
fs.ensureDirSync(UPLOAD_DIR);
fs.ensureDirSync(CHUNK_DIR);

// multer配置（處理分片上傳，臨時存儲分片）
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    // 分片存儲路徑：chunks/文件哈希/分片索引（確保每個文件的分片獨立存儲）
    const fileHash = req.body.fileHash;
    const chunkPath = path.resolve(CHUNK_DIR, fileHash);
    fs.ensureDirSync(chunkPath); // 確保該文件的分片目錄存在
    cb(null, chunkPath);
  },
  filename: (req, file, cb) => {
    // 分片文件名：分片索引（確保合并時順序正確）
    cb(null, req.body.index);
  }
});

// 限制分片大?。源笥谇岸朔制笮?，避免接收失?。?
const upload = multer({ 
  storage,
  limits: { fileSize: UPLOAD_CONFIG.chunkSize + 1024 * 100 } // 2MB + 100KB緩沖
});

// 配置前端分片大?。ㄅc前端保持一致）
const UPLOAD_CONFIG = {
  chunkSize: 2 * 1024 * 1024
};

// 接口1：校驗文件（秒傳、斷點續(xù)傳核心接口）
app.post('/check', async (req, res) => {
  try {
    const { fileHash, filename } = req.body;
    const ext = path.extname(filename); // 文件后綴（如.mp4、.zip）
    const finalFilePath = path.resolve(UPLOAD_DIR, `${fileHash}${ext}`);

    // 1. 秒傳校驗：文件已存在，直接返回成功
    if (await fs.pathExists(finalFilePath)) {
      return res.json({
        code: 0,
        msg: '文件已存在',
        isExist: true,
        uploadedChunks: []
      });
    }

    // 2. 斷點續(xù)傳校驗：查詢已上傳的分片
    const chunkDir = path.resolve(CHUNK_DIR, fileHash);
    let uploadedChunks = [];
    if (await fs.pathExists(chunkDir)) {
      // 讀取該文件的所有已上傳分片（文件名即分片索引）
      uploadedChunks = await fs.readdir(chunkDir);
      // 轉(zhuǎn)為數(shù)字類型，確保合并時順序正確
      uploadedChunks = uploadedChunks.map(index => parseInt(index));
    }

    res.json({
      code: 0,
      msg: '文件校驗成功',
      isExist: false,
      uploadedChunks
    });
  } catch (err) {
    res.status(500).json({
      code: 1,
      msg: `文件校驗失敗：${err.message}`,
      isExist: false,
      uploadedChunks: []
    });
  }
});

// 接口2：上傳分片（支持失敗自動重試，與前端重試邏輯配合）
app.post('/upload', upload.single('chunk'), async (req, res) => {
  try {
    // 前端傳遞的參數(shù)：fileHash（文件哈希）、index（分片索引）、total（總分片數(shù)）
    const { fileHash, index, total } = req.body;
    res.json({
      code: 0,
      msg: `分片${index}/${total}上傳成功`
    });
  } catch (err) {
    res.status(500).json({
      code: 1,
      msg: `分片上傳失?。?{err.message}`
    });
  }
});

// 接口3：合并分片（所有分片上傳完成后調(diào)用）
app.post('/merge', async (req, res) => {
  try {
    const { fileHash, filename } = req.body;
    const ext = path.extname(filename);
    const finalFilePath = path.resolve(UPLOAD_DIR, `${fileHash}${ext}`);
    const chunkDir = path.resolve(CHUNK_DIR, fileHash);

    // 校驗分片目錄是否存在
    if (!await fs.pathExists(chunkDir)) {
      return res.status(400).json({
        code: 1,
        msg: '分片目錄不存在，無法合并'
      });
    }

    // 讀取所有分片，按索引排序（確保合并順序正確）
    const chunks = (await fs.readdir(chunkDir)).sort((a, b) => parseInt(a) - parseInt(b));
    if (chunks.length === 0) {
      await fs.remove(chunkDir); // 刪除空目錄
      return res.status(400).json({
        code: 1,
        msg: '無分片數(shù)據(jù)，無法合并'
      });
    }

    // 合并所有分片（企業(yè)級優(yōu)化：使用流合并，提升大文件合并效率）
    const writeStream = fs.createWriteStream(finalFilePath);
    for (const chunk of chunks) {
      const chunkPath = path.resolve(chunkDir, chunk);
      const readStream = fs.createReadStream(chunkPath);
      await new Promise(resolve => {
        readStream.pipe(writeStream, { end: false });
        readStream.on('end', resolve);
      });
      await fs.remove(chunkPath); // 合并后刪除單個分片，節(jié)省空間
    }

    // 關(guān)閉寫入流，刪除分片目錄
    writeStream.end();
    await fs.remove(chunkDir);

    res.json({
      code: 0,
      msg: '分片合并成功',
      filePath: finalFilePath // 可選：返回最終文件路徑，用于前端下載
    });
  } catch (err) {
    res.status(500).json({
      code: 1,
      msg: `分片合并失?。?{err.message}`
    });
  }
});

// 接口4：取消上傳（新增，企業(yè)級必備功能）
app.post('/cancel', async (req, res) => {
  try {
    const { fileHash } = req.body;
    const chunkDir = path.resolve(CHUNK_DIR, fileHash);

    // 刪除該文件的所有臨時分片
    if (await fs.pathExists(chunkDir)) {
      await fs.remove(chunkDir);
    }

    res.json({
      code: 0,
      msg: '取消上傳成功，已清理臨時分片'
    });
  } catch (err) {
    res.status(500).json({
      code: 1,
      msg: `取消上傳失?。?{err.message}`
    });
  }
});

// 啟動服務(wù)（企業(yè)級建議添加日志、進程守護）
app.listen(PORT, () => {
  console.log(`后端服務(wù)啟動成功：http://localhost:${PORT}`);
  console.log(`最終文件存儲目錄：${UPLOAD_DIR}`);
  console.log(`臨時分片存儲目錄：${CHUNK_DIR}`);
});