let bucketName = "yourbucket";
let appendKey = "appendObjectKey";

// 首次上传时，offset设置为null
client.appendObjectFromString(bucketName,appendKey,"firstContent",null)
.then(function(response){
	// 从响应头中获取offset偏移量
  var offset = + response.http_headers['x-bce-next-append-offset'];
  // 第二次追加上传时，指定上面获取到的offset传入
  client.appendObjectFromString(bucketName, appendKey, "appendContent", offset);
});

let options = {
  'Content-Type': 'application/json', // 添加http header
  'Cache-Control': 'public, max-age=31536000', // 指定缓存指令
  'Content-Disposition': 'attachment; filename="example.jpg"', // 指示回复的内容该以何种形式展示

  'x-bce-meta-foo1': 'bar1', // 添加自定义meta信息
  'x-bce-meta-foo2': 'bar2', // 添加自定义meta信息
  'x-bce-meta-foo3': 'bar3' // 添加自定义meta信息
}; 
let PART_SIZE = 5 * 1024 * 1024; // 指定分块大小

function getTasks(file, uploadId, bucketName, key) {
    let leftSize = file.size;
    let offset = 0;
    let partNumber = 1;

    let tasks = [];

    while (leftSize > 0) {
        let partSize = Math.min(leftSize, PART_SIZE);
        tasks.push({
            file: file,
            uploadId: uploadId,
            bucketName: bucketName,
            key: key,
            partNumber: partNumber,
            partSize: partSize,
            start: offset,
            stop: offset + partSize - 1
        });

        leftSize -= partSize;
        offset += partSize;
        partNumber += 1;
    }
    return tasks;
}

function uploadPartFile(state, client) {
    return function(task, callback) {
        let blob = task.file.slice(task.start, task.stop + 1);
        client.uploadPartFromBlob(task.bucketName, task.key, task.uploadId, task.partNumber, task.partSize, blob)
            .then(function(res) {
                ++state.loaded;
                callback(null, res);
            })
            .catch(function(err) {
                callback(err);
            });
    };
}

let uploadId;
client.initiateMultipartUpload(bucket, key, options)
    .then(function(response) {
        uploadId = response.body.uploadId; // 开始上传，获取服务器生成的uploadId

        let deferred = sdk.Q.defer();
        let tasks = getTasks(blob, uploadId, bucket, key);
        let state = {
            lengthComputable: true,
            loaded: 0,
            total: tasks.length
        };

        // 为了管理分块上传，使用了async（https://github.com/caolan/async）库来进行异步处理
        let THREADS = 2; // 同时上传的分块数量
        async.mapLimit(tasks, THREADS, uploadPartFile(state, client), function(err, results) {
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(results);
            }
        });
        return deferred.promise;
    })
    .then(function(allResponse) {
        let partList = [];
        allResponse.forEach(function(response, index) {
            // 生成分块清单
            partList.push({
                partNumber: index + 1,
                eTag: response.http_headers.etag
            });
        });
        return client.completeMultipartUpload(bucket, key, uploadId, partList); // 完成上传
    })
    .then(function (res) {
        // 上传完成
    })
    .catch(function (err) {
        // 上传失败，添加您的代码
        console.error(err);
    });

let options = {
  'Content-Type': 'application/json', // 添加http header
  'Cache-Control': 'public, max-age=31536000', // 指定缓存指令
  'Content-Disposition': 'attachment; filename="example.jpg"', // 指示回复的内容该以何种形式展示

  'x-bce-meta-foo1': 'bar1', // 添加自定义meta信息
  'x-bce-meta-foo2': 'bar2', // 添加自定义meta信息
  'x-bce-meta-foo3': 'bar3' // 添加自定义meta信息
}; 
let PART_SIZE = 5 * 1024 * 1024;            // 指定分块大小
let uploadId;
client.initiateMultipartUpload(bucket, key, options)
    .then(function(response) {
        uploadId = response.body.uploadId; // 开始上传，获取服务器生成的uploadId
        let deferred = sdk.Q.defer();
        let blob = {
            // 使用fs文件库获取文件大小
            size: fs.statSync(localFileName).size,
            filename: localFileName
        }
        let tasks = getTasks(blob, uploadId, bucket, key);
        let state = {
            lengthComputable: true,
            loaded: 0,
            total: tasks.length
        };
        // 为了管理分块上传，使用了async（https://github.com/caolan/async）库来进行异步处理
        let THREADS = 2; // 同时上传的分块数量
        async.mapLimit(tasks, THREADS, uploadPartFile(state, client), function(err, results) {
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(results);
            }
        });
        return deferred.promise;
    })
    .then(function(allResponse) {
        let partList = [];
        allResponse.forEach(function(response, index) {
            // 生成分块清单
            partList.push({
                partNumber: index + 1,
                eTag: response.http_headers.etag
            });
        });
        return client.completeMultipartUpload(bucket, key, uploadId, partList); // 完成上传
    })
    .then(function (res) {
        // 上传完成
    })
    .catch(function (err) {
        // 上传失败，添加您的代码
        console.error(err);
    });

function getTasks(file, uploadId, bucketName, key) {
    let leftSize = file.size;
    let offset = 0;
    let partNumber = 1;
    let tasks = [];
    while (leftSize > 0) {
        let partSize = Math.min(leftSize, PART_SIZE);
        tasks.push({
            file: file.filename,
            uploadId: uploadId,
            bucketName: bucketName,
            key: key,
            partNumber: partNumber,
            partSize: partSize,
            start: offset,
            stop: offset + partSize - 1
        });

        leftSize -= partSize;
        offset += partSize;
        partNumber += 1;
    }
    return tasks;
}


function uploadPartFile(state, client) {
    return function(task, callback) {
        console.log("task: ", task)
        return client.uploadPartFromFile(task.bucketName, task.key, task.uploadId, task.partNumber, task.partSize, task.file , task.start)
            .then(function(res) {
                ++state.loaded;
                console.log("ok")
                callback(null, res);
            })
            .catch(function(err) {
                console.log("bad")
                callback(err);
            });
    };
}

client.abortMultipartUpload(<BucketName>, <Objectkey>, <UploadID>);

client.listMultipartUploads(<bucketName>)
    .then(function (response) {
        // 遍历所有上传事件
        for (var i = 0; i < response.body.multipartUploads.length; i++) {
            console.log(response.body.multipartUploads[i].uploadId);
        }
    });

client.listParts(<bucketName>, <key>, <uploadId>)
    .then(function (response) {
        // 遍历所有上传事件
        for (var i = 0; i < response.body.parts.length; i++) {
            console.log(response.body.parts[i].partNumber);
        }
    });

type ProgressCallback = (
    /* 当前上传速度 */
    speed: string,
    /* 上传进度，保留4位小数 */
    progress: number,
    /* 上传进度-百分比 */
    percent: string,
    /* 已上传字节数 */
    uploadedBytes: number,
    /* 文件总字节数 */
    totalBytes
) => void

type StateChangeCallback = (
    /* 状态 */
    state: string,
    /* 如果上传失败会传递失败的message，上传成功会返回上传后的地址 */
    options: {
        message: string;
        data: Record<string, any> | null
    }
) => void;

const sdk = require('@baiducloud/sdk');
const client = new sdk.BosClient({
  endpoint: 'http://bj.bcebos.com',
  credentials: {
    ak: "<Your Access Key>",
    sk: "<Your Secret Key>"
  }
});
// 存储桶名称
const bucketName = "<Your Bucket Name>";
// 上传后文件名称
const objectName = 'demo.tgz';
// 本地文件路径
const data = '/Mock/path/to/local/file/demo.tgz';

// 初始化上传任务
const SuperUploadTask = client.putSuperObject({
    // 桶名称
    bucketName,
    // 上传后对象名称
    objectName,
    // 上传数据, 类型为string时表示文件路径
    data,
    // 分片并发数
    partConcurrency: 2,
    // 上传进度回调函数
    onProgress: (options) => {
        const {speed, progress, percent, uploadedBytes, totalBytes} = options;
        console.log(options);
    },
    // 状态变化回调函数
    onStateChange: (state, data) => {
        if (state === 'completed') {
            console.log('上传成功');
        } else if (state === 'failed') {
            console.error('上传失败，失败原因：' + data.message);
        } else if (state === 'cancelled') {
            console.log('上传任务取消');
        } else if (state === 'inited') {
            console.log('上传任务初始化完成');
        } else if (state === 'running') {
            console.log('上传任务开始运行...');
        } else if (state === 'paused') {
            console.log('上传任务已暂停');
        }
    }
});

// 启动上传任务
const tasks = SuperUploadTask.start();
console.log('切分任务: ', tasks);

// 暂停上传任务
setTimeout(() => {
    SuperUploadTask.pause();
}, 5000);

// 恢复上传任务
setTimeout(() => {
    SuperUploadTask.resume();
}, 15000);

// 取消上传任务
setTimeout(async () => {
    const result = SuperUploadTask.cancel();
    console.log(result ? '任务取消成功' : '任务取消失败');
}, 25000);

<html>
  <head>
    <meta charset="utf-8" />
    <title>SuperUpload测试</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/amis/6.2.2/sdk.min.css" integrity="sha512-9yikVhRqNeq1rypIzAFKR8CA2uG8V5gYppoDKK4xx+7eoLXJsEm+f9QN0++xqHvrOxxvb93uiipgYk9uEW7RlA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/amis/6.2.2/cxd.min.css" integrity="sha512-9yikVhRqNeq1rypIzAFKR8CA2uG8V5gYppoDKK4xx+7eoLXJsEm+f9QN0++xqHvrOxxvb93uiipgYk9uEW7RlA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/simple-notify@1.0.4/dist/simple-notify.css" />
  </head>
  <body>
      <div id="root"></div>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js" integrity="sha512-v2CJ7UaYy4JwqLDIrZUI/4hqeoQieOmAZNXBeQyjo21dadnwR+8ZaIJVT8EE2iyI61OV8e6M8PP2/4hpQINQ/g==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
      <script src="https://cdn.jsdelivr.net/npm/simple-notify@1.0.4/dist/simple-notify.min.js"></script>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/amis/6.2.2/sdk.min.js" integrity="sha512-BpMIHWCtAUDARuH/qnGH6eBxoOv4l0i4Y9/9f6vnGVDNnPqbWCZoPgk3/KvY6NuOb6cAPFmqVN1R2sXz7Z3VcQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
      <script src="https://bce.bdstatic.com/lib/@baiducloud/sdk/1.0.1-beta.2/baidubce-sdk.bundle.min.js" ></script>
      <script>
        (async function () {
            // 实例化BOS SDK
            const client = new window.baidubce.sdk.BosClient({
              endpoint: 'http://bj.bcebos.com',
              credentials: {
                ak: "<Your Access Key>",
                sk: "<Your Secret Key>"
              }
            });
            // 实例化BOS SDK
            const bucketName = '<Your Bucket Name>';
            // 上传任务实例
            let SuperUpload;
            // 进度信息
            let p1 = 0;
            
            // 消息弹窗
            function pushNotify({status, title, text}) {
              new Notify({
                status: status || 'success',
                title: title,
                text: text,
                distance: 200,
                position: 'x-center'
              });
            }

            // 获取任务实例
            function getInstance() {
              if (SuperUpload) {
                pushNotify({title: '获取实例信息', text: '实例信息获取成功'});
              } else {
                pushNotify({status: 'error', title: '获取实例信息', text: '实例信息获取失败'});
              }
            }
            
            async function start() {
              const files = $('#file')?.[0]?.files;
    
              if (!files || files.length === 0) {
                pushNotify({status: 'error', title: '上传', text: '请先选择文件'});
                return;
              }
    
              const file = files[0];
              let reader = new FileReader();
              let rs = reader.readAsArrayBuffer(file);
              let blob = null;
    
              // 将文件读取为Blob对象
              reader.onload = async e => {
                if (typeof e.target.result === 'object') {
                  blob = new Blob([e.target.result]);
                } else {
                  blob = e.target.result;
                }
    
                SuperUpload = client.putSuperObject({
                  bucketName,
                  objectName: file.name,
                  ContentLength: file.size,
                  ContentType: file.type,
                  data: blob,
                  partConcurrency: 2,
                  onProgress: options => {
                    const {speed, progress, uploadedBytes, totalBytes} = options;
    
                    console.log(options);
                    amisScoped.updateProps({
                      data: {p1: progress * 100}
                    });
                  },
                  onStateChange: (state, data) => {
                    if (state === 'completed') {
                      pushNotify({title: '上传', text: '上传成功'});
                      console.log(data);
                    } else if (state === 'failed') {
                      pushNotify({status: 'error', title: '上传失败', text: data.message});
                    } else if (state === 'cancelled') {
                      pushNotify({title: '上传', text: '上传任务取消'});
                    } else if (state === 'inited') {
                      pushNotify({title: '上传', text: '上传任务初始化完成'});
                    } else if (state === 'running') {
                      pushNotify({title: '上传', text: '上传任务开始运行...'});
                    } else if (state === 'paused') {
                      pushNotify({title: '上传', text: '上传任务已暂停'});
                    }
                  }
                });
    
                const tasks = await SuperUpload.start();
                console.log('切片列表: ', tasks);
              };
            }
            
            function pause() {
              if (SuperUpload) {
                SuperUpload.pause();
              } else {
                pushNotify({status: 'error', title: '暂停', text: '实例不存在'});
              }
            }
    
            function resume() {
              if (SuperUpload) {
                SuperUpload.resume();
              } else {
                pushNotify({status: 'error', title: '恢复', text: '实例不存在'});
              }
            }
    
            async function cancel() {
              if (SuperUpload) {
                const result = await SuperUpload.cancel();
    
                if (result) {
                  SuperUpload = undefined;
                  p1 = 0;
    
                  amisScoped.updateProps({
                    data: {p1: 0}
                  });
                }
              } else {
                pushNotify({status: 'error', title: '取消任务', text: '实例不存在'});
              }
            }
            
            const amis = amisRequire('amis/embed');
            const amisJSON = {
              type: 'page',
              body: [
                {
                  type: 'alert',
                  title: 'CORS配置',
                  body: '如果接口报CORS错误，请开启对应存储桶的<a href="https://cloud.baidu.com/doc/BOS/s/Dk6kqw1g8", target="__blank">CORS配置</a>',
                  level: 'warning',
                  showIcon: true,
                  className: 'mb-3'
                },
                {
                  type: 'custom',
                  name: 'file',
                  onMount: (dom, value, onChange, props) => {
                    const input = document.createElement('input');
                    input.setAttribute('type', 'file');
                    input.setAttribute('id', 'file');
    
                    dom.appendChild(input);
                  }
                },
                {
                  type: 'progress',
                  value: '${p1}',
                  style: {
                    marginTop: '20px',
                    width: '500px'
                  }
                },
                {
                  type: 'flex',
                  justify: 'flex-start',
                  style: {
                    marginTop: '20px'
                  },
                  items: [
                    {
                      type: 'button',
                      level: 'primary',
                      label: '获取实例',
                      style: {
                        marginRight: '10px'
                      },
                      onClick: getInstance
                    },
                    {
                      type: 'button',
                      level: 'primary',
                      label: '上传',
                      style: {
                        marginRight: '10px'
                      },
                      onClick: start
                    },
                    {
                      type: 'button',
                      level: 'primary',
                      label: '暂停',
                      style: {
                        marginRight: '10px'
                      },
                      onClick: pause
                    },
                    {
                      type: 'button',
                      level: 'primary',
                      label: '恢复',
                      style: {
                        marginRight: '10px'
                      },
                      onClick: resume
                    },
                    {
                      type: 'button',
                      level: 'danger',
                      label: '取消',
                      onClick: cancel
                    }
                  ]
                }
              ]
            };
            const amisScoped = amis.embed('#root', amisJSON, {data: {p1}});
        })()
      </script>
  </body>
</html>

try {
  const res = await client.putObjectFromString('bucketName', 'fileName', 'demo-string', {
      callback: {
        urls: ["https://www.test.com/callback"],
        vars: {name: 'baidu'},
        encrypt: 'config',
        key: 'callback1'
      }
  });

  /* callback result */
  console.log(res.body.callback.result);
} catch (e) {
  /* callback error code */
  console.error(res.body.callback.code);
  /* callback error message */
  console.error(res.body.callback.message);
}

try {
  const res = await client.putObjectFromString('bucketName', 'fileName', 'demo-string', {
      'x-bce-process': 'callback/callback,u_WyJodHRwczovL3d3dy50ZXN0LmNvbS9jYWxsYmFjayJd,m_sync,v_eyJuYW1lIjoiYmFpZHUifQ'
  });

  /* callback result */
  console.log(res.body.callback.result);
} catch (e) {
  /* callback error code */
  console.error(res.body.callback.code);
  /* callback error message */
  console.error(res.body.callback.message);
}