Vue 下载 Excel 文件

首先前端将List列表生成Excel文件需要下载几个依赖包。

npm install -S file-saver（生产依赖，则为-s）

npm install -S xlsx

npm install -D script-loader （开发依赖，则为-d）

引入文件

在 src 目录下面新建一个文件夹，例如 vendor，然后把：Blob.js 和 Export2Excel.js 两个文件放在该文件夹下，在Export2Excel.js 文件中我们引入。这两个文件在文末我会直接贴出来。

require(‘script-loader!file-saver’); // 保存文件

require(‘script-loader!@/vendor/Blob’); // 转二进制

下面这步好像不写也可以

由于这几个文件不支持 import 引入，所以我们需要 script-loader 来将他们挂载到全局环境下

import XLSX from ‘xlsx’ // xlsx核心

使用

然后就可以在我们需要的地方将List转成文件下载下来。

比如我有一个 List 数组 mData：

data() {

return {

mData: [

{

name: ‘wjw’,

age: 18,

sex: ‘1’

}, {

name: ‘tcz’,

age: 22,

sex: ‘1’

}, {

name: ‘zx’,

age: 23,

sex: ‘1’

}, {

name: ‘qy’,

age: 21,

sex: ‘1’

}, {

name: ‘lxh’,

age: 22,

sex: ‘1’

},

]

}

},

然后有一个按钮，点击按钮就会把 mData 列表转成 Excel 文件下载下来。

这个按钮我用了 ant-d 组件库，其实无所谓，只要是个点击事件触发就行。

<a-button @click=“down” type=“primary”>

下载

然后会执行这个函数。

methods: {

down() {

import(‘@/vendor/Export2Excel’).then(excel => {

const tHeader = [‘姓名’, ‘年龄’, ‘性别’] // excel的表头标题，这个根据自己需要改

const filterVal = [‘name’, ‘age’, ‘sex’] // 需要导出对应自己列表中的每项数据，这个就是根据自己的需要改

const list = this.mData // 整个列表的数据

const data = this.formatJson(filterVal, list)

excel.export_json_to_excel(

tHeader,

data,

‘table-list’ // 文件名称,若不写导出文件可能不识别

)

})

},

formatJson(filterVal, jsonData) { // 在整个列表的数据中过滤导出自己需要的数据

return jsonData.map(v => filterVal.map(j => v[j]))

},

}

文件生成成功！

后台返回blob文件流，前端实现下载文件

---

看这篇文章 ：

https://www.cnblogs.com/tcz1018/p/14073558.html

Blob.js

---

/* Blob.js

• A Blob, File, FileReader & URL implementation.

• 2018-08-09

• By Eli Grey, http://eligrey.com

• By Jimmy Wärting, https://github.com/jimmywarting

• License: MIT

• See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md

*/

;(function(){

var global = typeof window === ‘object’

? window : typeof self === ‘object’

? self : this

var BlobBuilder = global.BlobBuilder

|| global.WebKitBlobBuilder

|| global.MSBlobBuilder

|| global.MozBlobBuilder;

global.URL = global.URL || global.webkitURL || function(href, a) {

a = document.createElement(‘a’)

a.href = href

return a

}

var origBlob = global.Blob

var createObjectURL = URL.createObjectURL

var revokeObjectURL = URL.revokeObjectURL

var strTag = global.Symbol && global.Symbol.toStringTag

var blobSupported = false

var blobSupportsArrayBufferView = false

var arrayBufferSupported = !!global.ArrayBuffer

var blobBuilderSupported = BlobBuilder

&& BlobBuilder.prototype.append

&& BlobBuilder.prototype.getBlob;

try {

// Check if Blob constructor is supported

blobSupported = new Blob([‘ä’]).size === 2

// Check if Blob constructor supports ArrayBufferViews

// Fails in Safari 6, so we need to map to ArrayBuffers there.

blobSupportsArrayBufferView = new Blob([new Uint8Array([1,2])]).size === 2

} catch(e) {}

/**

• Helper function that maps ArrayBufferViews to ArrayBuffers

• Used by BlobBuilder constructor and old browsers that didn’t

• support it in the Blob constructor.

*/

function mapArrayBufferViews(ary) {

return ary.map(function(chunk) {

if (chunk.buffer instanceof ArrayBuffer) {

var buf = chunk.buffer;

// if this is a subarray, make a copy so we only

// include the subarray region from the underlying buffer

if (chunk.byteLength !== buf.byteLength) {

var copy = new Uint8Array(chunk.byteLength);

copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));

buf = copy.buffer;

}

return buf;

}

return chunk;

});

}

function BlobBuilderConstructor(ary, options) {

options = options || {};

var bb = new BlobBuilder();

mapArrayBufferViews(ary).forEach(function(part) {

bb.append(part);

});

return options.type ? bb.getBlob(options.type) : bb.getBlob();

};

function BlobConstructor(ary, options) {

return new origBlob(mapArrayBufferViews(ary), options || {});

};

if (global.Blob) {

BlobBuilderConstructor.prototype = Blob.prototype;

BlobConstructor.prototype = Blob.prototype;

}

function FakeBlobBuilder() {

function toUTF8Array(str) {

var utf8 = [];

for (var i=0; i < str.length; i++) {

var charcode = str.charCodeAt(i);

if (charcode < 0x80) utf8.push(charcode);

else if (charcode < 0x800) {

utf8.push(0xc0 | (charcode >> 6),

0x80 | (charcode & 0x3f));

}

else if (charcode < 0xd800 || charcode >= 0xe000) {

utf8.push(0xe0 | (charcode >> 12),

0x80 | ((charcode>>6) & 0x3f),

0x80 | (charcode & 0x3f));

}

// surrogate pair

else {

i++;

// UTF-16 encodes 0x10000-0x10FFFF by

// subtracting 0x10000 and splitting the

// 20 bits of 0x0-0xFFFFF into two halves

charcode = 0x10000 + (((charcode & 0x3ff)<<10)

| (str.charCodeAt(i) & 0x3ff));

utf8.push(0xf0 | (charcode >>18),

0x80 | ((charcode>>12) & 0x3f),

0x80 | ((charcode>>6) & 0x3f),

0x80 | (charcode & 0x3f));

}

}

return utf8;

}

function fromUtf8Array(array) {

var out, i, len, c;

var char2, char3;

out = “”;

len = array.length;

i = 0;

while (i < len) {

c = array[i++];

switch (c >> 4)

{

case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:

// 0xxxxxxx

out += String.fromCharCode©;

break;

case 12: case 13:

// 110x xxxx 10xx xxxx

char2 = array[i++];

out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));

break;

case 14:

// 1110 xxxx 10xx xxxx 10xx xxxx

char2 = array[i++];

char3 = array[i++];

out += String.fromCharCode(((c & 0x0F) << 12) |

((char2 & 0x3F) << 6) |

((char3 & 0x3F) << 0));

break;

}

}

return out;

}

function isDataView(obj) {

return obj && DataView.prototype.isPrototypeOf(obj)

}

function bufferClone(buf) {

var view = new Array(buf.byteLength)

var array = new Uint8Array(buf)

var i = view.length

while(i–) {

view[i] = array[i]

}

return view

}

function encodeByteArray(input) {

var byteToCharMap = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789’

var output = [];

for (var i = 0; i < input.length; i += 3) {

var byte1 = input[i];

var haveByte2 = i + 1 < input.length;

var byte2 = haveByte2 ? input[i + 1] : 0;

var haveByte3 = i + 2 < input.length;

var byte3 = haveByte3 ? input[i + 2] : 0;

var outByte1 = byte1 >> 2;

var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);

var outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);

var outByte4 = byte3 & 0x3F;

if (!haveByte3) {

outByte4 = 64;

if (!haveByte2) {

outByte3 = 64;

}

}

output.push(

byteToCharMap[outByte1], byteToCharMap[outByte2],

byteToCharMap[outByte3], byteToCharMap[outByte4])

}

return output.join(‘’)

}

var create = Object.create || function (a) {

function c() {}

c.prototype = a;

return new c

}

if (arrayBufferSupported) {

var viewClasses = [

‘[object Int8Array]’,

‘[object Uint8Array]’,

‘[object Uint8ClampedArray]’,

‘[object Int16Array]’,

‘[object Uint16Array]’,

‘[object Int32Array]’,

‘[object Uint32Array]’,

‘[object Float32Array]’,

‘[object Float64Array]’

]

var isArrayBufferView = ArrayBuffer.isView || function(obj) {

return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1

}

}

/********************************************************/

/* Blob constructor */

/********************************************************/

function Blob(chunks, opts) {

chunks = chunks || []

for (var i = 0, len = chunks.length; i < len; i++) {

var chunk = chunks[i]

if (chunk instanceof Blob) {

chunks[i] = chunk._buffer

} else if (typeof chunk === ‘string’) {

chunks[i] = toUTF8Array(chunk)

} else if (arrayBufferSupported && (ArrayBuffer.prototype.isPrototypeOf(chunk) || isArrayBufferView(chunk))) {

chunks[i] = bufferClone(chunk)

} else if (arrayBufferSupported && isDataView(chunk)) {

chunks[i] = bufferClone(chunk.buffer)

} else {

chunks[i] = toUTF8Array(String(chunk))

}

}

this._buffer = [].concat.apply([], chunks)

this.size = this._buffer.length

this.type = opts ? opts.type || ‘’ : ‘’

}

Blob.prototype.slice = function(start, end, type) {

var slice = this._buffer.slice(start || 0, end || this._buffer.length)

return new Blob([slice], {type: type})

}

Blob.prototype.toString = function() {

return ‘[object Blob]’

}

/********************************************************/

/* File constructor */

/********************************************************/

function File(chunks, name, opts) {

opts = opts || {}

var a = Blob.call(this, chunks, opts) || this

a.name = name

a.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date

a.lastModified = +a.lastModifiedDate

return a

}

File.prototype = create(Blob.prototype);

File.prototype.constructor = File;

if (Object.setPrototypeOf)

Object.setPrototypeOf(File, Blob);

else {

try {File.proto = Blob} catch (e) {}

}

File.prototype.toString = function() {

return ‘[object File]’

}

/********************************************************/

/* FileReader constructor */

/********************************************************/

function FileReader() {

if (!(this instanceof FileReader))

throw new TypeError(“Failed to construct ‘FileReader’: Please use the ‘new’ operator, this DOM object constructor cannot be called as a function.”)

var delegate = document.createDocumentFragment()

this.addEventListener = delegate.addEventListener

this.dispatchEvent = function(evt) {

var local = this[‘on’ + evt.type]

if (typeof local === ‘function’) local(evt)

delegate.dispatchEvent(evt)

}

this.removeEventListener = delegate.removeEventListener

}

function _read(fr, blob, kind) {

if (!(blob instanceof Blob))

throw new TypeError(“Failed to execute '” + kind + “’ on ‘FileReader’: parameter 1 is not of type ‘Blob’.”)

fr.result = ‘’

setTimeout(function(){

this.readyState = FileReader.LOADING

fr.dispatchEvent(new Event(‘load’))

fr.dispatchEvent(new Event(‘loadend’))

})

}

FileReader.EMPTY = 0

FileReader.LOADING = 1

FileReader.DONE = 2

FileReader.prototype.error = null

FileReader.prototype.onabort = null

FileReader.prototype.onerror = null

FileReader.prototype.onload = null

FileReader.prototype.onloadend = null

FileReader.prototype.onloadstart = null

FileReader.prototype.onprogress = null

FileReader.prototype.readAsDataURL = function(blob) {

_read(this, blob, ‘readAsDataURL’)

this.result = ‘data:’ + blob.type + ‘;base64,’ + encodeByteArray(blob._buffer)

}

FileReader.prototype.readAsText = function(blob) {

_read(this, blob, ‘readAsText’)

this.result = fromUtf8Array(blob._buffer)

}

FileReader.prototype.readAsArrayBuffer = function(blob) {

_read(this, blob, ‘readAsText’)

this.result = blob._buffer.slice()

}

FileReader.prototype.abort = function() {}

/********************************************************/

/* URL */

/********************************************************/

URL.createObjectURL = function(blob) {

return blob instanceof Blob

? ‘data:’ + blob.type + ‘;base64,’ + encodeByteArray(blob._buffer)

createObjectURL.call(URL, blob)

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

更多面试题

**《350页前端校招面试题精编解析大全》**内容大纲主要包括 HTML，CSS，前端基础，前端核心，前端进阶，移动端开发，计算机基础，算法与数据结构，项目，职业发展等等

资料获取方式：点击蓝色传送门获取

anceof Blob

? ‘data:’ + blob.type + ‘;base64,’ + encodeByteArray(blob._buffer)

createObjectURL.call(URL, blob)

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-H2KsaizB-1712962401247)]

[外链图片转存中…(img-LJmVYVac-1712962401248)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

[外链图片转存中…(img-QoQIrz2B-1712962401248)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

更多面试题

**《350页前端校招面试题精编解析大全》**内容大纲主要包括 HTML，CSS，前端基础，前端核心，前端进阶，移动端开发，计算机基础，算法与数据结构，项目，职业发展等等

资料获取方式：点击蓝色传送门获取

[外链图片转存中…(img-SyTm17Jh-1712962401249)]