Nodejs http https模块get请求 管道下载 / 收集完转其他

import https from 'https'

import http from 'http'

const stream = fs.createWriteStream(path)

const httpName = this.fileUrl.includes('https') ? https : http

const request = httpName.get(

          this.fileUrl,

          {

            headers: {  }, // 可携带token

            timeout: 0, // 0 不超时 

            rejectUnauthorized: false // 用于https证书

          },

          (res: any) => {

            // 文件总长度

            const len = parseInt(res.headers['content-length'])

            let cur = 0

            // 通过pipe管道写入

            res.pipe(stream)

            res.on('data', (chunk: any) => {

              chunks.push(chunk)

              cur += chunk.length

              // 当前进度

              const progress: number = Number(((100.0 * cur) / len).toFixed(2))

              // 当前下载了多少M

              // const currProgress = (cur / 1048576).toFixed(2)

              // console.log('当前下载进度:' + progress)

            })

            // 下载结束 -> 后触发 stream.on('finish')

            res.on('end', () => {

               // 如果用了pipe，就不要用这个。 Buffer.concat(chunks).toString('base64')就可以转换为base64格式了

              //  stream.write(Buffer.concat(chunks))

              //  stream.end()

              }

            })

          }

        )

注意：如果需要对文件加解密就是对Buffer加解密，例如SM4对Buffer加解密

const sm4 = require('sm-crypto').sm4

export function stringToHex(str: string) {

  const len: number = str.length

  let val = ''

  for (let i = 0; i < len; i++) {

    val += '' + str.charCodeAt(i).toString(16)

  }

  return val

}
// 解密

const deChunk = sm4.decrypt(Buffer.concat(chunks), stringToHex(key), { output: 'array' })

new Blob([Buffer.from(deChunk)], { type: 'image/png' })

// 加密  （对buffer加密，加密后在转base64 或者 Blob）

const enChunk = sm4.encrypt(getBufferByFile(file), stringToHex(key),  { output: 'array' })

blob -> new Blob([Buffer.from(enChunk)], { type: 'image/png' })

base64 -> Buffer.from(enChunk).toString('base64')

再调用接口上传

文件转Buffer(二进制)

const getBufferByFile = async (file: File | Blob): Promise<Buffer> => {

  const arrayBuffer = await file.arrayBuffer()

  return Buffer.from(arrayBuffer)

}

Buffer转Base64

Buffer.from(arrayBuffer).toString('base64')

base64转Blob

const base64ToBlob = (b64data: string, contentType: string, sliceSize = 512) => {

  return new Promise((resolve) => {

    // 使用 atob() 方法将数据解码

    const byteCharacters = atob(b64data)

    const byteArrays = []

    for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {

      const slice = byteCharacters.slice(offset, offset + sliceSize)

      const byteNumbers = []

      for (let i = 0; i < slice.length; i++) {

        byteNumbers.push(slice.charCodeAt(i))

      }

      // 8 位无符号整数值的类型化数组。内容将初始化为 0。

      // 如果无法分配请求数目的字节，则将引发异常。

      byteArrays.push(new Uint8Array(byteNumbers))

    }

    let result = new Blob(byteArrays, {

      type: contentType

    })

    result = Object.assign(result, {

      // jartto: 这里一定要处理一下 URL.createObjectURL

      preview: URL.createObjectURL(result),

      name: `图片示例.png`

    })

    resolve(result)

  })

}

blob转base64

const blobToBase64 = (blob: Blob | File): Promise<string> => {

  return new Promise((resolve, reject) => {

    const fileReader = new FileReader()

    fileReader.onload = (e) => {

      e.target ? resolve(e.target.result as string) : reject(new Error('文件流异常'))

    }

    fileReader.readAsDataURL(blob)

    fileReader.onerror = () => {

      reject(new Error('文件流异常'))

    }

  })

}