列举对象

更新时间： 2019-03-14 10:05

您可以通过ObsClient.ListObjects列举出桶里的对象。

该接口可设置的参数如下：


参数

作用

ListObjectsInput.Bucket

桶名。

ListObjectsInput.Prefix

限定返回的对象名必须带有Prefix前缀。

ListObjectsInput.Marker

列举对象的起始位置，返回的对象列表将是对象名按照字典序排序后该参数以后的所有对象。

ListObjectsInput.MaxKeys

列举对象的最大数目，取值范围为1~1000，当超出范围时，按照默认的1000进行处理。

ListObjectsInput.Delimiter

用于对对象名进行分组的字符。对于对象名中包含Delimiter的对象，其对象名（如果请求中指定了Prefix，则此处的对象名需要去掉Prefix）中从首字符至第一个Delimiter之间的字符串将作为一个分组并作为CommonPrefix返回。

简单列举

以下代码展示如何简单列举对象，最多返回1000个对象：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.ListObjectsInput{}
  16.        input.Bucket = "bucketname"
  17.        output, err := obsClient.ListObjects(input)
  18.        if err == nil {
  19.               for index, val := range output.Contents {
  20.                      fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  21.                            index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  22.               }
  23.        } else if obsError, ok := err.(obs.ObsError); ok {
  24.               fmt.Printf("Code:%s\n", obsError.Code)
  25.               fmt.Printf("Message:%s\n", obsError.Message)
  26.        }
  27. }

列举对象 - 图1 说明：

  • 每次至多返回1000个对象，如果指定桶包含的对象数量大于1000，则返回结果中ListObjectsOutput.IsTruncated为true表明本次没有返回全部段，并可通过ListObjectsOutput.NextMarker获取下次列举的起始位置。
  • 如果想获取指定桶包含的所有对象，可以采用分页列举的方式。

指定数目列举

以下代码展示如何指定数目列举对象：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.ListObjectsInput{}
  16.        input.Bucket = "bucketname"
  17.        // 只列举100个对象
  18.        input.MaxKeys = 100
  19.        output, err := obsClient.ListObjects(input)
  20.        if err == nil {
  21.               for index, val := range output.Contents {
  22.                      fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  23.                            index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  24.               }
  25.        } else if obsError, ok := err.(obs.ObsError); ok {
  26.               fmt.Printf("Code:%s\n", obsError.Code)
  27.               fmt.Printf("Message:%s\n", obsError.Message)
  28.        }
  29. }

指定前缀列举

以下代码展示如何指定前缀列举对象：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.ListObjectsInput{}
  16.        input.Bucket = "bucketname"
  17.        // 设置列举带有prefix前缀的100个对象
  18.        input.MaxKeys = 100
  19.        input.Prefix = "prefix"
  20.        output, err := obsClient.ListObjects(input)
  21.        if err == nil {
  22.               for index, val := range output.Contents {
  23.                      fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  24.                            index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  25.               }
  26.        } else if obsError, ok := err.(obs.ObsError); ok {
  27.               fmt.Printf("Code:%s\n", obsError.Code)
  28.               fmt.Printf("Message:%s\n", obsError.Message)
  29.        }
  30. }

指定起始位置列举

以下代码展示如何指定起始位置列举对象：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.ListObjectsInput{}
  16.        input.Bucket = "bucketname"
  17.        // 设置列举对象名字典序在"test"之后的100个对象
  18.        input.MaxKeys = 100
  19.        input.Marker = "test"
  20.        output, err := obsClient.ListObjects(input)
  21.        if err == nil {
  22.               for index, val := range output.Contents {
  23.                      fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  24.                            index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  25.               }
  26.        } else if obsError, ok := err.(obs.ObsError); ok {
  27.               fmt.Printf("Code:%s\n", obsError.Code)
  28.               fmt.Printf("Message:%s\n", obsError.Message)
  29.        }
  30. }

分页列举全部对象

以下代码展示分页列举全部对象：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.ListObjectsInput{}
  16.        input.Bucket = "bucketname"
  17.        // 设置每页100个对象
  18.        input.MaxKeys = 100
  19.        index := 1
  20.  
  21.        for {
  22.               output, err := obsClient.ListObjects(input)
  23.               if err == nil {
  24.                      fmt.Printf("Page:%d\n", index)
  25.                      index++
  26.                      for index, val := range output.Contents {
  27.                            fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  28.                                   index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  29.                      }
  30.                      if output.IsTruncated {
  31.                            input.Marker = output.NextMarker
  32.                      } else {
  33.                            break
  34.                      }
  35.               } else {
  36.                      if obsError, ok := err.(obs.ObsError); ok {
  37.                            fmt.Printf("Code:%s\n", obsError.Code)
  38.                            fmt.Printf("Message:%s\n", obsError.Message)
  39.                      }
  40.                      break
  41.               }
  42.        }
  43. }

列举文件夹中的所有对象

OBS本身是没有文件夹的概念的，桶中存储的元素只有对象。文件夹对象实际上是一个大小为0且对象名以“/”结尾的对象，将这个文件夹对象名作为前缀，即可模拟列举文件夹中对象的功能。以下代码展示如何列举文件夹中的对象：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.ListObjectsInput{}
  16.        input.Bucket = "bucketname"
  17.        // 设置每页100个对象
  18.        input.MaxKeys = 100
  19.        // 设置文件夹对象名"dir/"为前缀
  20.        input.Prefix = "dir/"
  21.  
  22.        // 列举根目录"dir/"下所有对象
  23.        for {
  24.               output, err := obsClient.ListObjects(input)
  25.               if err == nil {
  26.                      for index, val := range output.Contents {
  27.                            fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  28.                                   index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  29.                      }
  30.                      if output.IsTruncated {
  31.                            input.Marker = output.NextMarker
  32.                      } else {
  33.                            break
  34.                      }
  35.               } else {
  36.                      if obsError, ok := err.(obs.ObsError); ok {
  37.                            fmt.Printf("Code:%s\n", obsError.Code)
  38.                            fmt.Printf("Message:%s\n", obsError.Message)
  39.                      }
  40.                      break
  41.               }
  42.        }
  43. }

按文件夹分组列举所有对象

以下代码展示如何按文件夹分组，列举桶内所有对象：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func listObjectsByPrefix(output *obs.ListObjectsOutput) {
  15.        input := &obs.ListObjectsInput{}
  16.        input.Bucket = "bucketname"
  17.        // 设置文件夹分隔符
  18.        input.Delimiter = "/"
  19.  
  20.        for _, commonPrefix := range output.CommonPrefixes {
  21.               input.Prefix = commonPrefix
  22.               output, err := obsClient.ListObjects(input)
  23.               if err == nil {
  24.                      fmt.Printf("Objects in folder [%s]:\n", commonPrefix)
  25.                      for index, val := range output.Contents {
  26.                            fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  27.                                   index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  28.                      }
  29.                      listObjectsByPrefix(output)
  30.               } else if obsError, ok := err.(obs.ObsError); ok {
  31.                      fmt.Printf("Code:%s\n", obsError.Code)
  32.                      fmt.Printf("Message:%s\n", obsError.Message)
  33.               }
  34.        }
  35. }
  36.  
  37. func main() {
  38.        input := &obs.ListObjectsInput{}
  39.        input.Bucket = "bucketname"
  40.        // 设置文件夹分隔符
  41.        input.Delimiter = "/"
  42.  
  43.        output, err := obsClient.ListObjects(input)
  44.  
  45.        if err == nil {
  46.               fmt.Println("Objects in the root directory:")
  47.               for index, val := range output.Contents {
  48.                      fmt.Printf("Content[%d]-OwnerId:%s, ETag:%s, Key:%s, LastModified:%s, Size:%d, StorageClass:%s\n",
  49.                            index, val.Owner.ID, val.ETag, val.Key, val.LastModified, val.Size, val.StorageClass)
  50.               }
  51.               listObjectsByPrefix(output)
  52.        } else if obsError, ok := err.(obs.ObsError); ok {
  53.               fmt.Printf("Code:%s\n", obsError.Code)
  54.               fmt.Printf("Message:%s\n", obsError.Message)
  55.        }
  56. }

列举对象 - 图2 说明：

  • 以上代码示例没有考虑文件夹中对象数超过1000个的情况。
  • 由于是需要列举出文件夹中的对象和子文件夹，且文件夹对象总是以“/”结尾，因此Delimiter总是为“/”。
  • 每次递归的返回结果中ListObjectsOutput.Contents包含的是文件夹中的对象；ListObjectsOutput.CommonPrefixes包含的是文件夹的子文件夹。

父主题：管理对象