vue-excel导出-单表头,多表头导出,Export2Excel.js Blob.js

2023-11-20

效果如图↓

一级导出:↓

 

 二级导出:如下图

 

三级导出:↓

Export2Excel.js Blob.js 等

安装依赖

npm install -S file-saver
npm install --save xlsx@0.10.0
npm install -D script-loader  
npm install xlsx-style --save   

其中xlsx-style 有坑↓

Can‘t resolve ‘./cptable‘ in ‘xxx\node_modules_xlsx

Can’t resolve ‘fs’

在vue.config.js中配置↓

const { defineConfig } = require('@vue/cli-service')
module.exports = defineConfig({
  transpileDependencies: true,
  configureWebpack:{
    externals: {
      './cptable': 'var cptable',
    
  },
  resolve: { fallback: { fs: false } }

  }

})

jszip not a constructor↓  在xslx-style下的xslx.js中

(node_modules\xlsx-style\xlsx.js )

将
if(typeof jszip === 'undefined') jszip = require('./js'+'zip').JSZip;
替换成
if(typeof jszip === 'undefined') jszip = require('./jszip.js');

项目结构↓

注:

 其中Export2ExcelPro.js 是可以导出二级标题, Export2Excel.js是导入一级标题

excelExport.js是封装了调用方法。

Blob.js↓

/* Blob.js
 * A Blob implementation.
 * 2014-05-27
 *
 * By Eli Grey, http://eligrey.com
 * By Devin Samarin, https://github.com/eboyjr
 * License: X11/MIT
 *   See LICENSE.md
 */

/*global self, unescape */
/*jslint bitwise: true, regexp: true, confusion: true, es5: true, vars: true, white: true,
 plusplus: true */

/*! @source http://purl.eligrey.com/github/Blob.js/blob/master/Blob.js */

(function (view) {
  "use strict";

  view.URL = view.URL || view.webkitURL;

  if (view.Blob && view.URL) {
      try {
          new Blob;
          return;
      } catch (e) {}
  }

  // Internally we use a BlobBuilder implementation to base Blob off of
  // in order to support older browsers that only have BlobBuilder
  var BlobBuilder = view.BlobBuilder || view.WebKitBlobBuilder || view.MozBlobBuilder || (function(view) {
          var
              get_class = function(object) {
                  return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
              }
              , FakeBlobBuilder = function BlobBuilder() {
                  this.data = [];
              }
              , FakeBlob = function Blob(data, type, encoding) {
                  this.data = data;
                  this.size = data.length;
                  this.type = type;
                  this.encoding = encoding;
              }
              , FBB_proto = FakeBlobBuilder.prototype
              , FB_proto = FakeBlob.prototype
              , FileReaderSync = view.FileReaderSync
              , FileException = function(type) {
                  this.code = this[this.name = type];
              }
              , file_ex_codes = (
                  "NOT_FOUND_ERR SECURITY_ERR ABORT_ERR NOT_READABLE_ERR ENCODING_ERR "
                  + "NO_MODIFICATION_ALLOWED_ERR INVALID_STATE_ERR SYNTAX_ERR"
              ).split(" ")
              , file_ex_code = file_ex_codes.length
              , real_URL = view.URL || view.webkitURL || view
              , real_create_object_URL = real_URL.createObjectURL
              , real_revoke_object_URL = real_URL.revokeObjectURL
              , URL = real_URL
              , btoa = view.btoa
              , atob = view.atob

              , ArrayBuffer = view.ArrayBuffer
              , Uint8Array = view.Uint8Array
              ;
          FakeBlob.fake = FB_proto.fake = true;
          while (file_ex_code--) {
              FileException.prototype[file_ex_codes[file_ex_code]] = file_ex_code + 1;
          }
          if (!real_URL.createObjectURL) {
              URL = view.URL = {};
          }
          URL.createObjectURL = function(blob) {
              var
                  type = blob.type
                  , data_URI_header
                  ;
              if (type === null) {
                  type = "application/octet-stream";
              }
              if (blob instanceof FakeBlob) {
                  data_URI_header = "data:" + type;
                  if (blob.encoding === "base64") {
                      return data_URI_header + ";base64," + blob.data;
                  } else if (blob.encoding === "URI") {
                      return data_URI_header + "," + decodeURIComponent(blob.data);
                  } if (btoa) {
                      return data_URI_header + ";base64," + btoa(blob.data);
                  } else {
                      return data_URI_header + "," + encodeURIComponent(blob.data);
                  }
              } else if (real_create_object_URL) {
                  return real_create_object_URL.call(real_URL, blob);
              }
          };
          URL.revokeObjectURL = function(object_URL) {
              if (object_URL.substring(0, 5) !== "data:" && real_revoke_object_URL) {
                  real_revoke_object_URL.call(real_URL, object_URL);
              }
          };
          FBB_proto.append = function(data/*, endings*/) {
              var bb = this.data;
              // decode data to a binary string
              if (Uint8Array && (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
                  var
                      str = ""
                      , buf = new Uint8Array(data)
                      , i = 0
                      , buf_len = buf.length
                      ;
                  for (; i < buf_len; i++) {
                      str += String.fromCharCode(buf[i]);
                  }
                  bb.push(str);
              } else if (get_class(data) === "Blob" || get_class(data) === "File") {
                  if (FileReaderSync) {
                      var fr = new FileReaderSync;
                      bb.push(fr.readAsBinaryString(data));
                  } else {
                      // async FileReader won't work as BlobBuilder is sync
                      throw new FileException("NOT_READABLE_ERR");
                  }
              } else if (data instanceof FakeBlob) {
                  if (data.encoding === "base64" && atob) {
                      bb.push(atob(data.data));
                  } else if (data.encoding === "URI") {
                      bb.push(decodeURIComponent(data.data));
                  } else if (data.encoding === "raw") {
                      bb.push(data.data);
                  }
              } else {
                  if (typeof data !== "string") {
                      data += ""; // convert unsupported types to strings
                  }
                  // decode UTF-16 to binary string
                  bb.push(unescape(encodeURIComponent(data)));
              }
          };
          FBB_proto.getBlob = function(type) {
              if (!arguments.length) {
                  type = null;
              }
              return new FakeBlob(this.data.join(""), type, "raw");
          };
          FBB_proto.toString = function() {
              return "[object BlobBuilder]";
          };
          FB_proto.slice = function(start, end, type) {
              var args = arguments.length;
              if (args < 3) {
                  type = null;
              }
              return new FakeBlob(
                  this.data.slice(start, args > 1 ? end : this.data.length)
                  , type
                  , this.encoding
              );
          };
          FB_proto.toString = function() {
              return "[object Blob]";
          };
          FB_proto.close = function() {
              this.size = this.data.length = 0;
          };
          return FakeBlobBuilder;
      }(view));

  view.Blob = function Blob(blobParts, options) {
      var type = options ? (options.type || "") : "";
      var builder = new BlobBuilder();
      if (blobParts) {
          for (var i = 0, len = blobParts.length; i < len; i++) {
              builder.append(blobParts[i]);
          }
      }
      return builder.getBlob(type);
  };
}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this.content || this));

Export2Excel.js↓

// require('script-loader!file-saver');//保存文件用
// // require('script-loader!@/excel/Blob');//转二进制用
// require('./Blob');//转二进制用
// require('script-loader!xlsx/dist/xlsx.core.min');//xlsx核心
import { saveAs } from "file-saver";
// import XLSX from 'xlsx'
import * as XLSX from "xlsx";
function generateArray(table) {
    var out = [];
    var rows = table.querySelectorAll('tr');
    var ranges = [];
    for (var R = 0; R < rows.length; ++R) {
        var outRow = [];
        var row = rows[R];
        var columns = row.querySelectorAll('td');
        for (var C = 0; C < columns.length; ++C) {
            var cell = columns[C];
            var colspan = cell.getAttribute('colspan');
            var rowspan = cell.getAttribute('rowspan');
            var cellValue = cell.innerText;
            if (cellValue !== "" && cellValue == +cellValue) cellValue = +cellValue;

            //Skip ranges
            ranges.forEach(function (range) {
                if (R >= range.s.r && R <= range.e.r && outRow.length >= range.s.c && outRow.length <= range.e.c) {
                    for (var i = 0; i <= range.e.c - range.s.c; ++i) outRow.push(null);
                }
            });

            //Handle Row Span
            if (rowspan || colspan) {
                rowspan = rowspan || 1;
                colspan = colspan || 1;
                ranges.push({ s: { r: R, c: outRow.length }, e: { r: R + rowspan - 1, c: outRow.length + colspan - 1 } });
            }
            ;

            //Handle Value
            outRow.push(cellValue !== "" ? cellValue : null);

            //Handle Colspan
            if (colspan) for (var k = 0; k < colspan - 1; ++k) outRow.push(null);
        }
        out.push(outRow);
    }
    return [out, ranges];
};

function datenum(v, date1904) {
    if (date1904) v += 1462;
    var epoch = Date.parse(v);
    return (epoch - new Date(Date.UTC(1899, 11, 30))) / (24 * 60 * 60 * 1000);
}

function sheet_from_array_of_arrays(data, opts) {
    var ws = {};
    var range = { s: { c: 10000000, r: 10000000 }, e: { c: 0, r: 0 } };
    for (var R = 0; R != data.length; ++R) {
        for (var C = 0; C != data[R].length; ++C) {
            if (range.s.r > R) range.s.r = R;
            if (range.s.c > C) range.s.c = C;
            if (range.e.r < R) range.e.r = R;
            if (range.e.c < C) range.e.c = C;
            var cell = { v: data[R][C] };
            if (cell.v == null) continue;
            var cell_ref = XLSX.utils.encode_cell({ c: C, r: R });

            if (typeof cell.v === 'number') cell.t = 'n';
            else if (typeof cell.v === 'boolean') cell.t = 'b';
            else if (cell.v instanceof Date) {
                cell.t = 'n';
                cell.z = XLSX.SSF._table[14];
                cell.v = datenum(cell.v);
            }
            else cell.t = 's';

            ws[cell_ref] = cell;
        }
    }
    if (range.s.c < 10000000) ws['!ref'] = XLSX.utils.encode_range(range);
    return ws;
}

function Workbook() {
    if (!(this instanceof Workbook)) return new Workbook();
    this.SheetNames = [];
    this.Sheets = {};
}

function s2ab(s) {
    var buf = new ArrayBuffer(s.length);
    var view = new Uint8Array(buf);
    for (var i = 0; i != s.length; ++i) view[i] = s.charCodeAt(i) & 0xFF;
    return buf;
}

export function export_table_to_excel(id) {
    var theTable = document.getElementById(id);
    var oo = generateArray(theTable);
    var ranges = oo[1];

    /* original data */
    var data = oo[0];
    var ws_name = "SheetJS";

    var wb = new Workbook(), ws = sheet_from_array_of_arrays(data);

    /* add ranges to worksheet */
    // ws['!cols'] = ['apple', 'banan'];
    ws['!merges'] = ranges;

    /* add worksheet to workbook */
    wb.SheetNames.push(ws_name);
    wb.Sheets[ws_name] = ws;

    var wbout = XLSX.write(wb, { bookType: 'xlsx', bookSST: false, type: 'binary' });

    saveAs(new Blob([s2ab(wbout)], { type: "application/octet-stream" }), "test.xlsx")
}

function formatJson(jsonData) {
}
export function export_json_to_excel(th, jsonData, defaultTitle) {

    /* original data */

    var data = jsonData;
    data.unshift(th);
    var ws_name = "SheetJS";

    var wb = new Workbook(), ws = sheet_from_array_of_arrays(data);


    /* add worksheet to workbook */
    wb.SheetNames.push(ws_name);
    wb.Sheets[ws_name] = ws;

    var wbout = XLSX.write(wb, { bookType: 'xlsx', bookSST: false, type: 'binary' });
    var title = defaultTitle || '列表'
    saveAs(new Blob([s2ab(wbout)], { type: "application/octet-stream" }), title + ".xlsx")
}

Export2ExcelPro.js↓

/* eslint-disable */
import { saveAs } from 'file-saver'
import XLSX from 'xlsx-style'

function generateArray(table) {
  var out = []
  var rows = table.querySelectorAll('tr')
  var ranges = []
  for (var R = 0; R < rows.length; ++R) {
    var outRow = []
    var row = rows[R]
    var columns = row.querySelectorAll('td')
    for (var C = 0; C < columns.length; ++C) {
      var cell = columns[C]
      var colspan = cell.getAttribute('colspan')
      var rowspan = cell.getAttribute('rowspan')
      var cellValue = cell.innerText
      if (cellValue !== '' && cellValue == +cellValue) cellValue = +cellValue

      //Skip ranges
      ranges.forEach(function (range) {
        if (R >= range.s.r && R <= range.e.r && outRow.length >= range.s.c && outRow.length <= range.e.c) {
          for (var i = 0; i <= range.e.c - range.s.c; ++i) outRow.push(null)
        }
      })

      //Handle Row Span
      if (rowspan || colspan) {
        rowspan = rowspan || 1
        colspan = colspan || 1
        ranges.push({
          s: {
            r: R,
            c: outRow.length
          },
          e: {
            r: R + rowspan - 1,
            c: outRow.length + colspan - 1
          }
        })
      }

      //Handle Value
      outRow.push(cellValue !== '' ? cellValue : null)

      //Handle Colspan
      if (colspan) for (var k = 0; k < colspan - 1; ++k) outRow.push(null)
    }
    out.push(outRow)
  }
  return [out, ranges]
}

function datenum(v, date1904) {
  if (date1904) v += 1462
  var epoch = Date.parse(v)
  return (epoch - new Date(Date.UTC(1899, 11, 30))) / (24 * 60 * 60 * 1000)
}

function sheet_from_array_of_arrays(data, opts, fontStyle) {
  var ws = {}
  var range = {
    s: {
      c: 10000000,
      r: 10000000
    },
    e: {
      c: 0,
      r: 0
    }
  }
  let _opts = []
  if (opts) {
    _opts = opts
  }
  for (var R = 0; R != data.length; ++R) {
    for (var C = 0; C != data[R].length; ++C) {
      if (range.s.r > R) range.s.r = R
      if (range.s.c > C) range.s.c = C
      if (range.e.r < R) range.e.r = R
      if (range.e.c < C) range.e.c = C
      var cell = {
        v: data[R][C]
      }
      //给单个表头添加斜线样式
      if (_opts) {
        if (R == _opts[0] && C == _opts[1]) {
          cell = {
            v: data[R][C],
            s: defaultCellStyle
          }
        }
      }
      //给某一单元格的字体自定义样式
      if (fontStyle) {
        if (R == data.length - 3 && C == 1) {
          cell = {
            v: data[R][C],
            s: fontCellStyle
          }
        }
      }
      if (cell.v == null) continue
      var cell_ref = XLSX.utils.encode_cell({
        c: C,
        r: R
      })

      if (typeof cell.v === 'number') cell.t = 'n'
      else if (typeof cell.v === 'boolean') cell.t = 'b'
      else if (cell.v instanceof Date) {
        cell.t = 'n'
        cell.z = XLSX.SSF._table[14]
        cell.v = datenum(cell.v)
      } else cell.t = 's'

      ws[cell_ref] = cell
    }
  }
  if (range.s.c < 10000000) ws['!ref'] = XLSX.utils.encode_range(range)
  return ws
}
let fontCellStyle = {
  font: {
    name: '宋体',
    sz: 18,
    color: { rgb: 'ff0000' },
    bold: true
  },
  alignment: {
    //对齐方式
    horizontal: 'center', //水平居中
    vertical: 'center' //竖直居中
  }
}

let defaultCellStyle = {
  alignment: {
    horizontal: 'center',
    vertical: 'center',
    indent: 0
  },
  border: {
    diagonalDown: true, //斜线方向
    diagonal: {
      color: { rgb: '303133' },
      style: 'thin'
    } //diagonalDown与diagonal必须同时使用
  }
}
function Workbook() {
  if (!(this instanceof Workbook)) return new Workbook()
  this.SheetNames = []
  this.Sheets = {}
}

function s2ab(s) {
  var buf = new ArrayBuffer(s.length)
  var view = new Uint8Array(buf)
  for (var i = 0; i != s.length; ++i) view[i] = s.charCodeAt(i) & 0xff
  return buf
}

export function export_table_to_excel(id) {
  var theTable = document.getElementById(id)
  var oo = generateArray(theTable)
  var ranges = oo[1]

  /* original data */
  var data = oo[0]
  var ws_name = 'SheetJS'

  var wb = new Workbook(),
    ws = sheet_from_array_of_arrays(data)

  /* add ranges to worksheet */
  // ws['!cols'] = ['apple', 'banan'];
  ws['!merges'] = ranges

  /* add worksheet to workbook */
  wb.SheetNames.push(ws_name)
  wb.Sheets[ws_name] = ws

  var wbout = XLSX.write(wb, {
    bookType: 'xlsx',
    bookSST: false,
    type: 'binary'
  })

  saveAs(
    new Blob([s2ab(wbout)], {
      type: 'application/octet-stream'
    }),
    'test.xlsx'
  )
}
/*自定义表头样式*/
let arr = ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1', 'K1', 'L1', 'M1', 'N1', 'O1', 'P1', 'Q1', 'R1', 'S1', 'T1', 'U1', 'V1', 'W1', 'X1', 'Y1', 'Z1']
let arr1 = ['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2', 'J2', 'K2', 'L2', 'M2', 'N2', 'O2', 'P2', 'Q2', 'R2', 'S2', 'T2', 'U2', 'V2', 'W2', 'X2', 'Y2', 'Z2']
let arr2 = ['A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'I3', 'J3', 'K3', 'L3', 'M3', 'N3', 'O3', 'P3', 'Q3', 'R3', 'S3', 'T3', 'U3', 'V3', 'W3', 'X3', 'Y3', 'Z3']
let style = {
  font: {
    color: { rgb: '000000' },
    bold: true
  },
  border: {
    color: {
      auto: 1
    },
    top: {
      style: 'thin'
    },
    bottom: {
      style: 'thin'
    },
    left: {
      style: 'thin'
    },
    right: {
      style: 'thin'
    }
  },
  alignment: {
    horizontal: 'center',
    vertical: 'center'
  },
  fill: {
    fgColor: { rgb: 'DCDFE6' }
  }
}
/*二级表头*/
export function export_json_to_excelPro({
  multiHeader = [], // 第一行表头
  multiHeader2 = [], // 第二行表头
  data,
  filename, //文件名
  merges = [], // 合并
  autoWidth = true,
  bookType = 'xlsx',
  diagonal = [], //斜线
  fontStyle = false
} = {}) {
  /* original data */
  filename = filename || '列表'
  data = [...data]
  /*data.unshift(header);*/
  var ws_name = 'SheetJS'

  data.unshift(multiHeader)
  data.unshift(multiHeader2)
  var wb = new Workbook() //加样式,如斜线
  if (diagonal) {
    var ws = sheet_from_array_of_arrays(data, diagonal, fontStyle)
  } else {
    var ws = sheet_from_array_of_arrays(data)
  }
  if (merges.length > 0) {
    if (!ws['!merges']) ws['!merges'] = []
    merges.forEach(item => {
      ws['!merges'].push(XLSX.utils.decode_range(item))
    })
  }
  if (autoWidth) {
    /*设置worksheet每列的最大宽度*/
    const colWidth = data.map(row =>
      row.map(val => {
        /*先判断是否为null/undefined*/
        if (val == null) {
          return {
            wch: 10
          }
        } else if (val.toString().charCodeAt(0) > 255) {
          /*再判断是否为中文*/
          return {
            wch: val.toString().length * 2
          }
        } else {
          return {
            wch: val.toString().length
          }
        }
      })
    )
    /*以第一行为初始值*/
    let result = colWidth[0]
    for (let i = 1; i < colWidth.length; i++) {
      for (let j = 0; j < colWidth[i].length; j++) {
        if (result[j]['wch'] < colWidth[i][j]['wch']) {
          result[j]['wch'] = colWidth[i][j]['wch']
        }
      }
    }
    ws['!cols'] = result
  }

  /* add worksheet to workbook */
  wb.SheetNames.push(ws_name)
  wb.Sheets[ws_name] = ws
  var dataInfo = wb.Sheets[wb.SheetNames[0]]

  for (var i = 0; i < multiHeader.length; i++) {
    dataInfo[arr[i]].s = style
  }
  for (var j = 0; j < multiHeader2.length; j++) {
    dataInfo[arr1[j]].s = style
  }
  var wbout = XLSX.write(wb, { bookType: 'xlsx', bookSST: false, type: 'binary' })
  saveAs(new Blob([s2ab(wbout)], { type: 'application/octet-stream' }), `${filename}.${bookType}`)
}
/*三级表头的*/
export function export_json_to_excelProPlus({
  multiHeader = [], // 第一行表头
  multiHeader2 = [], // 第二行表头
  header, // 第三行表头
  data,
  filename, //文件名
  merges = [], // 合并
  autoWidth = true,
  bookType = 'xlsx'
} = {}) {
  /* original data */
  filename = filename || '列表'
  data = [...data]
  var ws_name = 'SheetJS'
  data.unshift(multiHeader)
  data.unshift(multiHeader2)
  data.unshift(header)
  var wb = new Workbook()
  var ws = sheet_from_array_of_arrays(data)

  if (merges.length > 0) {
    if (!ws['!merges']) ws['!merges'] = []
    merges.forEach(item => {
      ws['!merges'].push(XLSX.utils.decode_range(item))
    })
  }
  if (autoWidth) {
    /*设置worksheet每列的最大宽度*/
    const colWidth = data.map(row =>
      row.map(val => {
        /*先判断是否为null/undefined*/
        if (val == null) {
          return {
            wch: 10
          }
        } else if (val.toString().charCodeAt(0) > 255) {
          /*再判断是否为中文*/
          return {
            wch: val.toString().length * 2
          }
        } else {
          return {
            wch: val.toString().length
          }
        }
      })
    )
    /*以第一行为初始值*/
    let result = colWidth[0]
    for (let i = 1; i < colWidth.length; i++) {
      for (let j = 0; j < colWidth[i].length; j++) {
        if (result[j]['wch'] < colWidth[i][j]['wch']) {
          result[j]['wch'] = colWidth[i][j]['wch']
        }
      }
    }
    ws['!cols'] = result
  }

  /* add worksheet to workbook */
  wb.SheetNames.push(ws_name)
  wb.Sheets[ws_name] = ws
  var dataInfo = wb.Sheets[wb.SheetNames[0]]
  for (var i = 0; i < multiHeader.length; i++) {
    dataInfo[arr[i]].s = style
  }
  for (var j = 0; j < multiHeader2.length; j++) {
    dataInfo[arr1[j]].s = style
  }
  for (var k = 0; k < header.length; k++) {
    dataInfo[arr2[k]].s = style
  }
  var wbout = XLSX.write(wb, { bookType: 'xlsx', bookSST: false, type: 'binary' })
  saveAs(new Blob([s2ab(wbout)], { type: 'application/octet-stream' }), `${filename}.${bookType}`)
}

excelExport.js↓

import { export_json_to_excel } from '../vendor/Export2Excel'
import { export_json_to_excelPro } from '../vendor/Export2ExcelPro'
import { export_json_to_excelProPlus } from '../vendor/Export2ExcelPro'

function exportExcel({ header, filterVal, filename, tableData }) {
  var data = formatJson(filterVal, tableData)

  export_json_to_excel(header, data, filename)
}

function exportExcelPro({ multiHeader, multiHeader2, data, merges, filename, filterVal }) {
  var data = formatJson(filterVal, data)

  export_json_to_excelPro({
    multiHeader,
    multiHeader2,
    data,
    merges,
    filename,
    filterVal
  })
}
function exportExcelProPlus({
  header,
  multiHeader,

  multiHeader2,
  data,
  merges,
  filename,
  filterVal
}) {
  var data = formatJson(filterVal, data)

  export_json_to_excelProPlus({
    header,
    multiHeader,
    multiHeader2,
    data,
    merges,
    filename,
    filterVal
  })
}
function formatJson(filterVal, tableData) {
  return tableData.map(v => {
    return filterVal.map(j => {
      return v[j]
    })
  })
}
let export_method = {
  exportExcel: exportExcel,
  exportExcelPro: exportExcelPro,
  exportExcelProPlus: exportExcelProPlus
}
export default export_method

使用↓  其中导出2是 带有二级标题的表格导出, 导出1(参考上一篇文章)

<template>
  <div>
    <button @click="exports1">导出基础表头</button>
    <button @click="exports2">导出二级表头</button>
    <button @click="exports3">导出三级表头</button>
    <el-table :data="tableData" border style="width: 100%">
      <el-table-column prop="date" label="日期" width="180"> </el-table-column>
      <el-table-column prop="name" label="姓名" width="180"> </el-table-column>
      <el-table-column prop="address" label="地址"> </el-table-column>
    </el-table>
  </div>
</template>

<script>
import export_method from "../utils/excelExport.js";

export default {
  data() {
    return {
      tableData: [
        {
          date: "2016-05-02",
          name: "王小虎",
          address: "上海市普陀区金沙江路 1518 弄",
          age: 1,
          sex: "男",
        },
        {
          date: "2016-05-04",
          name: "王小虎",
          address: "上海市普陀区金沙江路 1517 弄",
          age: 1,
          sex: "男",
        },
        {
          date: "2016-05-01",
          name: "王小虎",
          address: "上海市普陀区金沙江路 1519 弄",
          age: 1,
          sex: "男",
        },
        {
          date: "2016-05-03",
          name: "王小虎",
          address: "上海市普陀区金沙江路 1516 弄",
          age: 1,
          sex: "男",
        },
      ],
    };
  },
  methods: {
    exports1() {
      var header = ["日期", "姓名", "地址"];
      var filterVal = ["date", "name", "address"];
      var filename = "demoExcel";
      export_method.exportExcel({
        header,
        filterVal,
        filename,
        tableData: this.tableData,
      });
    },
    exports2() {
      const multiHeader2 = ["日期", "姓名", "其他", "", ""]; //第一层  数量相同
      const multiHeader = ["", "", "地址", "年龄", "性别"]; //第二层  数量相同
      const filterVal = ["date", "name", "address", "age", "sex"];
      const merges = ["A1:A2", "B1:B2", "C1:E1"]; // multiHeader2
      const filterName = "测试";
      export_method.exportExcelPro({
        multiHeader,
        multiHeader2,
        data: this.tableData,
        merges,
        autoWidth: true,
        filename: filterName,
        filterVal,
      });
    },
    exports3() {
      const header = ["日期", "姓名", "其他", "", ""];
      const multiHeader2 = ["", "", "个人", "", "家庭"];
      const multiHeader = ["", "中文名", "年龄", "性别", "地址"];
      const filterVal = ["date", "name", "age", "sex", "address"];
      // 这里要注意 header  和 filterVal 的数组长度一定要相等,否则会报错
      const merges = ["A1:A3", "B1:B2", "C1:E1", "C2:D2"];
      const filterName = "测试";
      export_method.exportExcelProPlus({
        header,
        multiHeader,
        multiHeader2,
        data: this.tableData,
        merges,
        autoWidth: true,
        filename: filterName,
        filterVal,
      });
    },
  },
};
</script>

难点:↓

const header = ["日期", "姓名", "其他", "", ""];   //表头第一行
const multiHeader2 = ["", "", "个人", "", "家庭"];//表头第二行
const multiHeader = ["", "中文名", "年龄", "性别", "地址"]; //表头第三行
const filterVal = ["date", "name", "age", "sex", "address"];//对应字段
// 这里要注意 header  和 filterVal 的数组长度一定要相等,否则会报错
const merges = ["A1:A3", "B1:B2", "C1:E1", "C2:D2"];//从左到右存放横跨两个单元格的记录

一一对应去理解

本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

vue-excel导出-单表头,多表头导出,Export2Excel.js Blob.js 的相关文章

随机推荐

  • win10下的anaconda安装pymysql

    1 打开anaconda的终端 即 anaconda prompt 2 输入命令 pip install pymysql ps 其余包都可以使用pip install xxx来完成安装 若下载失败 可在一下链接查找相关包进行安装 https
  • Java 单例模式、工厂模式、代理模式

    文章目录 单例模式 概念 单例模式的类型 破坏单例模式 枚举实现单例模式 工厂模式 概述 简单工厂模式 工厂方法 抽象工厂 代理模式 Proxy 概述 静态代理 动态代理 单例模式 概念 单例模式指在内存中创建对象且仅创建一次的设计模式 在
  • 《Pyramid Scene Parsing Network》

    Pytorch代码 1 研究问题 目前基于FCN的语义分割网络缺乏利用不同尺度全局上下文信息的能力 对于复杂图像的语义分割 如ADE20K数据集 存在问题 注 感受野的大小可以粗略表示为使用上下文信息的程度 2 研究方法 提出了金字塔场景理
  • Mybatis的常用注解

    加载配置文件的时候 绝对路径和相对路径的写法都不太好用 我们经常使用的两种方法第一种就是使用类加载器 他只能读取类路径的配置文件 第二种就是使用ServletContext对象的getRealPath 函数 mybatis的常用注解 1 与
  • jsp+servlet+ajax实现登录

    该案列使用jsp servlet ajax实现登录 页面简洁大方 弹框都是封装的插件 整体案列采用三层的模式 链接数据库方面用的是dbcp的链接池 数据库时mysql 运行效果如下图 下载地址 jsp servlet ajax实现登录案例
  • c++(对象赋值与拷贝构造函数)

    对象赋值 同一个类的对象之间可以相互赋值 默认情况下 进行的是对象成员之间的复制 也称为 按位复制 或 浅复制 当类的数据成员中没有指针类型的变量时 直接对两个对象进行赋值没有问题 但是一旦类的数据成员含有指针变量 那么直接对这两个对象进行
  • MySQL常用基础 - 小白必看(二)

    MySQL数据库基本操作 一 DDL 概念 是一个数据定义语言 该语言部分包括 1 对数据库的常用操作 创建数据库 1 create database 数据库名 直接删除 2 create database if not exists 数据
  • 《effective java》中关于解决构造函数/方法签名包含大量参数的解决方法

    针对构造方法 重叠构造器模式 重叠构造器模式是一种编程中的反模式 指的是一个类有多个构造函数 每个构造函数都有不同数量的参数 从而可以根据不同的情况创建对象 这种方式会导致代码可读性和可维护性降低 因为构造函数过多 参数顺序容易混淆 Jav
  • 使用 Composer 安装 JWT 失败错误 The "https://packagist.org/packages.json" file could not be downloaded 解决方案

    错误信息 The https packagist laravel china org packages json file could not be downloaded SSL operation failed with code 1 O
  • Redis3.0集群方案分析

    在Redis3 0集群出来之前 大家都对作者antirez寄予厚望 因为Redis从来没有让我们失望过 现在Redis3 0集群出来了 网上出了很多评论文章 都说他的功能多么强大 包括下面这张图是彻底把我欺骗了 等到我把Redis3 0客户
  • Qmake VS Cmake 对比讲解

    用 cmake 构建Qt工程 对比qmake进行学习 cmake vs qmake qmake 是为 Qt 量身打造的 使用起来非常方便 cmake 使用上不如qmake简单直接 但复杂换来的是强大的功能 内置的 out of source
  • 一点浩然气,千里快哉风

    到英国访学一年 也认识了一些其他来自国内的访问学者 平时周末也经常一起徒步聚餐 从今年1月份以来 基本每个月有一个小伙伴回国 随着身边的小伙伴越来越少 以及自己也要不久回国了 心里不免有些人走茶凉 曲终人散的落寞 总体上 来英国的访问学者很
  • 【模板】快速排序

    题目链接 洛谷 P1177 模板 快速排序 1960年由查尔斯 安东尼 理查德 霍尔 Charles Antony Richard Hoare 缩写为C A R Hoare 提出 如下图所示 快速排序的执行流程为 从序列中选择一个轴点元素
  • C/C++ getcwd 获取项目的运行路径

    在Linux下做QT项目时 需要获取项目的运行路径 于是用getcwd函数进行获取 然后在Windows下进行测试 发现获取到的是程序的项目路径 即代码文件路径 然后再Linux QT中测试 获取到的又是运行路径 这就很纳闷了 经过再三测试
  • 2-1、Lua数据结构

    2 1 Lua数据结构 文章目录 2 1 Lua数据结构 1 数组 2 矩阵和多维数组 3 链表 4 队列和双向队列 5 集合和包 6 字符串缓冲 table是Lua中唯一的数据结构 其他语言所提供的数据结构 如 arrays record
  • python crop函数-图片裁剪函数

    crop 函数的参数形式是 x1 y1 x2 y2 这个元组是作为一个参数的 参考代码 from PIL import Image im Image open d 22 jpg im1 im crop im size 0 4 im size
  • linux中进入目录命令是什么,linux进入目录的命令是什么

    linux进入目录的命令是 cd 该命令的作用是切换至指定目录下 语法格式为 cd dirName 参数 dirName 表示要切换的目标目录 可以是绝对路径或相对路径 若目录名称省略 则变换至使用者的home目录 本教程操作环境 Red
  • bp神经网络时间序列预测,bp神经网络有几个阶段

    什么是BP神经网络 BP算法的基本思想是 学习过程由信号正向传播与误差的反向回传两个部分组成 正向传播时 输入样本从输入层传入 经各隐层依次逐层处理 传向输出层 若输出层输出与期望不符 则将误差作为调整信号逐层反向回传 对神经元之间的连接权
  • SwiftUI接入穿山甲开屏广告

    研究了一下SwiftUI怎么接入穿山甲 基于穿山甲sdk版本 4 7 0 8 例子地址 1 首先要先注册一个账号 穿山甲地址 在广告变现 gt 流量 gt 应用中创建一个应用并记录下应用ID 在广告变现 gt 流量 gt 代码位创建一个代码
  • vue-excel导出-单表头,多表头导出,Export2Excel.js Blob.js

    效果如图 一级导出 二级导出 如下图 三级导出 Export2Excel js Blob js 等 安装依赖 npm install S file saver npm install save xlsx 0 10 0 npm install