
# 列举桶内对象(Node.js SDK)
![](https://support.huaweicloud.com/sdk-nodejs-devg-obs/public_sys-resources/notice_3.0-zh-cn.png)
开发过程中，您有任何问题可以在GitHub上[提交issue](https://github.com/huaweicloud/huaweicloud-sdk-nodejs-obs/issues)，或者在[华为云对象存储服务论坛](https://bbs.huaweicloud.com/forum/forum-620-1.html)中发帖求助。
#### 功能介绍
调用列举桶内对象接口，可列举指定桶内的部分或所有对象的描述信息。您还可以通过设置前缀、数量、起始位置等参数，返回符合您筛选条件的对象信息。返回结果以对象名的字典序排序。
#### 接口约束
- 每次接口调用最多返回1000个对象信息。
- 您必须是桶拥有者或拥有列举桶内对象的权限，才能列举桶内对象。建议使用IAM或桶策略进行授权，如果使用IAM则需授予obs:bucket:ListBucket权限，如果使用桶策略则需授予ListBucket权限。相关授权方式介绍可参见[OBS权限控制概述](https://support.huaweicloud.com/perms-cfg-obs/obs_40_0001.html)，配置方式详见[使用IAM自定义策略](https://support.huaweicloud.com/usermanual-obs/obs_03_0121.html)、[自定义创建桶策略](https://support.huaweicloud.com/usermanual-obs/obs_03_0123.html)。
- OBS支持的Region与Endpoint的对应关系，详细信息请参见[地区与终端节点](https://console.huaweicloud.com/apiexplorer/#/endpoint/OBS)。
 
#### 方法定义
```
ObsClient.listObjects(params)
```
#### 请求参数
表1ListObjectsInput 
| **参数名称**     | **参数类型** | **是否必选** | **描述**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|:---|:---|:---|:---|
| Bucket       | string   | 必选       | **参数解释** **：** 桶名。 **约束限制：** - 桶的名字需全局唯一，不能与已有的任何桶名称重复，包括其他用户创建的桶。  - 桶命名规则如下： - 3～63个字符，数字或字母开头，支持小写字母、数字、"-"、"."。  - 禁止使用IP地址。  - 禁止以"-"或"."开头及结尾。  - 禁止两个"."相邻（如："my..bucket"）。  - 禁止"."和"-"相邻（如："my-.bucket"和"my.-bucket"）。    - 同一用户在同一个区域多次创建同名桶不会报错，创建的桶属性以第一次请求为准。   **取值范围：** 长度为3～63个字符。 **默认取值：** 无 |
| Marker       | string   | 可选       | **参数解释：** 列举桶内对象列表时，指定一个标识符，从该标识符以后按对象名的字典顺序返回对象列表。 **约束限制：** 仅用于非多版本列举。 **取值范围：** 长度大于0且不超过1024的字符串。 **默认取值：** 无                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Prefix       | string   | 可选       | **参数解释：** 限定返回的对象名必须带有指定前缀。 例如，假设您拥有以下对象：logs/day1、logs/day2、logs/day3和ExampleObject.jpg。如果您将logs/指定为前缀，将返回以字符串"logs/"开头的三个对象。如果您指定空的前缀且请求中没有其他过滤条件，将返回桶中的所有对象。 **约束限制：** 无 **取值范围：** 长度大于0且不超过1024的字符串。 **默认取值：** 无                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| MaxKeys      | number   | 可选       | **参数解释：** 列举对象的最大数目，返回的对象列表将是按照字典顺序的最多前MaxKeys个对象。 **约束限制：** 无 **取值范围：** 1\~1000，当超出范围时，按照默认的1000进行处理。 **默认取值：** 1000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Delimiter    | string   | 可选       | **参数解释：** 对象名按照此标识符进行分组。通常与prefix参数搭配使用，如果指定了prefix，从prefix到第一次出现delimiter间具有相同字符串的对象名会被分成一组，形成一条CommonPrefixes；如果没有指定prefix，从对象名的首字符到第一次出现delimiter间具有相同字符串的对象名会被分成一组，形成一条CommonPrefixes。 例如，桶中有3个对象，分别为abcd、abcde、bbcde。如果指定delimiter为d，prefix为a，abcd、abcde会被分成一组，形成一条前缀为abcd的CommonPrefixes；如果只指定delimiter为d，abcd、abcde会被分成一组，形成一条前缀为abcd的CommonPrefixes，而bbcde会被单独分成一组，形成一条前缀为bbcd的CommonPrefixes。 对于并行文件系统，不携带此参数时默认列举是递归列举此目录下所有内容，会列举子目录。在大数据场景下（目录层级深、目录下文件多）的列举，建议设置\[delimiter=/\]，只列举当前目录下的内容，不列举子目录，提高列举效率。 **约束限制：** 无 **取值范围：** 长度大于0且不超过1024的字符串。 **默认取值：** 无                                                                                                                                                                                                              |
| EncodingType | string   | 可选       | **参数解释：** 对响应中的部分元素进行指定类型的编码。如果Delimiter、Marker、Prefix、CommonPrefixes、NextMarker和Key包含xml 1.0标准不支持的控制字符（特殊字符），需设置该参数为url编码。 **约束限制：** 无 **取值范围：** 可选值为url。 **默认取值：** 无，不设置则不编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
   
#### 返回结果
表2返回结果 
| **参数类型**                                                                                                                                                | 描述                                                                                        |
|:---|:---|
| [表3] 说明： 该接口返回是一个Promise类型，需要使用Promise、async/await语法处理。 | **参数解释：** 接口返回信息，详见[表3]。 |
   
 表3Response 
| **参数名称**        | **参数类型**                                     | 描述                                                                                                                                                                              |
|:---|:---|:---|
| CommonMsg       | [ICommonMsg] | **参数解释：** 接口调用完成后的公共信息，包含HTTP状态码，操作失败的错误码等，详见[ICommonMsg]。                                                       |
| InterfaceResult | [表5]        | **参数解释：** 操作成功后的结果数据，详见[表5]。 **约束限制：** 当Status大于300时为空。 |
   
 表4ICommonMsg 
| **参数名称**  | **参数类型** |                                                                                                                                                                                                       **描述**                                                                                                                                                                                                        |
|---|---|---|
| Status    | number   | **参数解释：** OBS服务端返回的HTTP状态码。 **取值范围：** 状态码是一组从2xx（成功）到4xx或5xx（错误）的数字代码，状态码表示了请求响应的状态。完整的状态码列表请参见[状态码](https://support.huaweicloud.com/api-obs/obs_04_0114.html)。 |
| Code      | string   | **参数解释：** OBS服务端返回的错误码。                                                                                                                                                                                                                                                                                                                                    |
| Message   | string   | **参数解释：** OBS服务端返回的错误描述。                                                                                                                                                                                                                                                                                                                                  |
| HostId    | string   | **参数解释：** OBS服务端返回的请求服务端ID。                                                                                                                                                                                                                                                                                                                               |
| RequestId | string   | **参数解释：** OBS服务端返回的请求ID。                                                                                                                                                                                                                                                                                                                                  |
| Id2       | string   | **参数解释：** OBS服务端返回的请求ID2。                                                                                                                                                                                                                                                                                                                               |
| Indicator | string   | **参数解释：** OBS服务端返回的详细错误码。                                                                                                                                                                                                                                                                                                                                |
   
 表5ListObjectsOutput 
| **参数名称**       | **参数类型**                                             | **描述**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|:---|:---|:---|
| RequestId      | string                                               | **参数解释：** OBS服务端返回的请求ID。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Location       | string                                               | **参数解释** **：** 桶所在的区域。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Bucket         | string                                               | **参数解释** **：** 桶名。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Prefix         | string                                               | **参数解释：** 对象名的前缀，与请求中的该参数对应。 例如，假设您拥有以下对象：logs/day1、logs/day2、logs/day3和ExampleObject.jpg。如果您将logs/指定为前缀，将返回以字符串"logs/"开头的三个对象。如果您指定空的前缀且请求中没有其他过滤条件，将返回桶中的所有对象。                                                                                                                                                                                                                                                                                                                                                                                      |
| Marker         | string                                               | **参数解释：** 列举对象的起始位置，与请求中的该参数对应。列举桶内对象列表时，指定一个标识符，从该标识符以后按对象名的字典顺序返回对象列表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Delimiter      | string                                               | **参数解释：** 对象名按照此标识符进行分组。通常与prefix参数搭配使用，如果指定了prefix，从prefix到第一次出现delimiter间具有相同字符串的对象名会被分成一组，形成一条CommonPrefixes；如果没有指定prefix，从对象名的首字符到第一次出现delimiter间具有相同字符串的对象名会被分成一组，形成一条CommonPrefixes。 例如，桶中有3个对象，分别为abcd、abcde、bbcde。如果指定delimiter为d，prefix为a，abcd、abcde会被分成一组，形成一条前缀为abcd的CommonPrefixes；如果只指定delimiter为d，abcd、abcde会被分成一组，形成一条前缀为abcd的CommonPrefixes，而bbcde会被单独分成一组，形成一条前缀为bbcd的CommonPrefixes。 对于并行文件系统，不携带此参数时默认列举是递归列举此目录下所有内容，会列举子目录。在大数据场景下（目录层级深、目录下文件多）的列举，建议设置\[delimiter=/\]，只列举当前目录下的内容，不列举子目录，提高列举效率。 |
| MaxKeys        | number                                               | **参数解释：** 列举对象的最大数目，与请求中的该参数对应。返回的对象列表将是按照字典顺序的最多前MaxKeys个对象。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| IsTruncated    | string                                               | **参数解释：** 表明本次请求是否返回了全部结果。因为每次列举返回对象的数量上限是1000个，如果对象个数大于1000，则无法通过一次请求返回全部结果。 **取值范围：** - true：表示没有返回全部结果。  - false：表示已返回了全部结果。                                                                                                                                                                                                                         |
| NextMarker     | string                                               | **参数解释：** 下次列举对象请求的起始位置。如果本次没有返回全部结果，响应请求中将包含此字段，用于标明本次请求列举到的最后一个对象。后续请求可以指定Marker参数等于该值来列举剩余的对象。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Contents       | [Content]\[\]      | **参数解释：** 桶内对象列表，详见[Content]。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| CommonPrefixes | [CommonPrefix]\[\] | **参数解释：** 当请求中设置了Delimiter分组字符时，返回按Delimiter分组后的对象名称前缀列表。 **取值范围：** 详见[CommonPrefix]。                                                                                                                                                                                                                                                                                                                                                                                                   |
| EncodingType   | string                                               | **参数解释：** 对响应中的部分元素进行指定类型的编码。如果Delimiter、Marker、Prefix、CommonPrefixes、NextMarker和Key包含xml 1.0标准不支持的控制字符（特殊字符），需设置该参数为url编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
   
 表6Content 
| **参数名称**     | **参数类型**                                   | **描述**                                                                                                                                                                                                                                                                                                                |
|:---|:---|:---|
| Key          | string                                     | **参数解释：** 对象名。对象名是对象在存储桶中的唯一标识。对象名是对象在桶中的完整路径，路径中不包含桶名。 例如，您对象的访问地址为examplebucket.obs.cn-north-4.myhuaweicloud.com/folder/test.txt 中，对象名为folder/test.txt。                                                                                                 |
| LastModified | string                                     | **参数解释：** 对象最近一次被修改的时间（UTC时间）。                                                                                                                                                                                                                                                          |
| ETag         | string                                     | **参数解释：** 对象的base64编码的128位MD5摘要。ETag是对象内容的唯一标识，可以通过该值识别对象内容是否有变化。比如上传对象时ETag为A，下载对象时ETag为B，则说明对象内容发生了变化。ETag只反映变化的内容，而不是其元数据。上传的对象或复制操作创建的对象，都有唯一的ETag。 **约束限制：** 当对象是服务端加密的对象时，ETag值不是对象的MD5值。                             |
| Size         | number                                     | **参数解释：** 对象的字节数。                                                                                                                                                                                                                                                                       |
| Owner        | [Owner] | **参数解释：** 对象的所有者，包含对象拥有者DomainId和对象拥有者名称，详见[Owner]。                                                                                                                                                                                                  |
| StorageClass | string                                     | **参数解释：** 对象的存储类型。                                                                                                                                                                                                                                                                          |
| Type         | string                                     | **参数解释：** 对象的类型。 **取值范围：** - NORMAL：普通对象  - APPENDABLE：追加写对象   |
   
 表7CommonPrefix 
| **参数名称**                                  | **参数类型** | **描述**                                                                                                                                                                                                                 |
|:---|:---|:---|
| Prefix  | string   | **参数解释：** 为桶内对象的前缀。 **取值范围：** 长度大于0且不超过1024的字符串。 **默认取值：** 无 |
   
 表8Owner 
| **参数名称**    | **参数类型** | **是否必选**  | **描述**                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|:---|:---|
| ID          | string   | 作为请求参数时必选 | **参数解释：** 所有者的账号ID，即domain_id。 **取值范围：** 如何获取账号ID请参见[如何获取账号ID和用户ID？(Node.js SDK)](https://support.huaweicloud.com/sdk-nodejs-devg-obs/obs_29_1715.html) **默认取值：** 无 |
| DisplayName | string   | 可选        | **参数解释：** 所有者的账号用户名。 **默认取值：** 无                                                                                                                                                                                                                                                          |
   
#### 代码示例一：简单列举
以下代码展示如何简单列举对象，最多返回1000个对象：
```
// 引入obs库
// 使用npm安装
const ObsClient = require("esdk-obs-nodejs");
// 使用源码安装
// var ObsClient = require('./lib/obs');
// 创建ObsClient实例
const obsClient = new ObsClient({
  // 推荐通过环境变量获取AKSK，这里也可以使用其他外部引入方式传入，如果使用硬编码可能会存在泄露风险
  // 您可以登录访问管理控制台获取访问密钥AK/SK，获取方式请参见https://support.huaweicloud.com/usermanual-ca/ca_01_0003.html
  access_key_id: process.env.ACCESS_KEY_ID,
  secret_access_key: process.env.SECRET_ACCESS_KEY,
  // 【可选】如果使用临时AK/SK和SecurityToken访问OBS，同样建议您尽量避免使用硬编码，以降低信息泄露风险。您可以通过环境变量获取访问密钥AK/SK，也可以使用其他外部引入方式传入
  // security_token: process.env.SECURITY_TOKEN,
  // endpoint填写Bucket对应的Endpoint, 这里以华北-北京四为例，其他地区请按实际情况填写
  server: "https://obs.cn-north-4.myhuaweicloud.com",
});
async function listObjects() {
  try {
    const params = {
      // 指定存储桶名称
      Bucket: "examplebucket",
    };
    // 列举桶内对象
    const result = await obsClient.listObjects(params);
    if (result.CommonMsg.Status <= 300) {
      console.log("List objects under the bucket(%s) successful!", params.Bucket);
      console.log("RequestId: %s", result.CommonMsg.RequestId);
      for (let j = 0; j < result.InterfaceResult.Contents.length; j++) {
        const val = result.InterfaceResult.Contents[j];
        console.log('Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d',
          j, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size);
      };
      return;
    };
    console.log("An ObsError was found, which means your request sent to OBS was rejected with an error response.");
    console.log("Status: %d", result.CommonMsg.Status);
    console.log("Code: %s", result.CommonMsg.Code);
    console.log("Message: %s", result.CommonMsg.Message);
    console.log("RequestId: %s", result.CommonMsg.RequestId);
  } catch (error) {
    console.log("An Exception was found, which means the client encountered an internal problem when attempting to communicate with OBS, for example, the client was unable to access the network.");
    console.log(error);
  };
};
listObjects();
```
![](https://support.huaweicloud.com/sdk-nodejs-devg-obs/public_sys-resources/note_3.0-zh-cn.png)
- 每次至多返回1000个对象，如果指定桶包含的对象数量大于1000，则返回结果中InterfaceResult.IsTruncated为true表明本次没有返回全部对象，并可通过InterfaceResult.NextMarker获取下次列举的起始位置。
- 如果想获取指定桶包含的所有对象，可以采用[代码示例五：分页列举全部对象]的方式。
 
#### 代码示例二：指定数目列举
以下代码展示如何指定数目列举对象：
```
// 引入obs库
// 使用npm安装
const ObsClient = require("esdk-obs-nodejs");
// 使用源码安装
// var ObsClient = require('./lib/obs');
// 创建ObsClient实例
const obsClient = new ObsClient({
  // 推荐通过环境变量获取AKSK，这里也可以使用其他外部引入方式传入，如果使用硬编码可能会存在泄露风险
    access_key_id: process.env.ACCESS_KEY_ID,
  // 您可以登录访问管理控制台获取访问密钥AK/SK，获取方式请参见https://support.huaweicloud.com/usermanual-ca/ca_01_0003.html
  secret_access_key: process.env.SECRET_ACCESS_KEY,
  // 【可选】如果使用临时AK/SK和SecurityToken访问OBS，同样建议您尽量避免使用硬编码，以降低信息泄露风险。您可以通过环境变量获取访问密钥AK/SK，也可以使用其他外部引入方式传入
  // security_token: process.env.SECURITY_TOKEN,
  // endpoint填写Bucket对应的Endpoint, 这里以华北-北京四为例，其他地区请按实际情况填写
  server: "https://obs.cn-north-4.myhuaweicloud.com",
});
async function listObjects() {
  try {
    const params = {
      // 指定存储桶名称
      Bucket: "examplebucket",
      // 指定返回的最大对象数，此处以 100 为例，返回的对象列表将是按照字典顺序的最多前max-keys个对象，默认值为1000
      MaxKeys: 100,
    };
    // 列举桶内对象
    const result = await obsClient.listObjects(params);
    if (result.CommonMsg.Status <= 300) {
      console.log("List objects under the bucket(%s) successful!", params.Bucket);
      console.log("RequestId: %s", result.CommonMsg.RequestId);
      for (let j = 0; j < result.InterfaceResult.Contents.length; j++) {
        const val = result.InterfaceResult.Contents[j];
        console.log('Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d',
          j, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size);
      };
      return;
    };
    console.log("An ObsError was found, which means your request sent to OBS was rejected with an error response.");
    console.log("Status: %d", result.CommonMsg.Status);
    console.log("Code: %s", result.CommonMsg.Code);
    console.log("Message: %s", result.CommonMsg.Message);
    console.log("RequestId: %s", result.CommonMsg.RequestId);
  } catch (error) {
    console.log("An Exception was found, which means the client encountered an internal problem when attempting to communicate with OBS, for example, the client was unable to access the network.");
    console.log(error);
  };
};
listObjects();
```
#### 代码示例三：指定前缀列举
以下代码展示如何指定前缀列举对象：
```
// 引入obs库
// 使用npm安装
const ObsClient = require("esdk-obs-nodejs");
// 使用源码安装
// var ObsClient = require('./lib/obs');
// 创建ObsClient实例
const obsClient = new ObsClient({
  // 推荐通过环境变量获取AKSK，这里也可以使用其他外部引入方式传入，如果使用硬编码可能会存在泄露风险
  // 您可以登录访问管理控制台获取访问密钥AK/SK，获取方式请参见https://support.huaweicloud.com/usermanual-ca/ca_01_0003.html
  access_key_id: process.env.ACCESS_KEY_ID,
  secret_access_key: process.env.SECRET_ACCESS_KEY,
  // 【可选】如果使用临时AK/SK和SecurityToken访问OBS，同样建议您尽量避免使用硬编码，以降低信息泄露风险。您可以通过环境变量获取访问密钥AK/SK，也可以使用其他外部引入方式传入
  // security_token: process.env.SECURITY_TOKEN,
  // endpoint填写Bucket对应的Endpoint, 这里以华北-北京四为例，其他地区请按实际情况填写
  server: "https://obs.cn-north-4.myhuaweicloud.com",
});
async function listObjects() {
  try {
    const params = {
      // 指定存储桶名称
      Bucket: "examplebucket",
      // 指定列举对象前缀，此处以“test/”前缀为例，满足指定前缀的对象会被列举
      Prefix: "test/",
      // 指定返回的最大对象数，此处以 100 为例，返回的对象列表将是按照字典顺序的最多前max-keys个对象，默认值为1000
      MaxKeys: 100,
    };
    
    // 列举桶内对象
    const result = await obsClient.listObjects(params);
    if (result.CommonMsg.Status <= 300) {
      console.log("List objects under the bucket(%s) successful!", params.Bucket);
      console.log("RequestId: %s", result.CommonMsg.RequestId);
      for (let j = 0; j < result.InterfaceResult.Contents.length; j++) {
        const val = result.InterfaceResult.Contents[j];
        console.log('Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d',
          j, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size);
      };
      return;
    };
    console.log("An ObsError was found, which means your request sent to OBS was rejected with an error response.");
    console.log("Status: %d", result.CommonMsg.Status);
    console.log("Code: %s", result.CommonMsg.Code);
    console.log("Message: %s", result.CommonMsg.Message);
    console.log("RequestId: %s", result.CommonMsg.RequestId);
  } catch (error) {
    console.log("An Exception was found, which means the client encountered an internal problem when attempting to communicate with OBS, for example, the client was unable to access the network.");
    console.log(error);
  };
};
listObjects();
```
#### 代码示例四：指定起始位置列举
以下代码展示如何指定起始位置列举对象：
```
// 引入obs库
// 使用npm安装
const ObsClient = require("esdk-obs-nodejs");
// 使用源码安装
// var ObsClient = require('./lib/obs');
// 创建ObsClient实例
const obsClient = new ObsClient({
  // 推荐通过环境变量获取AKSK，这里也可以使用其他外部引入方式传入，如果使用硬编码可能会存在泄露风险
  // 您可以登录访问管理控制台获取访问密钥AK/SK，获取方式请参见https://support.huaweicloud.com/usermanual-ca/ca_01_0003.html
  access_key_id: process.env.ACCESS_KEY_ID,
  secret_access_key: process.env.SECRET_ACCESS_KEY,
  // 【可选】如果使用临时AK/SK和SecurityToken访问OBS，同样建议您尽量避免使用硬编码，以降低信息泄露风险。您可以通过环境变量获取访问密钥AK/SK，也可以使用其他外部引入方式传入
  // security_token: process.env.SECURITY_TOKEN,
  // endpoint填写Bucket对应的Endpoint, 这里以华北-北京四为例，其他地区请按实际情况填写
  server: "https://obs.cn-north-4.myhuaweicloud.com",
});
async function listObjects() {
  try {
    const params = {
      // 指定存储桶名称
      Bucket: "examplebucket",
      // 指定列举对象前缀，此处以“test/”前缀为例，满足指定前缀的对象会被列举
      Prefix: "test/",
      // 指定返回的最大对象数，此处以 100 为例，返回的对象列表将是按照字典顺序的最多前max-keys个对象，默认值为1000
      MaxKeys: 100,
      // 指定列举对象的起始位置，此处以“test/test2”为例
      Marker: "test/test2",
    };
    // 列举桶内对象
    const result = await obsClient.listObjects(params);
    if (result.CommonMsg.Status <= 300) {
      console.log("List objects under the bucket(%s) successful!", params.Bucket);
      console.log("RequestId: %s", result.CommonMsg.RequestId);
      for (let j = 0; j < result.InterfaceResult.Contents.length; j++) {
        const val = result.InterfaceResult.Contents[j];
        console.log('Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d',
          j, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size);
      };
      return;
    };
    console.log("An ObsError was found, which means your request sent to OBS was rejected with an error response.");
    console.log("Status: %d", result.CommonMsg.Status);
    console.log("Code: %s", result.CommonMsg.Code);
    console.log("Message: %s", result.CommonMsg.Message);
    console.log("RequestId: %s", result.CommonMsg.RequestId);
  } catch (error) {
    console.log("An Exception was found, which means the client encountered an internal problem when attempting to communicate with OBS, for example, the client was unable to access the network.");
    console.log(error);
  };
};
listObjects();
```
 #### 代码示例五：分页列举全部对象
以下代码展示分页列举全部对象：
```
// 引入obs库
// 使用npm安装
const ObsClient = require("esdk-obs-nodejs");
// 使用源码安装
// var ObsClient = require('./lib/obs');
// 创建ObsClient实例
const obsClient = new ObsClient({
  // 推荐通过环境变量获取AKSK，这里也可以使用其他外部引入方式传入，如果使用硬编码可能会存在泄露风险
  // 您可以登录访问管理控制台获取访问密钥AK/SK，获取方式请参见https://support.huaweicloud.com/usermanual-ca/ca_01_0003.html
  access_key_id: process.env.ACCESS_KEY_ID,
  secret_access_key: process.env.SECRET_ACCESS_KEY,
  // 【可选】如果使用临时AK/SK和SecurityToken访问OBS，同样建议您尽量避免使用硬编码，以降低信息泄露风险。您可以通过环境变量获取访问密钥AK/SK，也可以使用其他外部引入方式传入
  // security_token: process.env.SECURITY_TOKEN,
  // endpoint填写Bucket对应的Endpoint, 这里以华北-北京四为例，其他地区请按实际情况填写
  server: "https://obs.cn-north-4.myhuaweicloud.com",
});
async function listObjects() {
  try {
    const params = {
      // 指定存储桶名称
      Bucket: "examplebucket",
      // 指定编码方式，此处以“url”为例，如果列举对象中存在特殊字符，则该参数必传
      EncodingType: "url",
    };
    while (true) {
      // 列举桶内版本对象
      const result = await obsClient.listObjects(params);
      if (result.CommonMsg.Status > 300) {
        console.log("An ObsError was found, which means your request sent to OBS was rejected with an error response.");
        console.log("Status: %d", result.CommonMsg.Status);
        console.log("Code: %s", result.CommonMsg.Code);
        console.log("Message: %s", result.CommonMsg.Message);
        console.log("RequestId: %s", result.CommonMsg.RequestId);
        return;
      };
      console.log("List objects under the bucket(%s) successful!", params.Bucket);
      console.log("RequestId: %s", result.CommonMsg.RequestId);
      for (let j = 0; j < result.InterfaceResult.Contents.length; j++) {
        const val = result.InterfaceResult.Contents[j];
        console.log('Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d',
          j, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size);
      };
      if (result.InterfaceResult.IsTruncated === "true") {
        params.KeyMarker = result.InterfaceResult.NextKeyMarker;
      } else {
        break;
      };
    };
  } catch (error) {
    console.log("An Exception was found, which means the client encountered an internal problem when attempting to communicate with OBS, for example, the client was unable to access the network.");
    console.log(error);
  };
};
listObjects();
```
#### 代码示例六：列举文件夹中的所有对象
OBS本身是没有文件夹的概念的，桶中存储的元素只有对象。文件夹对象实际上是一个大小为0且对象名以"/"结尾的对象，将这个文件夹对象名作为前缀，即可模拟列举文件夹中对象的功能。以下代码展示如何列举文件夹中的对象：
```
// 引入obs库
// 使用npm安装
const ObsClient = require("esdk-obs-nodejs");
// 使用源码安装
// var ObsClient = require('./lib/obs');
// 创建ObsClient实例
const obsClient = new ObsClient({
  // 推荐通过环境变量获取AKSK，这里也可以使用其他外部引入方式传入，如果使用硬编码可能会存在泄露风险
  // 您可以登录访问管理控制台获取访问密钥AK/SK，获取方式请参见https://support.huaweicloud.com/usermanual-ca/ca_01_0003.html
  access_key_id: process.env.ACCESS_KEY_ID,
  secret_access_key: process.env.SECRET_ACCESS_KEY,
  // 【可选】如果使用临时AK/SK和SecurityToken访问OBS，同样建议您尽量避免使用硬编码，以降低信息泄露风险。您可以通过环境变量获取访问密钥AK/SK，也可以使用其他外部引入方式传入
  // security_token: process.env.SECURITY_TOKEN,
  // endpoint填写Bucket对应的Endpoint, 这里以华北-北京四为例，其他地区请按实际情况填写
  server: "https://obs.cn-north-4.myhuaweicloud.com",
});
async function listObjects() {
  try {
    const params = {
      // 指定存储桶名称
      Bucket: "examplebucket",
      // 指定列举对象前缀，此处以“test/”前缀为例，满足指定前缀的对象会被列举
      Prefix: "test/",
      // 指定编码方式，此处以“url”为例，如果列举对象中存在特殊字符，则该参数必传
      EncodingType: "url",
    };
    let count = 1
    while (true) {
      // 列举桶内版本对象
      const result = await obsClient.listObjects(params);
      if (result.CommonMsg.Status > 300) {
        console.log("An ObsError was found, which means your request sent to OBS was rejected with an error response.");
        console.log("Status: %d", result.CommonMsg.Status);
        console.log("Code: %s", result.CommonMsg.Code);
        console.log("Message: %s", result.CommonMsg.Message);
        console.log("RequestId: %s", result.CommonMsg.RequestId);
        return;
      };
      console.log("List objects under the bucket(%s) successful!", params.Bucket);
      console.log("RequestId: %s", result.CommonMsg.RequestId);
      for (let j = 0; j < result.InterfaceResult.Contents.length; j++) {
        const val = result.InterfaceResult.Contents[j];
        console.log('Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d',
          count++, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size);
      };
      if (result.InterfaceResult.IsTruncated === "true") {
        params.Marker = result.InterfaceResult.NextMarker;
      } else {
        break;
      };
    };
  } catch (error) {
    console.log("An Exception was found, which means the client encountered an internal problem when attempting to communicate with OBS, for example, the client was unable to access the network.");
    console.log(error);
  };
};
listObjects();
```
