Go语言教程（一看就会）

已于 2024-07-27 16:41:54 修改
阅读量1.3k 收藏 16
点赞数 12
分类专栏： go 文章标签： golang 学习 开发语言
于 2024-07-25 22:16:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bjjgff/article/details/140701054
版权

 

全篇文章 7000 字左右， 建议阅读时长 1h 以上。  

Go语言是一门开源的编程语言，目的在于降低构建简单、可靠、高效软件的门槛。Go平衡了底层系统语言的能力，以及在现代语言中所见到的高级特性。它是快速的、静态类型编译语言。

第一个GO程序

package main // 程序组织成包 (1)

import "fmt" // 格式化输出数据 (2)

// 主函数入口 (3)
func main() {
    fmt.Println("你好世界") // 输出语句 (4)
}

逐行解析这个程序

  • (1) 这里是每个go文件必备的，如果当前文件是独立执行必须要使用 package main
  • (2) 引入了一个名为 fmt 的库包。
  • (3) 当go程序执行时，首先调用的就是main.main()函数
  • (4) 调用了fmt库中的Println函数，在屏幕中打印字符串信息。

构建和运行Go程序

  • 构建需要在命令行中输入 go build 文件名.go， 执行后会生成一个同名的可执行文件。
  • 命令行中输入 ./文件名 即可运行

如果你没有本地的Go语言环境，可以通过浏览器在线方式学习: https://go.dev/play/

一、数据类型

1.1 变量

Go语言是一种静态类型的编程语言。

可以通过 var 声明一个或多个变量

var str = "apple"

也可以通过 := 语法来进行初始化变量的简写

str := "apple"

以上两种创建方式应用代码如下：

package main

import "fmt"

func main() {
	var a = "saycode" // 字符串
	fmt.Println(a)

	var b, c int = 1, 2 // 整型
	fmt.Println(b, c)

	var d = true 	// 布尔型
	fmt.Println(d)

	var e int		// 声明变量类型为 int
	fmt.Println(e)

    // 简化方式
	f := "apple" // 字符串
	fmt.Println(f)

	g := true	// 布尔型
	fmt.Println(g)
}

多个var声明可以成组

var (
    x int,
    y bool
)

如果涉及到多个变量同类型的情况，可以进行平行赋值。

// 多行
name := "saycode"
age := 10

// 平行
name, age := "saycode", 10

特殊变量 _(下划线)

对于下划线而言，任何值赋值给它，都会被舍弃。程序将3赋值给b，1进行舍弃。

_, b := 1, 3

 1.2 常量

常量是可不变的值，Go语言支持字符、字符串、布尔值和数字值的常量。

使用 const 关键字声明

错误案例

运行当前程序发现报错cannot assign to name (untyped string constant "I Like Go")，也就证实了，常量进行初始化值后，是不可以进行改变的。

package main

import "fmt"

func main() {
    const name := "I Like Go"
    name = "I Like Java"

    fmt.Println(name)
}

正确案例

将π作为常量进行声明，接着去计算出圆的面积。

package main

import "fmt"

const PI = 3.14

func main() {
	// 计算圆的面积
	const r = 2
	const area = PI * r * r

	fmt.Println(area)
}

二、格式化输出

2.1 默认方式

如果不确定要用什么，可以直接使用%v (最好使用特定)

fmt.Printf("我今年 %v 岁", 20)
// 我今年 20 岁
fmt.Printf("我叫 %v", "张三")
// 我叫 张三

2.2 字符串

当需要特定插入字符串时，可使用 %s

fmt.Printf("我叫 %s", "张三")

2.3 十进制整数

当需要特定插入十进制整数时，可使用%d

fmt.Printf("我今年 %d 岁", 10)
// 我今年 10岁

2.4 浮点数

当需要插入浮点数时，可使用 %f

.数字f (.2f)，含义就是保留小数点后两位

fmt.Printf("我今年 %f 岁", 10.22)
// 我今年 10.220000岁
fmt.Printf("我今年 %.2f 岁", 10.22)
// 我今年 10.22岁

2.5 变量类型

当需要查看当前变量类型时，可使用%T

package main

import "fmt"

func main() {
    
	num := 10
	fmt.Printf("num类型为 %T", num)
}

三、控制结构

3.1 条件判断if

if语句是一种用于判断条件的结构，他将根据布尔表达式，结果就是 (true 或 false)的结果来决定是否执行某段代码。

else 是不满足前一个 if 后去执行的代码块。

如下代码就是判断 x > 5(布尔表达式), 如果大于则执行"x大于5"，否则执行 "x小于或等于5"

if x > 5 {
    fmt.Println("x大于5")
} else {
    fmt.Println("x小于或等于5")
}

3.2 if的嵌套

可以通过嵌套的方式去判断多个值

if x > 5 {
    fmt.Println("x大于5") 
} else if x < 5 {
    fmt.Println("x小于5")
} else {
    fmt.Println("x等于5")
}

if语句可以有初始化语句，初始化语句中创建的变量只在if语句块中使用。

以下代码是通过getLength方法去获取email字符串的长度，在去对长度进行判断大小是否小于1。

package main

import "fmt"

func main() {
	email := "nazhanpeng@163.com"
    // 语法糖创建
	if length := getLength(email); length < 1 {
		fmt.Println("邮箱长度小于1")
	} else {
		fmt.Println("邮箱没问题")
	}

}

func getLength(a string) int {
	return len(a)
}

3.4 goto

可以使用goto去跳转到当前函数的内定标签位置。例如以下示例。

package main

import "fmt"

func myGoto() {
	i := 1
Position:	// 定义跳转目标标签(注意要以冒号结尾)
	fmt.Println(i)
	i++	// i++ == i+1
	if i == 10 {	// 限制输出10次以内
		return
	}

	goto Position	// 跳转到目标标签
}

func main() {
	myGoto()
}

3.5 for循环

for循环的写法有三种形式

(1)、for 初始化语句; 条件语句; 后置语句 { } 正常循环

package main

import "fmt"

func main() {
	sum := 0
	for i := 0; i < 10; i++ {
		sum += i	//  将i的值进行累加
	}
	fmt.Println("sum = ", sum)
}

(2)、for 条件语句 { } 和while一样

package main

import "fmt"

func main() {

	sum, i := 0, 0

	for i < 10 {
		sum += i
		i++
	}

	fmt.Println("sum = ", sum)

}

(3)、for { } 死循环

package main

import "fmt"

func main() {
	for {
        fmt.Println("我爱学 Go")
    }
}

3.6 break

利用break可以终止当前语句的执行。下面循环打印了0-5。

package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		if i > 5 {
			break // 终止当前循环
		}
		fmt.Println("i=", i)
	}
}

3.7 continue

可以让循环进入下一次迭代，也就是跳过当前这一次的循环。下面循环打印了0-9,但是当i=5时，跳过了。

package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		if i == 5 {
			continue
		}
		fmt.Println("i=", i)
	}
}

3.8 switch

从上到下去执行switch的代码块，直到找到匹配项，如果switch没有表达式，会去匹配true。

package main

import "fmt"

func main() {
	i := 1

	switch i {	// 检测i的值是否有匹配项
	case 0:	// case 值，为匹配项
		fmt.Println("i=0")
	case 1:
		fmt.Println("i=1")
	}
}

当我进行匹配时，想让它向下进行匹配时，需要用到 fallthroungh 关键字。下面当i=0时，会自定向下匹配，去执行对应语句。

package main

import "fmt"

func main() {
	i := 0

	switch i {
	case 0:
		fallthrough
	case 1:
		fmt.Println("寻找到了", i)
	}
}

我们也可以去指定当没有任何匹配项时的默认行为，使用 default 关键字。下面当i=2时，会默认去执行默认行为。

package main

import "fmt"

func main() {
	i := 2

	switch i {
	case 0:
		fallthrough
	case 1:
		fmt.Println("寻找到", i)
	default:	// 如果i不等于0和1，则默认执行
		fmt.Println("默认执行")
	}
}

也可以在一个case中匹配匹配多个值,使用逗号进行分隔。下面将1-5的数字进行分隔。

package main

import "fmt"

func main() {
	i := 1

	switch i {
	case 1, 2, 3, 4, 5: // 逗号相当于 或，也就是 1 或 2 或 3 或 4 或 5
		fmt.Println("i=", i)
	}
}

四、数组

数组是一种固定长度、同类型元素的集合。数组的长度在声明时就被确定，并且无法改变。

4.1 创建数组

var 数组名 [数组长度]数组类型

var nums [5]int
var names [3]string

4.2 数组初始化

可以在声明数组的同时去进行初始化

nums := [5]int{1, 2, 3, 4, 5}
names := [3]string{"张三", "李四", "王五"}

对于数组长度可以使用省略号来进行替换，这样编译器会通过初始化值的数量去判断数组的长度。

nums := [...]int{1, 2, 3, 4, 5}

对于访问数组元素，可以通过数组下标来进行访问。 数组下标都是以0开始。下面有一个整数数组1到5。它的下标值是这样的。

下面声明一个1到5元素的数组，对数组元素进行访问。

package main

import "fmt"

func main() {
	arr := [5]int{1, 2, 3, 4, 5} // 声明数组
	fmt.Println("arr[0]=", arr[0]) // 访问下标0位置的元素
	fmt.Println("arr[2]=", arr[2]) // 访问下标2位置的元素
}

4.3 遍历数组的两种方式

(1)、通过for循环进行遍历数组。

package main

import "fmt"

func main() {
	nums := [...]int{1, 2, 3, 4, 5}

	for i := 0; i < len(nums); i++ {
		fmt.Println(nums[i])
	}
}

(2)、通过for循环进行遍历数组。 

range 是一个迭代器，使用时会在循环的内容中返回一个键值对。下面是一个range循环的一个写法， k是键，v是值。range后面紧接着遍历数据

for k, v := range slice/array/string/map/channel { }

下面是使用range 去遍历一个nums 的一个数组的例子。

package main

import "fmt"

func main() {
	nums := [...]int{1, 2, 3, 4, 5}

	for index, value := range nums {
		fmt.Printf("索引: %d, 值: %d\n", index, value)
	}
}

4.4 声明多维数组

var 数组名 [数组长度][数组长度]数组类型

var nums [3][4]int // 声明一个 3*4的二维整数型数组

可以在声明多维数组时，直接进行初始化。

package main

import "fmt"

func main() {
	nums := [3][4]int{
		{1, 2, 3, 4},
		{5, 6, 7, 8},
		{9, 10, 11, 12},
	}

	fmt.Println(nums)
}

初始化后的样子如下。

当我们对部分值进行初始化，未被初始化的位置将被赋值为0。

package main

import "fmt"

func main() {
	nums := [3][4]int{
		{1, 2},
		{5, 6, 7},
	}

	fmt.Println(nums)
}

初始化后的样子如下。

4.5 访问和修改多维数组

可以通过索引访问和修改多维数组的元素。

package main

import "fmt"

func main() {
	nums := [3][4]int{
		{1, 2, 3, 4},
		{5, 6, 7, 8},
		{9, 10, 11, 12},
	}

	fmt.Println(nums)

	nums[1][2] = 10
	fmt.Println(nums[1][2])
}

对于遍历多维数组，可以使用for循环嵌套来进行遍历。下面程序中i代表的是多维数组的行，j代表的是多维数组的列，也就是多维数组要是用两个下标才可以进行访问。

package main

import "fmt"

func main() {
	nums := [3][4]int{
		{1, 2, 3, 4},
		{5, 6, 7, 8},
		{9, 10, 11, 12},
	}

	for i := 0; i < len(nums); i++ {
		for j := 0; j < len(nums[i]); j++ {
			fmt.Printf("nums[%d][%d]=%d\n", i, j, nums[i][j])
		}
	}
}

上面程序中nums数组的下标值如下。

五、slice

动态数组(slice)是对数组的抽象。它可以改变长度和容量，并能共享底层数组的数据。

5.1 创建slice

var s []int // 声明一个整数类型的 动态数组

从另一个数组中创建动态数组

arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4] // 创建一个包含 arr中从索引1到索引3元素的动态数组

s2 := s[1:2] // 创建一个基于s的动态数组

5.2 make函数

可以使用内置 make 函数来创建一个指定长度和容量的slice。下面所说的长度为5，容量为10，是说会创建可以容纳10个的slice，默认插入5个为0的整数。

package main

import "fmt"

func main() {
	s1 := make([]int, 5) // 长度为5的整数。
	s2 := make([]int, 5, 10) // 长度为5，容量为10的整数。

	fmt.Println(s1)
	fmt.Println(s2)

}

也可以通过字面量的方式去进行初始化。

s := []int{1, 2, 3, 4, 5}

5.3 len函数与cap函数

假设我们创建了一个slice，可以通过len函数和cap函数来获取对应的长度和容量。

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4, 5}
	fmt.Println("长度: ", len(s)) // 5
	fmt.Println("容量: ", cap(s)) // 5
}

5.4 追加元素

通过使用内容函数 append向slice内追加元素，并且会返回追加后的slice

var 数组名 [数组长度][数组长度]数组类型

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    s = append(s, 4, 5)
    fmt.Println(s) // [1 2 3 4 5]
}

如果被追加的slice 没有足够的容量去存储追加的元素，append 会分配一个足够大的slice来存放原有slice和追加的元素。

package main

import "fmt"

func main() {
    s0 := []int{0, 1}
    s1 := append(s0, 2) // 追加一个元素2, [0 0 2]
    s2 := append(s1, 3) // 追加一个元素3, [0 0 2 3]
}

5.5 copy函数

copy函数可以从slice中复制元素到新的slice。会返回复制的元素的个数。

package main

import "fmt"

func main() {
	var a = [...]int{0, 1, 2, 3, 4, 5}
	var s = make([]int, 4)
	l1 := copy(s, a[0:]) // 从slice 0开始复制并存储到s中， [0 1 2 3]
	fmt.Println(s)
	fmt.Println("l1=", l1)

	l2 := copy(s, s[2:]) // 从slice 2开始复制并存储到s中， [2 3 2 3]
	fmt.Println(s)
	fmt.Println("l2=", l2)
}

5.6 遍历 slice

可以使用for循环进行遍历

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    for i := 0; i < len(s); i++ {
        fmt.Println(s[i)
    }
}

也可以使用for range循环遍历

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    for index, value := range s {
        fmt.Printf("索引: %d, 值: %d\n", index, value)
    }
}

六、函数

一个基本的函数需要包含函数名、参数列表、返回值类型和函数体。

例如定义一个函数名为add的函数，包含两个参数a、b，返回值类型为int类型，函数体是a+b计算两个整数的和。

func add(a int, b int) int {
    return a + b
}

函数可以有0个或多个参数。

4.1 返回结果

一般用于去终止函数并返回结果。在Go中可以返回单个值或多个值。

单个值返回已经在上面返回了。

4.1.1 多个值返回

package main

import "fmt"

func divide(a int, b int) (int, int) {
    quotient := a / b
    remainder := a % b
    return quotient, remainder
}

func main() {
    q, r := divide(4, 3)
    fmt.Println(q,r)
}

4.1.2 命名返回值

命名返回值在函数代码块内为局部变量，可以进行使用。

package main

import "fmt"

func rectangleArea(width, height int) (area int) {

    area = width * height
    return
}

func main() {
    area := rectangleArea(5,6)
    fmt.Println("area", area)
}

4.1.3 空返回语句

可以使用空return返回结果

package main

import "fmt"

func swap(a, b int) (x, y int) {
    x = b
    y = a
    return
}

func main() {
    x, y := swap(1,2)
    fmt.Println("x", y, "y", y)
}

4.1.4 按照值传递变量

意味着当一个变量传递给一个函数时，该函数收到的是该变量的副本。

我们发现x的值还是5，就说明函数无法去改变传递变量的值。

package main

import "fmt"

func main() {
	x := 5
	increment(x)

	fmt.Println("x=", x)

}

func increment(x int) {
	x++
}

明天继续更新,请关注我

小那同学
关注
  • 12
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Go语言学习教程（一）
小陈工的博客
06-05 421
一、Go语言简介Go语言是谷歌公司于2009年11月发布的编程语言。Go语言是一种开源的程序设计语言,它使得开发者可以方便地构建简单、可靠、高效的软件。二、Go语言优势* 语法简单* 可以直接编译成机器码* 静态数据类型和编译语言* 内置支持并发* 内置垃圾回收* 部署简单* 强大的标准库三、Go语言适用场景* 服务器编程.实现日志处理,虚拟机处理,文件处理等* 分布式系统或数据库代理* 网络编程,包含web应用* 云平台四、Go语言下载4.1 可以通过Go语言中文网进行加载资源和交流Go语言技术网址：ht
go语言中文教程及手册.pdf
05-06
go语言中文教程及手册. Go 编程语言是一个使得程序员更加有效率的开源项目。Go 是有表达力、简洁、清晰和有效率的。它的并行机制使其很容易编写多核和网络应用，而新ᓆ的类型系统允许构建有ᧄ性的模块化程序。Go编译到机器码非常快速，同时具有便利的垃圾回收和强大的运行时反射。它是快速的、静态类型编译语言，但是感觉上是动态类型的，解释型语言。 《go语言中文教程及手册》包含了语言结构、基础语法、数据类型、语言变量、语言常量以及运算符等内容的介绍，可以让你快速进阶为go语言编程高手。简洁，一句废话没有，对于初学者可以让大家快速掌握GO语言！
Go语言笔记.nyf（教程笔记）
10-24
B站《【整整500集】清华大佬196小时讲完的Go语言教程（golang进阶实战）全程干货无废话》教程笔记
go学习教程
07-29
go语言入门，精通go语言，go语言的网络编程。三本高清书带书签，你值得拥有！
Golang入门教程（非常详细）从零基础入门到精通，看完这一篇就够了
热门推荐
2401_84248681的博客
04-13 1万+
Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。中文网在线标准库文档。
go语言入门详细教程
qq_55706127的博客
05-16 8410
二.对go语言基础语法的介绍
Go 语言 入门教程
胭脂草的ABC博客
04-19 961
首页 文章 Go 语言 入门教程 物干焯·2018-08-03 14:34:51· 9878 次点击 ·预计阅读时间 13 分钟·42分钟之前开始浏览 这是一个创建于2018-08-03 14:34:51的文章，其中的信息可能已经有所发展或是发生改变。 1. 概述 Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。Go是从2007年末由...
Go语言入门详细教程
m0_53328239的博客
07-01 3386
Go语言最初由Google公司的Robert Griesemer、Ken Thompson和Rob Pike三个大牛于2007年开始设计发明，他们最终的目标是设计一种适应网络和多核时代的C语言。所以Go语言很多时候被描述为“类C语言”，或者是“21世纪的C语言”，Go 富有表现力、简洁、干净且高效。其并发性机制使编写充分利用多核的程序变得容易，而其新颖的类型系统可实现灵活和模块化程序构建。Go 可以快速编译为机器代码，且具有垃圾回收的便利性和运行时反射的强大功能。是一个快速的静态类型的编译语言，但感觉就像动
Go从入门到精通（一）go语言初识
weixin_34114823的博客
06-08 275
 一、第一个go程序 package main import ( "fmt" ) func main(){ fmt.Println("hello world") } 对于代码的解释 如果是为了将代码编译成一个可执行程序，那么package必须是main如果是为了将代码编译成库，那么package则没有限制go中所有的代码都应该隶属一个包...
GO语言入门学习（超详细的教程）-01
newbie_______的博客
04-11 5361
详细介绍go语言特色、用途、环境安装、语言结构、基础语法、格式化字符串等等
C语言中文网Go语言教程
06-16
1. 静态类型：Go 语言是一种静态类型语言，编译器会在编译时检查类型错误。 2. 编译型语言：Go 语言使用编译器来编译代码，编译器将源代码编译成二进制（或字节码）格式。 3. 并发型语言：Go 语言提供了强大的并发...
Go语言15套教程（百度网盘）
10-25
### Go语言15套教程知识点概述 #### 01 Go语言基础（一） - **Go语言简介**：介绍Go语言的发展历史、设计理念及其优势特点。 - **环境搭建**：指导如何在Windows/Linux/MacOS环境下安装Go语言环境，并配置环境变量...
Go语言实战_golang教程_Go_go_
10-01
Go语言，又称Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的、C风格的编程语言。它旨在提高编程效率，简化系统编程，并且能够支持大规模的网络服务和分布式计算。Go语言实战教程是学习Go...
go语言十分钟入门教程
qq_41066066的博客
03-02 694
导语｜这是一篇go基本语法快速入门文章，学习该文章时，默认读者已安装成功Golang环境，若环境未安装成功，可自行百度。 目录 环境安装 输出语句 Go语言关键字 类型 数据类型 变量定义 var关键字定义 简短模式 多变量赋值 常量 iota关键字 运算符 函数 条件语句和循环语句 条件语句 循环语句 数据 数组 字符串 切片 初始化slice 示例 map字典 结构体struct 接口 语法 示例 总结 环境安装 安装地址：https://www.cnblogs.com/aaronthon/p/105.
【GO语言入门到精通】
dongbao520的博客
01-12 3180
Go语言中包含了大量用于处理Go语言代码的命令和工具。其中，go命令就是最常用的一个，它有许多子命令。这些子命令都拥有不同的功能，如下所示。l build：用于编译给定的代码包或Go语言源码文件及其依赖包。l clean：用于清除执行其他go命令后遗留的目录和文件。l doc：用于执行godoc命令以打印指定代码包。l env：用于打印Go语言环境信息。l fix：用于执行go tool fix命令以修正给定代码包的源码文件中包含的过时语法和代码调用。
Go 语言学习路线指南
咻咻ing的专栏
10-12 730
不知道是不是有同学打算开始学习 Golang，确不知道如何开始，至少我开始学习的时候就是这种感觉，为了这个，我查询了很多的帖子和问答。网上的 Golang 资料虽然不多，但是也不少，这个我的一个学习路线，从简单内容开始，可以作为参考。 第一步 Go 语言之旅 这个是一个官方的入门教程，或者说只是一个大概了解的教程，只介绍了一些简单的东西，并且没有太多的说明。不过这个教程支持在线执行代码，还是很不错...
2024年Go最新golang超详细基础入门教程_golang教程(1)，Golang跨进程通信导论
最新发布
2401_84920041的博客
05-14 622
在Go语言中，可以使用关键字var来定义变量，并使用赋值运算符对变量进行赋值。在上面的语句中，var关键字用于声明一个变量，age是变量的名称，int是变量的类型，是赋值运算符，将10赋给变量age。在上面的语句中，变量name的类型会被自动推导为字符串类型，并将字符串"Alice"赋值给变量name。age := 20在上面的语句中，:=是简短赋值运算符，表示将20赋值给新声明的变量age。由于没有明确指定变量的类型，因此编译器会根据右侧表达式的值来自动推导变量的类型。
GO语言快速入门
程序媛也要干巴爹
03-29 924
简介 特性 强类型、编译型、并发型，并具有垃圾回收功能的编程语言。 运行方式 直接运行： go run helloworld.go 编译后再运行： $ go build helloworld.go $ ./helloworld Hello，world 语法 “{”必须和func同一行 首字母大写的是可以由package外部访问的；首字母小写的只能在package内部访问 数据类型 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小那同学

晚饭加鸡腿🍗

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值