文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
MCP广场
返回腾讯云官网
社区首页 >专栏 >golang基础（一）

golang基础（一）

作者头像
阿dai学长
发布于 2020-03-31 03:07:23
发布于 2020-03-31 03:07:23
53000
代码可运行
举报
文章被收录于专栏：阿dai_linux阿dai_linux
运行总次数：0
代码可运行
关联问题
换一批

Go编程结构

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 当前程序的包名
package main

// 导入其他的包
// import "fmt"

// 导入其他的包，并设置别名
import std "fmt"

// 定义常量
const PI  = 3.14

// 全局变量的声明与赋值
var name  = "gopher"

// 一般类型声明：为类型设置别名
type newType int

// 结构的声明
type gopher string{}

// 接口的声明
type golang interface {}

// 由 main 函数作为程序入口点启动
func main() {
   std.Println("Hello world!")
}

Tips：

  • go程序中导入的包如果在程序中未使用，程序会报错，即不能 import 不使用的包；
  • go中可以使用 . 作为包的别名，不过，尽量不要使用，避免降低代码可读性；
  • go中的 private 和 public 是通过大小写来实现的，以大写字母开头的变量、函数等是public型，以小写字母开头的是private型

数据类型与变量

类型和变量都能批量声明，变量组只能用于全局变量声明，不能在函数体重使用。

数据类型

  • 布尔型：bool
  • 整型：int/uint
  • 8位整型：int8/uint8
  • 字节型：byte（unit8别名）
  • 16位整型：int16/uint16
  • 32位整型：int32/uint32
  • 64位整型：int64/uint64
  • 浮点型：float32/float64
  • 复数：complex64/complex128
  • 其他值类型：
    • array、struct、string
  • 引用类型：
    • slice、map、chan
  • 接口类型：interface
  • 函数类型：func

变量

单个变量的声明与赋值

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 变量的声明
var a int

// 变量的赋值
a = 123

// 声明的同时赋值
var a int = 123

多个变量的声明与赋值

  • 全局变量的声明不可以省略 var ，但可以用并行方式
  • 全局变量的声明可以使用 var() 的方式进行简写
  • 局部变量不可以使用 var() 的方式简写，只能使用并行方式
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 多个变量的声明
var a, b, c int

// 多个变量的复制
a, b, c, = 111, 222,333

// 多个变量声明的同时赋值
var d, e, f int = 444, 555, 666

// 省略变量类型，由系统推断
var i, j, k = 777, 888, 999

// 多个变量声明与赋值的最简写法
m, n, o := 1, 2, 3

var (
	// 使用常规方式
	aaa = "hello"
	// 使用并行方式
	sss, bbb = 1, 2
)

// 函数体内只能使用并行方式声明多个变量
func main() {
	var x, y, z int = 444, 555, 666
  // var aa, _, bb, cc = 11, 22, 33, 44  // _ 为空白符号，即忽略对应位置的值
}

类型转换

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 只能在相互兼容的类型之间转换
func main() {
   var a float32 = 1.1
   b := int(a)
   fmt.Println(a)
   fmt.Println(b)
}

练习：计算机存储单位的枚举

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
const (
   B float64 = 1 << (iota * 10)
   KB
   MB
   GB
   TB
   PB
)

func main() {
   fmt.Println(B)
   fmt.Println(KB)
   fmt.Println(MB)
   fmt.Println(GB)
   fmt.Println(TB)
   fmt.Println(PB)
}

补充内容

go保留了指针，但不支持指针运算以及 -> 运算符，而直接采用 . 选择符来操作指针目标对象的成员。

  • 操作符 & 取变量地址，使用 * 通过指针间接访问目标对象
  • 默认值为 nil，而非 NULL

go语言中（递增、递减），++ 与 -- 是作为语句而并不是作为表达式（即，只能作为单独的语句存在）。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 指针
func main() {
	a := 1
	var p *int = &a  // 指针 p 指向变量 a 的地址
	fmt.Println(p)  // 打印指针
	fmt.Println(*p)  // 打印指针对应的目标对象
}

// ++ 和 --
func main() {
	// a := a++  // 不允许这样
	a := 1
	a++
	var p *int = &a
	fmt.Println(p)
	fmt.Println(*p)
}

go控制语句

判断语句 if

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
func main() {
   a := 10
   if a, b := 1, 3; a > 0 {
      fmt.Println(a)
      fmt.Println(b)
   }
   fmt.Println(a)
}

循环语句 for

go语言中只有 for 循环。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 普通 for 循环
func main() {
   a := 1
   for {
      a++
      if a > 3 {
         break
      }
      fmt.Println(a)

   }
   fmt.Println("Over!")
}

// for 循环本身带条件
func main() {
	a := 1
	for a <= 3 {
		a++
		fmt.Println(a)
	}
	fmt.Println("Over!")
}

// 经典用法：计数器(i)
func main() {
	a := 1
	for i := 0; i <= 3; i++ {
		a++
		fmt.Println(a)
	}
	fmt.Println("Over!")
}

选择语句 switch

默认满足某个 case 后自动 break，如果想继续执行后面的 case，需要使用 fallthrough 语句。

类似 python 中的 if...elif...else...

switch 中有变量 swithc a {}，则case中默认使用该变量创建表达式（ case 0: ）；如果switch中没有变量 switch {}，则需要在case中使用变量创建表达式（case a==0:）。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 普通用法
func main() {
   a := 1
   switch a {
   case 0:
      fmt.Println("a=0")
   case 1:
      fmt.Println("a=1")
   default:
      fmt.Println("None")
   }
}

// fallthrough
func main() {
	a := 1
	switch {
	case a <= 0:
		fmt.Println("a=0")
	case a >= 1:
		fmt.Println("a=1")
		fallthrough
	default:
		fmt.Println("None")
	}
}

// 带一个初始化语句
func main() {
	switch a := 1; {
	case a >= 10:
		fmt.Println("a=0")
	case a >= 1:
		fmt.Println("a=1")
		fallthrough
	default:
		fmt.Println("None")
	}
}

跳转语句 goto，break，continue 和 标签

跳转语句都可以配合标签使用。标签区分大小写。

goto用于调整执行位置；break和continue配合标签可以跳出多层循环。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 跳出 LABEL1 循环
func main() {
LABEL1:
   for {
      for i := 0; i < 10; i++ {
         if i > 3 {
            break LABEL1
         }
         fmt.Println(i)
      }
   }
   fmt.Println("Over")
}

// continue 本身可以是一个无限循环；但是 continue 对应的标签必须有限循环，不然会造成死循环；
func main() {
LABEL1:
	for i := 0; i < 10; i++ { // 有限循环，即 LABEL1 对应有限循环
		fmt.Println(i)
		for {  // 无限循环
			continue LABEL1 // 有限循环标签
			fmt.Println("???")
		}
	}
	fmt.Println("Over")
}

练习：for + switch + if

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
func main() {
   a := 1
   for {
      switch {
      case a <= 5:
         fmt.Println("a=", a)
      case a > 5 && a <= 10:
         fmt.Println("a=", a)
         fallthrough
      default:
         fmt.Println("None")
      }
      a++
      if a > 10 {
         fmt.Println("Over...", "a=", a)
         break
      }
   }
}

Tips： goto 结合标签使用的时候，标签放在 goto 语句的后面，避免造成死循环。

数组：array

  • 定义数组格式：var <varName> [n]<type> ，n>=0 。
  • 数组之间可以用 == 或 != 比较，但是不可以使用 < 或 >
  • 可以使用new来创建数组，此方法返回一个指向数组的指针，但是可以通过指针对数组进行操作
  • 如果不值得数组的长度，可以使用 [...] 来让系统自动计算数组长度（注意：该方法只能用于顶级数组）
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 普通
func main() {
	var a [2]int
  fmt.Println(a)
	a[0] = 5
	a[1] = 6
	fmt.Println(a)
}

// 最简方式
func main() {
	a := [2]int{7, 8}
	fmt.Println(a)
}

// 为数组的某一位赋值
func main() {
	a := [2]int{7, 8}
	fmt.Println(a)
	b := [10]int{5: 5}
	fmt.Println(b)
}

// 数组间的比较
func main() {
	a := [2]int{1, 2}
	b := [2]int{1, 2}
	fmt.Println("a=", a)
	fmt.Println("b=", b)
	fmt.Println(a == b)
	fmt.Println(a != b)
}

// 使用new方法创建数组
func main() {
	a := [10]int{}
	a[1] = 2
	fmt.Println(a)

	p := new([10]int)
	p[1] = 2  // 通过指针对数组中单个元素进行操作
	fmt.Println(p)
}

指向数组的指针 和 指针数组

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
func main() {
   a := [10]int{9, 1}
   var p *[10]int = &a // 指向数组的指针
   fmt.Println(p)

   x, y := 1, 2
   b := [...]*int{&x, &y} // 指针数组
   fmt.Println(b)
}

在go语言中数组是值类型。

多维数组：数组中嵌套数组

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
func main() {
   a := [2][3]int{ // 含义是：数组a包含2个元素，每个元素为长度为3的int型数组
      {1, 1, 1},
      {2, 2, 2}}

   fmt.Println(a)
}

go语言实现冒泡排序

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
func main() {
   a := [...]int{5, 3, 6, 7, 9}
   fmt.Println(a)

   num := len(a)
   for i := 0; i < num; i++ {
      for j := i + 1; j < num; j++ {
         if a[i] < a[j] {
            temp := a[i]
            a[i] = a[j]
            a[j] = temp
         }
      }
   }
   fmt.Println(a)
}

切片：slice

  • 切片本身不是数组，它指向的是一个数组
  • 一般使用 make() 创建
  • 用于切片的两个函数：
    • len()：获取切片长度
    • cap()：获取切片容量
  • 如果多个切片(slice)指向相同底层数组，其中一个值的改变会影响全部
  • 创建切片的格式：make([]Type, len, cap)
    • len：表示切片当前实际长度
    • cap：容量，表示当前切片超出len后的最大容量，用于预分配资源（提升效率）
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// 
func main() {
	var s1 []int // 声明slice，结果为一个空的slice
	fmt.Println(s1)

	a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
  s2 := a[0:5] // 从已有数组中取值
	fmt.Println(s2)
	s3 := a[5:]
	fmt.Println(s3)
}

// make中的 len 和 cap
func main() {
	s1 := make([]int, 5, 10)
	fmt.Println(s1)
	fmt.Println(len(s1), cap(s1))
}

reslice：从一个slice中获取新的slice

  • reslice时索引以被slice的切片为准
  • 索引不可超过被slice的切片的容量cap()值
  • 索引越界不会导致底层数组重新分配，而是引发错误

slice与底层数组的对应关系：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
func main() {
   a := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'}
   fmt.Println("================= aa ===================")
   fmt.Println("a=", string(a))
   fmt.Println("len(a)=", len(a), "cap(a)=", cap(a))
   fmt.Println("================= sa ===================")
   sa := a[2:5]
   fmt.Println("sa=", string(sa))
   fmt.Println("len(sa)=", len(sa), "cap(sa)=", cap(sa))
   fmt.Println("================= sb ===================")
   sb := sa[3:5]
   fmt.Println("sb=", string(sb))
   fmt.Println("len(sb)=", len(sb), "cap(sb)=", cap(sb))
}

append

  • 可以在slice尾部追加元素
  • 可以将一个slice追加到另一个slice的尾部
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
func main() {
	s1 := make([]int, 3, 6)
	fmt.Printf("%p %v\n", s1, s1)
	s1 = append(s1, 1, 2, 3)  // 未超出原始slice容量时，内存地址不变
	fmt.Printf("%p %v\n", s1, s1)
	s1 = append(s1, 1, 2, 3)  // 超出原始slice容量时，会重新分配内存地址
	fmt.Printf("%p %v\n", s1, s1)
}


func main() {
	a := []int{1, 2, 3, 4, 5}
	s1 := a[2:5]
	s2 := a[1:3]
	fmt.Println(s1, s2) // 此时 s1,s2 共用 a[2]
	s1[0] = 9           // 多个切片(slice)指向相同底层数组，其中一个值的改变会影响全部
	fmt.Println(s1, s2)
	fmt.Println(a)
	s2 = append(s2, 1, 2, 3, 4, 5, 6, 7)
	s1[0] = 10
	fmt.Println(s1, s2) // 超出原始切片（s1）容量的部分不受影响，因为超出原始切片容量后，已分配新的内存地址
	fmt.Println(a)
}

copy

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
// copy时，以短的slice中元素长度为准进行copy
func main() {
   s1 := []int{1, 2, 3, 4, 5, 6}
   s2 := []int{7, 8, 9}
   fmt.Println(s1, s2)
   copy(s1, s2)
   fmt.Println("new:: ", s1, s2)

   s3 := []int{1, 2, 3, 4, 5, 6}
   s4 := []int{7, 8, 9}
   fmt.Println(s3, s4)
   copy(s4, s3)
   fmt.Println("new:: ", s3, s4)
}

// 拷贝到目标切片的指定位置
func main() {
	s1 := []int{1, 2, 3, 4, 5, 6}
	s2 := []int{7, 8, 9}
	fmt.Println(s1, s2)
	copy(s1[2:5], s2) 
	fmt.Println("new:: ", s1, s2)
}
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除
go
编程算法

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

go
编程算法
评论
登录后参与评论
暂无评论
登录 后参与评论
推荐阅读
编辑精选文章
换一批
万字详解高可用架构设计
5615
Go 开发者必备：Protocol Buffers 入门指南
3332
10分钟带你彻底搞懂分布式链路跟踪
2451
多租户的 4 种常用方案
4802
亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？
3431
60页PPT全解：DeepSeek系列论文技术要点整理
4759
【GoLang#2】：基础入门（工具链 | 基础语法 | 内置函数）
基础入门语法工具函数
Go 编译器是一行一行进行编译的，因此我们一行就写一条语句，不能把多条语句写在一起
IsLand1314
2025/08/08
1340
​Golang切片(Slice)
jquery编程算法go
举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。
PayneWu
2020/12/18
8960
​Golang切片(Slice)
​go语言的31个坑
gohttp编程算法utf8
在其他大多数语言中，{的位置你自行决定。Go比较特别，遵守分号注入规则（automatic semicolon injection）：编译器会在每行代码尾部特定分隔符后加;来分隔多条语句，比如会在 )后加分号：
阿兵云原生
2023/02/16
8510
【Go】深入剖析slice和array
gojavascript编程算法
array 和 slice 看似相似，却有着极大的不同，但他们之间还有着千次万缕的联系 slice 是引用类型、是 array 的引用，相当于动态数组， 这些都是 slice 的特性，但是 slice 底层如何表现，内存中是如何分配的，特别是在程序中大量使用 slice 的情况下，怎样可以高效使用 slice？ 今天借助 Go 的 unsafe 包来探索 array 和 slice 的各种奥妙。
thinkeridea
2019/11/04
5160
【Go】深入剖析slice和array
GoLang语言--的函数运用
其他
首先要学习一下go 语言的变量定义等等 我把代码copy一下 package mainimport ("fmt") type Books struct{ title string author string subject string } func main() { //分配内存，不够内存为空 Books1 :=new(Books) Books1.title="go语言开发" Books1.author="多啦A梦" Books1.subje
李海彬
2018/03/21
6560
深度解密Go语言之Slice
编程算法gojqueryhttps网络安全
Go 语言的 slice 很好用，不过也有一些坑。slice 是 Go 语言一个很重要的数据结构。网上已经有很多文章写过了，似乎没必要再写。但是每个人看问题的视角不同，写出来的东西自然也不一样。我这篇会从更底层的汇编语言去解读它。而且在我写这篇文章的过程中，发现绝大部分文章都存在一些问题，文章里会讲到，这里先不展开。
李海彬
2019/05/08
9820
深度解密Go语言之Slice
Go基础之--数组和切片
go
数组 数组的定义： 数组是具有固定长度并拥有零个或者多个相同数据类型元素的序列 定义一个数组的方法： var 变量名[len] type 例子： var a[5] int //3个整数的数组 var
coders
2018/01/04
8060
Go基础之--数组和切片
go 学习笔记之数组还是切片都没什么不一样
go编程算法
上篇文章中详细介绍了 Go 的基础语言,指出了 Go 和其他主流的编程语言的差异性,比较侧重于语法细节,相信只要稍加记忆就能轻松从已有的编程语言切换到 Go 语言的编程习惯中,尽管这种切换可能并不是特别顺畅,但多加练习尤其是多多试错,总是可以慢慢感受 Go 语言之美!
雪之梦技术驿站
2019/08/18
4430
golang之切片
其他
4.cap可以求出slice最大的容量，0<=cap(slice)  <=len(array)，其中array是slice引用的数组
超蛋lhy
2018/08/31
3950
golang之切片
golang 学习笔记
编程算法gohttplinux
go语言完整的定义的变量的方法为 var 变量名 类型=值，var name string ="fuwei",可以简写为name:="fuwei"（这种只能在函数内使用，无法再包内使用），
付威
2021/05/06
1.1K0
golang学习笔记之一 - 基础知识与概念
变量函数数组学习笔记指针
go中字符称为rune，等价于C中的char，可直接与整数转换。rune实际是整型，必需先将其转换为string才能打印出来，否则打印出来的是一个ascii整数
躺平程序员老修
2023/09/05
2890
golang学习笔记——数据和切片
编程算法jquery
fmt.Printf("s2 : len(s2) = %d,cap(s2) = %d \n", len(s2), cap(s2))
码缘
2021/03/04
3520
golang中数组和切片到底有什么区别？
编程算法jquerygo
数组大家都知道是具有「固定长度及类型的序列集合」,但是golang中又引入了「切片」，语法上看起来还和数组差不多，为什么会引入这些呢？切片和数组到底有什么区别呢？接下来咱们来一个一个的看
程序员小饭
2023/02/24
7500
golang中数组和切片到底有什么区别？
GO基础知识分享
c 语言go编程算法
空白标识符 _ 也被用于抛弃值，如值 5 在 _, b = 5, 7 中被抛弃。
阿兵云原生
2023/02/16
4170
A Bite of GoLang(上)
gogithubpython
A bite of GoLang（浅尝GoLang），本文只是Go语言的冰山一角，本文包含作者学习Go语言期间积累的一些小的经验，同时为了方便让读者了解到Go语言中的一些概念，文中包含了许多快速简洁的例子，读者后期可以去自行拓展。当然写这篇文章的灵感来源于GitHub上的 a bite of Python
盛国存
2018/05/14
1.2K4
A Bite of GoLang(上)
Golang切片与实现原理
slice函数内存数组原理
array是切片用来存储数据的底层数组的指针，len为切片中元素的数量，cap为切片的容量即数组的长度
Orlion
2024/09/02
1240
Golang切片与实现原理
Golang的slice
编程算法jquerygo
今天来说个简单的，也不简单的东西，那就是切片。slice对于golang来说那真的是一个非常常用的东西了，很多地方都会用到它，今天就来说说，slice底层是如何实现的，又有哪些坑是需要提前注意的。
LinkinStar
2022/09/01
4540
3.Go编程快速入门学习
编程算法gojquery
比如：var a [5]int， 数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变。注意: [5]int和[10]int是不同的类型。
全栈工程师修炼指南
2022/09/29
4360
3.Go编程快速入门学习
Go 从入门到精通（三）字符串，时间，流程控制，函数
go
coders
2018/01/04
7090
Golang高效实践之泛谈篇
编程算法gophp
我博客之前的Golang高效实践系列博客中已经系统的介绍了Golang的一些高效实践建议，例如：《Golang高效实践之interface、reflection、json实践》、《Golang 高效实践之defer、panic、recover实践》、《Golang 高效实践之并发实践context篇》、《Golang 高效实践之并发实践channel篇》，本文将介绍一些零散的Golang高效实践建议，虽然琐碎但是比较重要。
用户2937493
2019/08/29
4980
推荐阅读
编辑精选文章
万字详解高可用架构设计Go 开发者必备：Protocol Buffers 入门指南10分钟带你彻底搞懂分布式链路跟踪
相关讨论
sdk for golang？使用Golang如何快速稳定构建一个桌面应用？CMQ哪有官方GOLANG SDK？
相关课程
AI绘画-StableDiffusion图像生成微信小程序应用实践_《锋运票务系统》TDSQL for PG训练营
【GoLang#2】：基础入门（工具链 | 基础语法 | 内置函数）
1340
​Golang切片(Slice)
8960
​go语言的31个坑
8510
【Go】深入剖析slice和array
5160
GoLang语言--的函数运用
6560
深度解密Go语言之Slice
9820
Go基础之--数组和切片
8060
go 学习笔记之数组还是切片都没什么不一样
4430
golang之切片
3950
golang 学习笔记
1.1K0
golang学习笔记之一 - 基础知识与概念
2890
golang学习笔记——数据和切片
3520
golang中数组和切片到底有什么区别？
7500
GO基础知识分享
4170
A Bite of GoLang(上)
1.2K4
Golang切片与实现原理
1240
Golang的slice
4540
3.Go编程快速入门学习
4360
Go 从入门到精通（三）字符串，时间，流程控制，函数
7090
Golang高效实践之泛谈篇
4980
相关推荐
【GoLang#2】：基础入门（工具链 | 基础语法 | 内置函数）
更多 >
阿dai学长0
LV.1
待业运维工程师
文章
250
获赞
689
专栏
1
作者相关精选
换一批
加入讨论
的问答专区 >
北京-宏哥0
北京宏哥擅长4个领域
相关课程
一站式学习中心 >
云开发微搭低代码平台-一人构建企业级应用实战训练营
2495人在学
腾讯云微搭低代码
云开发
微信小程序应用实践_《锋运票务系统》
334人在学
云托管 CloudBase Run
Serverless 容器服务
对象存储
云数据库 MySQL
TDSQL for PG训练营
208人在学
分布式数据库 TDSQL
数据库
云数据库 PostgreSQL
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论
2