<input type="file" id="file" />
<script>
    function imageScale(width, originWidth, originHeight) {
        const scaleRatio = width / originWidth;
        const scaleHeight = scaleRatio * originHeight;
        return [width, scaleHeight];
    }

    function compress(file, scaleWidth, quality = 0.5) {
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            reader.readAsDataURL(file);
            reader.onload = (e) => {
                let img = new Image();
                img.src = e.target.result;
                img.onload = function () {
                    // 等比例縮放圖片
                    const [width, height] = imageScale(
                        scaleWidth,
                        img.width,
                        img.height
                    );
                    let canvas = document.createElement("canvas");
                    img.width = canvas.width = width;
                    img.height = canvas.height = height;
                    let ctx = canvas.getContext("2d");
                    ctx.drawImage(img, 0, 0, img.width, img.height);
                    canvas.toBlob(
                        (blob) => {
                            resolve(blob);
                        },
                        "image/jpeg",
                        quality
                    );
                };

                img.onerror = function () {
                    reject();
                };
            };
        });
    }

    file.onchange = function () {
        compress(this.files[0], 200).then((blob) => {
            let url = window.URL.createObjectURL(blob);
            const img = document.createElement("img");
            img.src = url;
            img.width = 200;
            document.body.appendChild(img);
        });
    };
</script>

if (!HTMLCanvasElement.prototype.toBlob) {
  Object.defineProperty(HTMLCanvasElement.prototype, 'toBlob', {
    value: function(callback, type, quality) {
      var canvas = this
      setTimeout(() => {
        var binStr = atob(canvas.toDataURL(type, quality).split(',')[1])
        var len = binStr.length
        var arr = new Uint8Array(len)
        for (var i = 0; i < len; i++) {
          arr[i] = binStr.charCodeAt(i)
        }
        callback(new Blob([arr], { type: type || 'image/png' }))
      })
    }
  })
}

/**
 * 圖片壓縮
 * @param {object} options 參數(shù)
 * @param {string} options.content 圖像內容
 * @param {number} options.maxWidth 最大寬度
 * @param {number} options.maxHeight 最大高度
 * @param {number} options.quality 圖像質量
 * @example rotateImage({ content: Img, maxWidth: 1000, maxHeight: 1000, quality: 0.8 })
 * @returns {Promise<object>} 結果值
 */
const compressionImage = function(options = {}) {
  if (!options || typeof options !== 'object') {
    throw new Error(`[compressionImage error]: options is not a object`)
  }
  if (!options.content || (typeof options.content !== 'string' && !(options.content instanceof File))) {
    throw new Error(`[compressionImage error]: options.content is not a string or file`)
  }
  if (typeof options.maxWidth !== 'number') {
    throw new Error(`[compressionImage error]: options.maxWidth is not a number`)
  }
  if (typeof options.maxHeight !== 'number') {
    throw new Error(`[compressionImage error]: options.maxHeight is not a number`)
  }
  if (typeof options.quality !== 'number') {
    throw new Error(`[compressionImage error]: options.quality is not a number`)
  }
  return new Promise(resolve => {
    const set = (content, type) => {
      const canvasDOM = document.createElement('canvas')
      const canvasContext = canvasDOM.getContext('2d')
      const img = new Image()
      img.src = content
      img.onload = () => {
        let targetWidth
        let targetHeight
        if (img.width > options.maxWidth && img.height > options.maxHeight) {
          const rate = Math.min(options.maxWidth / img.width, options.maxHeight / img.height)
          targetWidth = img.width * rate
          targetHeight = img.height * rate
        } else if (img.width > options.maxWidth) {
          targetWidth = options.maxWidth
          targetHeight = (options.maxWidth / img.width) * img.height
        } else if (img.height > options.maxHeight) {
          targetHeight = options.maxHeight
          targetWidth = (options.maxHeight / img.height) * img.width
        } else {
          targetWidth = img.width
          targetHeight = img.height
        }
        canvasDOM.width = targetWidth
        canvasDOM.height = targetHeight
        canvasContext.drawImage(img, 0, 0, img.width, img.height, 0, 0, targetWidth, targetHeight)
        const url = canvasDOM.toDataURL(type, options.quality)
        const callback = blob => {
          resolve({ url, blob })
        }
        canvasDOM.toBlob(callback, type, options.quality)
      }
    }
    if (options.content instanceof File) {
      const fileReader = new FileReader()
      fileReader.readAsDataURL(options.content)
      fileReader.onload = e => {
        set(e.target.result, options.content.type)
      }
    } else if (typeof options.content === 'string') {
      const fileContent = options.content.includes('base64,') ? options.content : `data:image/jpeg;base64,${options.content}`
      const fileType =
        options.content.includes('data:image/png;base64,') ? 'image/png'
          : options.content.includes('data:image/gif;base64,') ? 'image/gif' : 'image/jpeg'
      set(fileContent, fileType)
    }
  })
}

const { url, blob } = await compressionImage({
  content: 'base64', //圖像base64或file文件
  maxWidth: 1000, //最大寬度
  maxHeight: 600, //最大高度
  quality: 0.7 //圖像質量，1為100%，建議選值0.95以下，1輸出后的圖像較大
})
console.log('壓縮后的base64內容', url)
console.log('壓縮后的blob文件', blob)