JS實現(xiàn)可恢復的文件上傳示例詳解

更新時間：2022年12月29日 09:29:50 作者：莫凡是莫煩

這篇文章主要為大家介紹了JS實現(xiàn)可恢復的文件上傳示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

正文

使用 fetch 方法來上傳文件相當容易。

連接斷開后如何恢復上傳？這里沒有對此的內建選項，但是我們有實現(xiàn)它的一些方式。

對于大文件（如果我們可能需要恢復），可恢復的上傳應該帶有上傳進度提示。由于 fetch 不允許跟蹤上傳進度，我們將會使用 XMLHttpRequest。

不太實用的進度事件

要恢復上傳，我們需要知道在連接斷開前已經上傳了多少。

我們有 xhr.upload.onprogress 來跟蹤上傳進度。

不幸的是，它不會幫助我們在此處恢復上傳，因為它會在數(shù)據 被發(fā)送 時觸發(fā)，但是服務器是否接收到了？瀏覽器并不知道。

或許它是由本地網絡代理緩沖的（buffered），或者可能是遠程服務器進程剛剛終止而無法處理它們，亦或是它在中間丟失了，并沒有到達服務器。

這就是為什么此事件僅適用于顯示一個好看的進度條。

要恢復上傳，我們需要 確切地 知道服務器接收的字節(jié)數(shù)。而且只有服務器能告訴我們，因此，我們將發(fā)出一個額外的請求。

算法

首先，創(chuàng)建一個文件 id，以唯一地標識我們要上傳的文件：

let fileId = file.name + '-' + file.size + '-' + file.lastModified;

在恢復上傳時需要用到它，以告訴服務器我們要恢復的內容。

如果名稱，或大小，或最后一次修改時間發(fā)生了更改，則將有另一個 fileId。

向服務器發(fā)送一個請求，詢問它已經有了多少字節(jié)，像這樣：

let response = await fetch('status', {
  headers: {
    'X-File-Id': fileId
  }
});
// 服務器已有的字節(jié)數(shù)
let startByte = +await response.text();

這假設服務器通過 X-File-Id header 跟蹤文件上傳。應該在服務端實現(xiàn)。

如果服務器上尚不存在該文件，則服務器響應應為 0。

然后，我們可以使用 Blob 和 slice 方法來發(fā)送從 startByte 開始的文件：

xhr.open("POST", "upload", true);
// 文件 id，以便服務器知道我們要恢復的是哪個文件
xhr.setRequestHeader('X-File-Id', fileId);
// 發(fā)送我們要從哪個字節(jié)開始恢復，因此服務器知道我們正在恢復
xhr.setRequestHeader('X-Start-Byte', startByte);
xhr.upload.onprogress = (e) => {
  console.log(`Uploaded ${startByte + e.loaded} of ${startByte + e.total}`);
};
// 文件可以是來自 input.files[0]，或者另一個源
xhr.send(file.slice(startByte));

這里我們將文件 id 作為 X-File-Id 發(fā)送給服務器，所以服務器知道我們正在上傳哪個文件，并且，我們還將起始字節(jié)作為 X-Start-Byte 發(fā)送給服務器，所以服務器知道我們不是重新上傳它，而是恢復其上傳。

服務器應該檢查其記錄，如果有一個上傳的該文件，并且當前已上傳的文件大小恰好是 X-Start-Byte，那么就將數(shù)據附加到該文件。

這是用 Node.js 寫的包含客戶端和服務端代碼的示例。

在本網站上，它只有部分能工作，因為 Node.js 位于另一個服務 Nginx 后面，該服務器緩沖（buffer）上傳的內容，當完全上傳后才將其傳遞給 Node.js。

但是你可以下載這些代碼，在本地運行以進行完整演示：

server.js

let http = require('http');
let static = require('node-static');
let fileServer = new static.Server('.');
let path = require('path');
let fs = require('fs');
let debug = require('debug')('example:resume-upload');
let uploads = Object.create(null);
function onUpload(req, res) {
  let fileId = req.headers['x-file-id'];
  let startByte = +req.headers['x-start-byte'];
  if (!fileId) {
    res.writeHead(400, "No file id");
    res.end();
  }
  // 我們將“無處”保存文件
  let filePath = '/dev/null';
  // 可以改用真實路徑，例如
  // let filePath = path.join('/tmp', fileId);
  debug("onUpload fileId: ", fileId);
  // 初始化一個新上傳
  if (!uploads[fileId]) uploads[fileId] = {};
  let upload = uploads[fileId];
  debug("bytesReceived:" + upload.bytesReceived + " startByte:" + startByte)
  let fileStream;
  // 如果 startByte 為 0 或者沒設置，創(chuàng)建一個新文件，否則檢查大小并附加到現(xiàn)有的大小
  if (!startByte) {
    upload.bytesReceived = 0;
    fileStream = fs.createWriteStream(filePath, {
      flags: 'w'
    });
    debug("New file created: " + filePath);
  } else {
    // 我們也可以檢查磁盤上的文件大小以確保
    if (upload.bytesReceived != startByte) {
      res.writeHead(400, "Wrong start byte");
      res.end(upload.bytesReceived);
      return;
    }
    // 附加到現(xiàn)有文件
    fileStream = fs.createWriteStream(filePath, {
      flags: 'a'
    });
    debug("File reopened: " + filePath);
  }
  req.on('data', function(data) {
    debug("bytes received", upload.bytesReceived);
    upload.bytesReceived += data.length;
  });
  // 將 request body 發(fā)送到文件
  req.pipe(fileStream);
  // 當請求完成，并且其所有數(shù)據都以寫入完成
  fileStream.on('close', function() {
    if (upload.bytesReceived == req.headers['x-file-size']) {
      debug("Upload finished");
      delete uploads[fileId];
      // 可以在這里對上傳的文件進行其他操作
      res.end("Success " + upload.bytesReceived);
    } else {
      // 連接斷開，我們將未完成的文件保留在周圍
      debug("File unfinished, stopped at " + upload.bytesReceived);
      res.end();
    }
  });
  // 如果發(fā)生 I/O error —— 完成請求
  fileStream.on('error', function(err) {
    debug("fileStream error");
    res.writeHead(500, "File error");
    res.end();
  });
}
function onStatus(req, res) {
  let fileId = req.headers['x-file-id'];
  let upload = uploads[fileId];
  debug("onStatus fileId:", fileId, " upload:", upload);
  if (!upload) {
    res.end("0")
  } else {
    res.end(String(upload.bytesReceived));
  }
}
function accept(req, res) {
  if (req.url == '/status') {
    onStatus(req, res);
  } else if (req.url == '/upload' && req.method == 'POST') {
    onUpload(req, res);
  } else {
    fileServer.serve(req, res);
  }
}
// -----------------------------------
if (!module.parent) {
  http.createServer(accept).listen(8080);
  console.log('Server listening at port 8080');
} else {
  exports.accept = accept;
}

uploader.js

class Uploader {
  constructor({file, onProgress}) {
    this.file = file;
    this.onProgress = onProgress;
    // 創(chuàng)建唯一標識文件的 fileId
    // 我們還可以添加用戶會話標識符（如果有的話），以使其更具唯一性
    this.fileId = file.name + '-' + file.size + '-' + file.lastModified;
  }
  async getUploadedBytes() {
    let response = await fetch('status', {
      headers: {
        'X-File-Id': this.fileId
      }
    });
    if (response.status != 200) {
      throw new Error("Can't get uploaded bytes: " + response.statusText);
    }
    let text = await response.text();
    return +text;
  }
  async upload() {
    this.startByte = await this.getUploadedBytes();
    let xhr = this.xhr = new XMLHttpRequest();
    xhr.open("POST", "upload", true);
    // 發(fā)送文件 id，以便服務器知道要恢復哪個文件
    xhr.setRequestHeader('X-File-Id', this.fileId);
    // 發(fā)送我們要從哪個字節(jié)開始恢復，因此服務器知道我們正在恢復
    xhr.setRequestHeader('X-Start-Byte', this.startByte);
    xhr.upload.onprogress = (e) => {
      this.onProgress(this.startByte + e.loaded, this.startByte + e.total);
    };
    console.log("send the file, starting from", this.startByte);
    xhr.send(this.file.slice(this.startByte));
    // return
    //   true —— 如果上傳成功，
    //   false —— 如果被中止
    // 出現(xiàn) error 時將其拋出
    return await new Promise((resolve, reject) => {
      xhr.onload = xhr.onerror = () => {
        console.log("upload end status:" + xhr.status + " text:" + xhr.statusText);
        if (xhr.status == 200) {
          resolve(true);
        } else {
          reject(new Error("Upload failed: " + xhr.statusText));
        }
      };
      // onabort 僅在 xhr.abort() 被調用時觸發(fā)
      xhr.onabort = () => resolve(false);
    });
  }
  stop() {
    if (this.xhr) {
      this.xhr.abort();
    }
  }
}

index.html

<!DOCTYPE HTML>
<script src="uploader.js"></script>
<form name="upload" method="POST" enctype="multipart/form-data" action="/upload">
  <input type="file" name="myfile">
  <input type="submit" name="submit" value="Upload (Resumes automatically)">
</form>
<button onclick="uploader.stop()">Stop upload</button>
<div id="log">Progress indication</div>
<script>
  function log(html) {
    document.getElementById('log').innerHTML = html;
    console.log(html);
  }
  function onProgress(loaded, total) {
    log("progress " + loaded + ' / ' + total);
  }
  let uploader;
  document.forms.upload.onsubmit = async function(e) {
    e.preventDefault();
    let file = this.elements.myfile.files[0];
    if (!file) return;
    uploader = new Uploader({file, onProgress});
    try {
      let uploaded = await uploader.upload();
      if (uploaded) {
        log('success');
      } else {
        log('stopped');
      }
    } catch(err) {
      console.error(err);
      log('error');
    }
  };
</script>

結果