JS implements processing and downloading method of base64 file

// Get the backend returned by the unfinished base64, file name, file typefunction downladBase64(item) {
    APINAME().then((res) => {
            let base64 = getBase64Type() +  //The type splicing backend gives incomplete base64            ('Split complete base64', base64)
            downloadFileByBase64(base64, )
    })
}

//According to the file suffix, get the base64 prefix differently, splice the complete base64function getBase64Type(type) {
    switch (type) {
        case 'txt':
            return 'data:text/plain;base64,'
        case 'doc':
            return 'data:application/msword;base64,'
        case 'docx':
            return 'data:application/;base64,'
        case 'xls':
            return 'data:application/-excel;base64,'
        case 'xlsx':
            return 'data:application/;base64,'
        case 'pdf':
            return 'data:application/pdf;base64,'
        case 'pptx':
            return 'data:application/;base64,'
        case 'ppt':
            return 'data:application/-powerpoint;base64,'
        case 'png':
            return 'data:image/png;base64,'
        case 'jpg':
            return 'data:image/jpeg;base64,'
        case 'gif':
            return 'data:image/gif;base64,'
        case 'svg':
            return 'data:image/svg+xml;base64,'
        case 'ico':
            return 'data:image/x-icon;base64,'
        case 'bmp':
            return 'data:image/bmp;base64,'
    }
}

//Convert full base64 to blobfunction dataURLtoBlob(dataurl) {
    var arr = (","),
        mime = arr[0].match(/:(.*?);/)[1],
        bstr = atob(arr[1]),
        n = ,
        u8arr = new Uint8Array(n)
    while (n--) {
        u8arr[n] = (n)
    }
    return new Blob([u8arr], { type: mime })
}

// Convert base64 to fileexport default async function base64ImgtoFile(dataurl, filename = 'file') {
    try {
        const arr = (',')
        const mime = arr[0].match(/:(.*?);/)[1]
        const suffix = ('/')[1]
        const bstr = atob(arr[1])
        let n = 
        const u8arr = new Uint8Array(n)
        while (n--) {
            u8arr[n] = (n)
        }
        return new File([u8arr], `${filename}.${suffix}`, {
            type: mime
        })
    } catch (err) {
        return (err);
    }
}

// * desc: Download parameter entry// * @param base64: Returns the blob object or link to the data// * @param fileName: file name tag after downloadfunction downloadFileByBase64(base64, fileName) {
    var myBlob = dataURLtoBlob(base64)
    var myUrl = (myBlob)
    downloadFile(myUrl, fileName)
}
// * desc: Download method// * @param url: Returns the blob object or link to the data// * @param fileName: file name tag after downloadfunction downloadFile(url, name = "What's the fuvk") {
    ('url==', url)
    var a = ("a")
    ("href", url)
    ("download", name)
    ("target", "_blank")
    let clickEvent = ("MouseEvents")
    ("click", true, true)
    (clickEvent)
}
export default downloadFileByBase64

export const downloadImage = (imgsrc, name) => { // Download the image address and image name  var image = new Image()
  ('crossOrigin', 'anonymous')
   = function() {
    var canvas = ('canvas')
     = 
     = 
    var context = ('2d')
    (image, 0, 0, , )
    var url = ('image/png') // Get the base64 encoded data of the image
    var a = ('a') // Generate an element a    var event = new MouseEvent('click') // Create a click event     = name || 'photo' // Set the picture name     = url // Set the generated URL to attribute    (event) // Trigger a click event  }
   = imgsrc
}

/**
  * Download the file
  *
  * @param {*} path Download address/download request address.
  * @param {string} [name=''] The name of the download file (considering compatibility issues, it is best to add a suffix name
  */
export const downloadFile = (path, name = '') => {
        const download = (href) => {
            const a = ('a')
             = 'none'
             = href
             = name
            (a)
            ()
            (a)
        }

        if (isIE()) {
            download(path)
        } else {
            const xhr = new XMLHttpRequest()
            ('get', path)
             = 'blob'
            ()
             = (e) => {
                const { status, response } = 
                if (status === 200 || status === 304) {
                    const fileReader = new FileReader()
                    (response)
                     = (ev) => {
                        download()
                    }
                }
            }
        }
    }
    // Determine whether IE isexport function isIE() {
    return /msie|trident/.test(())
}

import JSZip from 'jszip'
import FileSaver from 'file-saver'
import axios from 'axios'
// Batch exportfunction getFile(url) {
    return new Promise((resolve, reject) => {
        axios({
            method: 'get',
            url,
            responseType: 'arraybuffer'
        }).then(data => {
            resolve()
        }).catch(error => {
            (error, url, 'getfile-err')
                // reject(());
            resolve('')
        })
    })
}

/**
  *
  * @param {Array} files The file object array to be downloaded [{name,url}]
  * @param {String} zipName zipName
  * @param {Function} callback after downloading
  */
function batchDownZip(files, zipName, callback) {
    const data = files
    const zip = new JSZip()
    const cache = {}
    const promises = []
    (item => {
        // (getFile, 'getFile')
        const promise = getFile().then(result_file => { // Download the file and coexist as an ArrayBuffer object            let file_name =  // Get the file name            let lastIndex = file_name.lastIndexOf('/')
            (result_file, file_name, lastIndex, 'result_file111')
                //Put all files into the same level            if (lastIndex > -1) {
                file_name = file_name.slice(lastIndex + 1)
            }
            (result_file, file_name, lastIndex, 'result_file222')

            (file_name, result_file, { binary: true }) // Add files one by one            cache[file_name] = data
        })
        (promise)
    })
    (promises).then(() => {
        ({ type: 'blob' }).then(content => {
            // Generate binary streams            (content, zipName) // Use file-saver to save the file. Customize the file name            callback && callback()
        })
    })
}

export default batchDownZip