golang 切片详解

已于 2023-08-01 17:56:43 修改
阅读量2k 收藏 4
点赞数
文章标签： golang 开发语言 后端
于 2023-08-01 17:45:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37698352/article/details/132047659
版权

Go 中的切片是一种灵活且高效的表示数组的方式，并且由于其动态大小和附加功能，它们经常用来代替数组。切片是对数组的一部分的引用。它是一种数据结构，通过指定起始索引和部分长度来描述数组的一部分。这允许您像使用独立数组一样使用数组的一部分。Go语言中切片比数组更强大、更灵活、更方便，是一种轻量级的数据结构。切片是一个变长序列，用于存储相似类型的元素，不允许在同一个切片中存储不同类型的元素。它就像一个具有索引值和长度的数组，但是切片的大小是调整大小的，它们不像数组那样是固定大小的。在内部，切片和数组是相互连接的，切片是对底层数组的引用。切片中允许存储重复元素。

切片中的第一个索引位置始终为 0，最后一个索引位置将为 (切片长度 – 1)。

如何在 Go 中创建切片的示例:

package main

import "fmt"

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

    fmt.Println("Array: ", array)
    fmt.Println("Slice: ", slice)
}

Output:

Array: [1 2 3 4 5]
Slice: [2 3 4]

在此示例中，创建的数组包含 5 个元素，并且通过指定起始索引 1 和长度 4 创建切片。切片现在包含原始数组中的元素 2、3 和 4。

切片是动态的，这意味着它们的大小可以随着您添加或删除元素而改变。Go 提供了几个内置函数允许您修改切片，例如追加、复制和删除。

如何在 Go 中向切片添加元素:

package main

import "fmt"

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

    fmt.Println("Slice: ", slice)
}

Output:

Slice: [1 2 3 4 5 6]

本例中，函数append用于将元素4、5、6添加到切片slice中。结果是一个包含元素 1、2、3、4、5、6 的新切片。

Go 中的切片是一种强大且灵活的数据结构，可用于表示数组。它们提供了一种更动态、更高效的数组处理方式，并且广泛应用于 Go 程序中。

切片声明

切片的声明方式与数组类似，但它不包含切片的大小。所以它可以根据需要增长或缩小。

Syntax:

[]T
or 
[]T{}
or 
[]T{value1, value2, value3, ...value n}

例如:

var my_slice[]int

切片的组成部分

切片包含三个组件：

指针：指针用于指向可通过切片访问的数组的第一个元素。这里，所指向的元素不一定是数组的第一个元素。
长度： 长度是数组中存在的元素总数。
容量： 容量表示可以扩展的最大大小。

示例:

// Golang program to illustrate
// the working of the slice components
package main

import "fmt"

func main() {

    // Creating an array
    arr := [7]string{"This", "is", "the", "tutorial",
                        "of", "Go", "language"}

    // Display array
    fmt.Println("Array:", arr)

    // Creating a slice
    myslice := arr[1:6]

    // Display slice
    fmt.Println("Slice:", myslice)

    // Display length of the slice
    fmt.Printf("Length of the slice: %d", len(myslice))

    // Display the capacity of the slice
    fmt.Printf("\nCapacity of the slice: %d", cap(myslice))
}

Output:

Array: [This is the tutorial of Go language]
Slice: [is the tutorial of Go]
Length of the slice: 5
Capacity of the slice: 6

**说明:*在上面的示例中，我们从给定数组创建一个切片。这里切片的指针指向索引 1，因为切片的下界设置为 1，因此它从索引 1 开始访问元素。切片的长度为 5，这意味着切片中存在的元素总数为5和切片6的容量意味着它最多可以存储6个元素。

在这里插入图片描述

如何创建和初始化Slice?

在Go语言中，切片可以通过以下方式创建和初始化：

使用切片文字：您可以使用切片文字创建切片。切片文字的创建就像数组文字一样，但有一点不同，不允许在方括号 [] 中指定切片的大小。如下例所示，该表达式的右侧是切片文字。

var my_slice_1 = []string{"极客", "for", "极客"}

注意： 当您使用字符串文字创建切片时，它首先创建一个数组，然后返回对其的切片引用。

示例:

// Golang program to illustrate how
// to create a slice using a slice
// literal
package main

import "fmt"

func main() {

    // Creating a slice
    // using the var keyword
    var my_slice_1 = []string{"Geeks", "for", "Geeks"}

    fmt.Println("My Slice 1:", my_slice_1)

    // Creating a slice
    //using shorthand declaration
    my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
    fmt.Println("My Slice 2:", my_slice_2)
}

Output:

My Slice 1: [Geeks for Geeks]
My Slice 2: [12 45 67 56 43 34 45]

使用数组： 我们已经知道切片是数组的引用，因此您可以从给定数组创建切片。要从给定数组创建切片，首先需要指定下限和上限，这意味着切片可以从数组中从下限到上限获取元素。它不包括上面的上限元素。如下例所示：

Syntax:

array_name[low:high]

此语法将返回一个新切片。

注意： 下界的默认值为 0，上限的默认值为给定数组中存在的元素总数。

示例:

// Golang program to illustrate how to
// create slices from the array
package main

import "fmt"

func main() {

    // Creating an array
    arr := [4]string{"Geeks", "for", "Geeks", "GFG"}

    // Creating slices from the given array
    var my_slice_1 = arr[1:2]
    my_slice_2 := arr[0:]
    my_slice_3 := arr[:2]
    my_slice_4 := arr[:]

    // Display the result
    fmt.Println("My Array: ", arr)
    fmt.Println("My Slice 1: ", my_slice_1)
    fmt.Println("My Slice 2: ", my_slice_2)
    fmt.Println("My Slice 3: ", my_slice_3)
    fmt.Println("My Slice 4: ", my_slice_4)
}

Output:

My Array:  [Geeks for Geeks GFG]
My Slice 1:  [for]
My Slice 2:  [Geeks for Geeks GFG]
My Slice 3:  [Geeks for]
My Slice 4:  [Geeks for Geeks GFG]

使用已经存在的切片： 也可以从给定的切片创建切片。要从给定切片创建切片，首先需要指定下限和上限，这意味着切片可以从给定切片中从下限到上限获取元素。它不包括上面的上限元素。如下例所示：
语法：

slice_name[low:high]

此语法将返回一个新切片。

注意： 下界的默认值为 0，上限的默认值为给定切片中存在的元素总数。

示例:

// Golang program to illustrate how to
// create slices from the slice
package main

import "fmt"

func main() {

    // Creating s slice
    oRignAl_slice := []int{90, 60, 40, 50,
        34, 49, 30}

    // Creating slices from the given slice
    var my_slice_1 = oRignAl_slice[1:5]
    my_slice_2 := oRignAl_slice[0:]
    my_slice_3 := oRignAl_slice[:6]
    my_slice_4 := oRignAl_slice[:]
    my_slice_5 := my_slice_3[2:4]

    // Display the result
    fmt.Println("Original Slice:", oRignAl_slice)
    fmt.Println("New Slice 1:", my_slice_1)
    fmt.Println("New Slice 2:", my_slice_2)
    fmt.Println("New Slice 3:", my_slice_3)
    fmt.Println("New Slice 4:", my_slice_4)
    fmt.Println("New Slice 5:", my_slice_5)
}

Output:

Original Slice: [90 60 40 50 34 49 30]
New Slice 1: [60 40 50 34]
New Slice 2: [90 60 40 50 34 49 30]
New Slice 3: [90 60 40 50 34 49]
New Slice 4: [90 60 40 50 34 49 30]
New Slice 5: [40 50]

使用 make() 函数： 您还可以使用go 库提供的make() 函数创建切片。该函数采用三个参数，即类型、长度和容量。这里，容量值是可选的。它分配一个大小等于给定容量的底层数组，并返回一个引用底层数组的切片。通常，make()函数用于创建一个空切片。这里，空切片是那些包含空数组引用的切片。

语法:

func make([]T, len, cap) []T

示例:

// Go program to illustrate how to create slices
// Using make function
package main

import "fmt"

func main() {

    // Creating an array of size 7
    // and slice this array till 4
    // and return the reference of the slice
    // Using make function
    var my_slice_1 = make([]int, 4, 7)
    fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",
                my_slice_1, len(my_slice_1), cap(my_slice_1))

    // Creating another array of size 7
    // and return the reference of the slice
    // Using make function
    var my_slice_2 = make([]int, 7)
    fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",
                my_slice_2, len(my_slice_2), cap(my_slice_2))
    
}

Output:

Slice 1 = [0 0 0 0], 
length = 4, 
capacity = 7
Slice 2 = [0 0 0 0 0 0 0], 
length = 7, 
capacity = 7

如何迭代切片？

您可以使用以下方式迭代切片：

使用 for 循环：这是迭代切片的最简单方法，如下例所示：
示例:

// Golang program to illustrate the
// iterating over a slice using
// for loop
package main

import "fmt"

func main() {

	// Creating a slice
	myslice := []string{"This", "is", "the", "tutorial",
		"of", "Go", "language"}

	// Iterate using for loop
	for e := 0; e < len(myslice); e++ {
		fmt.Println(myslice[e])
	}
}

Output:

This
is
the
tutorial
of
Go
language

在 for 循环中使用 range：允许在 for 循环中使用 range 来迭代切片。在 for 循环中使用 range，您可以获取索引和元素值，如示例所示：

示例:

// Golang program to illustrate the iterating
// over a slice using range in for loop
package main

import "fmt"

func main() {

	// Creating a slice
	myslice := []string{"This", "is", "the", "tutorial",
								"of", "Go", "language"}

	// Iterate slice
	// using range in for loop
	for index, ele := range myslice {
		fmt.Printf("Index = %d and element = %s\n", index+3, ele)
	}
}

Output:

Index = 3 and element = This
Index = 4 and element = is
Index = 5 and element = the
Index = 6 and element = tutorial
Index = 7 and element = of
Index = 8 and element = Go
Index = 9 and element = language

在 for 循环中使用空白标识符：在 range for 循环中，如果您不想获取元素的索引值，则可以使用空格（_）代替索引变量，如下例所示：
示例:

// Golang program to illustrate the iterating over
// a slice using range in for loop without an index
package main

import "fmt"

func main() {

	// Creating a slice
	myslice := []string{"This", "is", "the",
		"tutorial", "of", "Go", "language"}

	// Iterate slice
	// using range in for loop
	// without index
	for _, ele := range myslice {
		fmt.Printf("Element = %s\n", ele)
	}
}

Output:

Element = This
Element = is
Element = the
Element = tutorial
Element = of
Element = Go
Element = language

关于 Slice 的要点

零值切片：在Go语言中，您可以创建一个不包含任何元素的nil切片。因此该切片的容量和长度为 0。 Nil 切片不包含数组引用，如下例所示：

示例:

// Go program to illustrate a zero value slice
package main

import "fmt"

func main() {

	// Creating a zero value slice
	var myslice []string
	fmt.Printf("Length = %d\n", len(myslice))
	fmt.Printf("Capacity = %d ", cap(myslice))

}

Output:

Length = 0
Capacity = 0

修改切片：我们已经知道切片是一种引用类型，它可以引用底层数组。因此，如果我们更改切片中的某些元素，那么更改也应该发生在引用的数组中。或者换句话说，如果您在切片中进行了任何更改，那么它也会反映在数组中，如下例所示：

示例:

// Golang program to illustrate
// how to modify the slice
package main

import "fmt"

func main() {

	// Creating a zero value slice
	arr := [6]int{55, 66, 77, 88, 99, 22}
	slc := arr[0:4]

	// Before modifying

	fmt.Println("Original_Array: ", arr)
	fmt.Println("Original_Slice: ", slc)

	// After modification
	slc[0] = 100
	slc[1] = 1000
	slc[2] = 1000

	fmt.Println("\nNew_Array: ", arr)
	fmt.Println("New_Slice: ", slc)
}

Output:

Original_Array:  [55 66 77 88 99 22]
Original_Slice:  [55 66 77 88]

New_Array:  [100 1000 1000 88 99 22]
New_Slice:  [100 1000 1000 88]

Slice 的比较：在 Slice 中，只能使用运算符来检查给定的 slice 是否为空。如果您尝试借助运算符比较两个切片，则会出现错误，如下例所示：

示例:

// Golang program to check if
// the slice is nil or not
package main

import "fmt"

func main() {

	// creating slices
	s1 := []int{12, 34, 56}
	var s2 []int

	// If you try to run this commented
	// code compiler will give an error
	/*s3:= []int{23, 45, 66}
	fmt.Println(s1==s3)
	*/

	// Checking if the given slice is nil or not
	fmt.Println(s1 == nil)
	fmt.Println(s2 == nil)
}

Output:

false
true

注意：如果要比较两个切片，请使用 range for 循环来匹配每个元素，或者可以使用DeepEqual函数。

多维切片：多维切片就像多维数组一样，只是切片不包含大小。

示例:

// Go program to illustrate the multi-dimensional slice
package main

import "fmt"

func main() {

	// Creating multi-dimensional slice
	s1 := [][]int{{12, 34},
		{56, 47},
		{29, 40},
		{46, 78},
	}

	// Accessing multi-dimensional slice
	fmt.Println("Slice 1 : ", s1)

	// Creating multi-dimensional slice
	s2 := [][]string{
		[]string{"Geeks", "for"},
		[]string{"Geeks", "GFG"},
		[]string{"gfg", "geek"},
	}

	// Accessing multi-dimensional slice
	fmt.Println("Slice 2 : ", s2)

}

Output:

Slice 1 :  [[12 34] [56 47] [29 40] [46 78]]
Slice 2 :  [[Geeks for] [Geeks GFG] [gfg geek]]

切片的排序：在Go语言中，您可以对切片中存在的元素进行排序。Go语言的标准库提供了sort包，其中包含不同类型的排序方法，用于对int、float64和strings切片进行排序。这些函数始终按升序对切片中可用的元素进行排序。

示例:

// Go program to illustrate how to sort
// the elements present in the slice
package main

import (
	"fmt"
	"sort"
)

func main() {

	// Creating Slice
	slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"}
	slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}

	fmt.Println("Before sorting:")
	fmt.Println("Slice 1: ", slc1)
	fmt.Println("Slice 2: ", slc2)

	// Performing sort operation on the
	// slice using sort function
	sort.Strings(slc1)
	sort.Ints(slc2)

	fmt.Println("\nAfter sorting:")
	fmt.Println("Slice 1: ", slc1)
	fmt.Println("Slice 2: ", slc2)

}

Output:

Before sorting:
Slice 1:  [Python Java C# Go Ruby]
Slice 2:  [45 67 23 90 33 21 56 78 89]

After sorting:
Slice 1:  [C# Go Java Python Ruby]
Slice 2:  [21 23 33 45 56 67 78 89 90]
OneGopher
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
golang slice切片
技术的搬运工
06-24 502
string本身是不可变的，因此要改变string中的字符，需要将字符串转化成切片。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准。string底层就是一个byte的数组，因此，也可以进行切片操作。在函数内等号左半部分可以用。1、切片追加另外一个切片。4、从数组中切片赋值。2、切片追加一个元素。3、切片追加多个元素。
golang切片内存应用技巧详解
09-18
主要介绍了golang切片内存应用技巧详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
golang切片简介
农家小舍
08-02 8046
创建 访问 操作 切片（slice）是Golang中数组之上的抽象；可按需自动增长与缩小。切片的底层是连续的内存块。 创建 切片本身是一个三个字段的数据结构： Data：指向底层数组的指针； Len：切片中元素的个数；len(s)获取; Cap：切片的容量（不需重新分配内存前，可容纳的元素数量）；cap(s)获取； typeSliceHeaderstruct{ Datauintptr Lenint Capint } 创建与初始化 有多种创...
Go 切片常用操作与使用技巧
最新发布
大灰狼的专栏
05-23 1122
在 Go 语言中的切片（slice）是一种灵活的动态数组，它可以自动扩展和收缩，是 Go 语言中非常重要的数据结构之一。切片是基于数组实现的，它的底层是数组，可以理解为对底层数组的抽象。它会生成一个,并通过切片长度关联到底层数组部分或者全部元素。
golang--slice(切片)
Freeman_23的博客
05-14 1491
切片的长度表示切片中当前存储的元素个数，它不能超过切片的容量。切片可以通过设置下限和上限来截取一个新的切片，语法为slice[start:end]，其中start和end表示切片的元素索引，如果省略start，则默认为0，如果省略end，则默认为切片的长度。切片可以使用copy()函数来复制另一个切片的所有元素，语法为copy(dst, src)，其中dst表示目标切片，src表示源切片。对切片再次截取时，新切片和原切片会共享底层数组，所以修改其中一个切片的元素会影响另一个切片。
Golang学习——string和slice切片
weixin_44891093的博客
07-12 1298
Golang学习——string和slice切片
【玩转Golang】slice切片的操作——切片的追加、删除、插入等
weixin_33736832的博客
01-20 2077
一、一般操作 　　1,声明变量，go自动初始化为nil，长度：0，地址：0，nil func main(){ var ss []string; fmt.Printf("length:%v \taddr:%p \tisnil:%v",len(ss),ss, ss==nil) } --- Running... length:0 addr:0x...
Golang中切片的用法与本质详解
09-20
Go的切片类型为处理同类型数据序列提供一个方便而高效的方式，下面这篇文章就来给大家介绍了关于Golang中切片的用法与本质的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
Golang数组的传递详解
09-19
总的来说，理解Golang中的数组和切片以及它们在函数参数传递中的行为是编写高效代码的关键。在处理大数组时，应优先考虑使用切片或指针来避免不必要的性能开销。此外，掌握按值传递和按引用传递的概念有助于更好地...
Golang中的自定义函数详解
09-20
- 可变参数在函数内部表现为切片类型，可以进行遍历和操作。 例如，一个求整数和的函数，接受任意数量的整数： ```go func sum(numbers ...int) int { s := 0 for _, num := range numbers { s += num } ...
golang字符串拼接，字符串与切片转换的几种方式比较
猛犸象
02-20 1600
golang字符串拼接，字符串与切片转换的几种方式比较
Golang slice切片操作之切片的追加、删除、插入等
09-21
主要介绍了Golang slice切片操作之切片的追加、删除、插入等，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
go切片在指定位置插入元素
liulanba的博客
01-28 7075
第一个示例追加了一个元素到切片 slice 中，创建了一个新的切片 newSlice。第三个示例将一个切片 slice2 追加到切片 slice 的末尾，创建了一个合并后的切片 combinedSlice。如果原始切片的容量不足，append 函数将创建一个新的底层数组，并将原始切片的元素复制到新数组中，然后再追加新的元素。如果追加的元素超过了切片的容量，append 函数会自动分配更大的底层数组来容纳新的元素。append 函数返回一个新的切片，而不会修改原始的切片。slice：要追加元素的切片。
go语言基础4——切片
一蓑烟雨任平生
02-23 1399
引子 因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性。 例如： func arraySum(x [3]int) int{ sum := 0 for _, v := range x{ sum = sum + v } return sum } 这个求和函数只能接受[3]int类型，其他的都不支持。 再比如， a := [3]int{1, 2, 3} 数组a中已经有三个元素了，我们不能再继续往数组a中添加新元素了。 切
golang 字符串转字符串切片
qq_44365652的博客
06-06 2361
将字符串[[112.548879, 37.87059], [111.74918, 40.842585], [126.534967, 45.803775], [125.323544, 43.817071], [123.431474, 41.805698], [117.200983, 39.084158], [116.407526, 39.90403], [114.514859, 38.042306], [117.119999, 36.651216]]转成切片形式考虑先将字符串进行处理 把[]先删除 再通过st
【go基础】切片
每天进步一点点
03-12 1003
go语言中数组的长度是固定的，如果数组中元素个数已经等于数组容量时，就不能再继续往数组中添加新元素了。为了解决此问题，就有了切片（slice）类型，它时在数组的基础上重新进行了一层封装。 一、定义 切片的本质 切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。 基本定义 语法：var 变量 [] 类型 表面上看，定义切片和定义数组是非常相似的，就是不用写明存储元素的个数即可。 ```go package main import "fmt" /
Golang基础-切片
一起学习吧
10-14 466
切片 文章目录切片1.切片的引入2.内存分析3.切片的定义4.切片的遍历5.切片的注意事项 1.切片的引入 【1】切片(slice)是golang中一种特有的数据类型 【2】数组有特定的用处，但是却有一些呆板(数组长度固定不可变)，所以在 Go 语言的代码里并不是特别常见。相对的切片却是随处可见的，切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷。 【3】切片(slice)是对数组一个连续片段的引用，所以切片是一个引用类型。这个片段可以是整个数组，或者是由起始和终止索引标识的一
golang使用切片修改字符串
ens160的博客
06-25 736
package main import "fmt" func main() { angel := "Heros never die" angelBytes := []byte(angel) for i := 5; i <= 10; i++ { angelBytes[i] = ' ' } fmt.Println(string(angelBytes)) } 定义一个angle 字符串，转换为字符串数组，切angle。使用string(angleBytes) 将字符串angel转.
Golang slice 切片
princeyuan的专栏
07-02 564
package main import ( "fmt" ) func main() { s := make([]string, 10) fmt.Println(s) fmt.Println(len(s)) fmt.Println("--------------------------") s = append(s, "a") s = append(s, "a", "b") f
golang 切片原理
08-19
在Go语言中，切片(slice)是一个动态数组，它提供了对数组的部分或全部元素的访问和操作功能。切片的底层是通过数组实现的，但与数组相比，切片具有更强大的功能和灵活性。切片的底层实现原理是使用了一个结构体(runtime.slice)来表示切片的结构信息，包括指向底层数组的指针、切片的长度和容量等信息。切片的长度表示切片中实际存储的元素个数，而容量则表示切片底层数组的长度。切片可以根据需要动态扩容，当切片的长度超过了容量时，会重新分配更大的底层数组，并将原来的元素复制到新的底层数组中。这个过程是由Go语言的运行时系统自动完成的，不需要程序员手动操作。使用切片作为参数传递时，性能损耗很小，因为切片作为参数是传递的是一个结构体实例。切片作为参数具有比数组更强大的功能和灵活性，因此在Go语言中推荐使用切片而不是数组作为参数。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Golang切片的底层实现原理](https://blog.csdn.net/m0_72560813/article/details/129231704)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值