GO ——奇妙的数组

最新推荐文章于 2024-08-16 23:21:18 发布
最新推荐文章于 2024-08-16 23:21:18 发布
阅读量274 收藏
点赞数
文章标签： golang 开发语言 go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiuHuan303/article/details/123910167
版权
本文详细介绍了Go语言中数组的声明、初始化方法，包括一维数组、多维数组的访问和元素操作，以及如何在函数中传递数组参数。通过实例演示了如何创建、初始化和操作不同维度的数组，以及处理数组元素的常见任务，如查找最大值和冒泡排序。
摘要由CSDN通过智能技术生成

目录

GO 数组

1，声明数组

2，初始化数组

3，访问数组元素

4，多维数组

5，向函数中传递数组

GO 数组

数组是具有相同唯一类型的一 组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。 相对于去声明number0, number1, ... number99的变量，使用数组形式numbers[0], numbers[1] ... numbers[99]更加方便且易于扩展。 数组元素可以通过索引(位置)来读取(或者修改) ,索引从0开始,第一个元素索引为0,第二-个索引为1,以 此类推。

 

1，声明数组

声明需要指定元索类型及元索个数，语法格式如下: .

var variable_ name[SIZE] variable type
          名字      长度     类型   
如：var aaa [10] int

以上为-维数组的定义方式。例如以下定义了数组balance长度为10类型为float32:

var balance [10] float32

2，初始化数组

var balance = [5]float32{1000.0, 2.0, 3.4，7.0，50. 0}

可以通过字面量在声明数组的同时快速初始化数组:

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果数组长度不确定，可以使用...代替数组的长度，编译器会根据元素个数自行推断数组的长度:

var balance = [...]float32{1000.0，2.0，3.4, 7.0，50.0}
或
balance := [...]float32{1000.0， 2.0, 3.4, 7.0，50.0}

如果设置了数组的长度，还可以通过指定下标来初始化元素:

//1将索引为1和3的元素初始化
balance := [5]float32(1:2.0,3:7.0}

初始化数组中{}中的元素个数不能大于[ ]中的数字。 如果忽略[ ]中的数字不设置数组大小，Go会根据元素的个数来设置数组的大小

balance[4] = 50.0

以上实例读取了第五个元素，数组元素可以用过索引（位置）来读取或者修改，索引从0开始，第一个元素的索引下标是0，第二个索引是1，往后依次递增。第五个元素的索引就是4。

 

package main
​
import "fmt"
​
//数组定义         元素，下标
var aaa = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
​
func main() {
    //数组元素的提取，依赖下标提取
    fmt.Println(aaa[0]) //索引从0开始
    fmt.Println(aaa[9])
    //数组元素的遍历
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", aaa[i])
    }
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
10
1 2 3 4 5 6 7 8 9 10 
[Done] exited with code=0 in 0.573 seconds
package main
​
import "fmt"
​
//数组定义         元素，下标
var aaa = [10]int{1, 2, 3, 4, 5, 6, 7, 8}
​
func main() {
    //数组元素的提取，依赖下标提取
    fmt.Println(aaa[0]) //索引从0开始
    fmt.Println(aaa[9])
    //数组元素的遍历
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", aaa[i])
    }
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
0
1 2 3 4 5 6 7 8 0 0 //未赋值时是默认值
[Done] exited with code=0 in 0.577 seconds
package main
​
import "fmt"
​
//数组定义         元素，下标
var aaa = [10]int{1, 2, 3, 4, 5, 6, 7, 8}
​
func main() {
    //数组元素的提取，依赖下标提取
    fmt.Println(aaa[0]) //索引从0开始
    fmt.Println(aaa[9])
    //数组元素的遍历
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", aaa[i])
    }
    //输出数组长度
    fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
0
1 2 3 4 5 6 7 8 0 0 数组的长度： 10
​
[Done] exited with code=0 in 0.582 seconds
package main
​
import "fmt"
​
//数组定义         元素，下标
var aaa = []int{1, 2, 3, 4, 5, 6, 7, 8} //未标注下标
​
func main() {
    //数组元素的提取，依赖下标提取
    fmt.Println(aaa[0]) //索引从0开始
    fmt.Println(aaa[6])
    //数组元素的遍历
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", aaa[i])
    }
    //输出数组长度
    fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
7
1 2 3 4 5 6 7 8 panic: runtime error: index out of range [8] with length 8 //会报错
​
goroutine 1 [running]:
main.main()
    f:/goProject/src/dev_code/day9/example3/main/main.go:14 +0x1d1
exit status 2
package main
​
import "fmt"
​
//数组定义         元素，下标
var aaa = [...]int{1, 2, 3, 4, 5, 6, 7, 8} //长度定为...是不定长度的设定
​
func main() {
    //数组元素的提取，依赖下标提取
    fmt.Println(aaa[0]) //索引从0开始
    fmt.Println(aaa[6])
    //数组元素的遍历
    for i := 0; i < len(aaa); i++ {
        fmt.Printf("%d ", aaa[i])
    }
    //输出数组长度
    fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
7
1 2 3 4 5 6 7 8 数组的长度： 8   //定义了几个元素就是几个元素
​
[Done] exited with code=0 in 0.57 seconds

定义指定下标的值

package main
​
import "fmt"
​
//数组定义         元素，下标
var aaa = [6]int{1: 20, 3: 50}
​
func main() {
    //数组元素的遍历
    for i := 0; i < len(aaa); i++ {
        fmt.Printf("%d ", aaa[i])
    }
    //输出数组长度
    fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
0 20 0 50 0 0 数组的长度： 6
​
[Done] exited with code=0 in 0.6 seconds

示例：

package main
​
import "fmt"
​
//控制台输入10名学生的成绩，如果低于60分的，自动修正成绩为60，
//并且展现成绩清单
var a [10]int
​
func main() {
    //数组，学生成绩输入
    for i := 1; i <= 10; i++ {
        fmt.Printf("请输入第%d名学生的成绩:", i)
        fmt.Scan(&a[i-1])
        if a[i-1] < 60 {
            a[i-1] = 60
        }
    }
    //数组，学生成绩输出
    for j := 0; j < len(a); j++ {
        fmt.Printf("第%d名学生的成绩是%d.\n", j+1, a[j])
    }
​
}
​
PS F:\goProject\src\dev_code\day9\exampple4\main> go run .\main.go
请输入第1名学生的成绩:20
请输入第2名学生的成绩:30
请输入第3名学生的成绩:40
请输入第4名学生的成绩:50
请输入第5名学生的成绩:60
请输入第6名学生的成绩:55
请输入第7名学生的成绩:70
请输入第8名学生的成绩:80
请输入第9名学生的成绩:90
请输入第10名学生的成绩:100
第1名学生的成绩是60.
第2名学生的成绩是60.
第3名学生的成绩是60.
第4名学生的成绩是60.
第5名学生的成绩是60.
第6名学生的成绩是60.
第7名学生的成绩是70.
第8名学生的成绩是80.
第9名学生的成绩是90.
第10名学生的成绩是100.

3，访问数组元素

数组元素可以通过索引(位置)来读取。格式为数组名后加中括号,中括号中为索引的值。例如:

var salary float32 =balance[9 ]

以上实例读取了数组balance第10个元素的值。

示例：

package main
​
import "fmt"
​
//数组定义         元素，下标
var aaa = [...]int{1, 2, 3, 4, 5, 6, 7, 8} //长度定为...是不定长度的设定
​
func main() {
    //数组元素的提取，依赖下标提取
    fmt.Println(aaa[0]) //索引从0开始
    fmt.Println(aaa[6])
    //数组元素的遍历
    for i := 0; i < len(aaa); i++ {
        fmt.Printf("%d ", aaa[i])
    }
    //输出数组长度
    fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
7
1 2 3 4 5 6 7 8 数组的长度： 8   //定义了几个元素就是几个元素
​
[Done] exited with code=0 in 0.57 seconds

示例：

package main
​
import "fmt"
​
func main() {
    var i, j, k int
    //声明数组的同时快速初始化数组
    aaa := [5]float32{00, 0.2, 100, 7.4, 3.0}
    //输出数组元素
    for i = 0; i < 5; i++ {
        fmt.Printf("aaa[%d]=%f\n", i, aaa[i])
    }
    aaa2 := [...]float32{00, 0.2, 100, 7.4, 3.0}
    //输出每个数组元素的值
    for j = 0; j < 5; j++ {
        fmt.Printf("aaa2[%d]=%f\n", j, aaa2[j])
​
    }
    //将索引为1和3的元素初始化
    aaa3 := [5]float32{00, 0.2, 100, 7.4, 3.0}
​
    for k = 0; k < 5; k++ {
        fmt.Printf("aaa3[%d]=%f\n", k, aaa3[k])
    }
​
}
​
[Running] go run "f:\goProject\src\dev_code\day10\example1\main\main.go"
aaa[0]=0.000000
aaa[1]=0.200000
aaa[2]=100.000000
aaa[3]=7.400000
aaa[4]=3.000000
aaa2[0]=0.000000
aaa2[1]=0.200000
aaa2[2]=100.000000
aaa2[3]=7.400000
aaa2[4]=3.000000
aaa3[0]=0.000000
aaa3[1]=0.200000
aaa3[2]=100.000000
aaa3[3]=7.400000
aaa3[4]=3.000000

最大值/最小值求值

package main
​
import "fmt"
​
//用随意输入5个数值，输出最大值
func main() {
    var (
        tmp int //擂台
        sum int
        num [5]int //名单
    )
    for i := 0; i < 5; i++ {
        fmt.Printf("请输入第%d个数字:", i+1)
        fmt.Scan(&sum)
        //人员添加到名单中
        num[i] = sum
    }
    fmt.Println("数据输入完成")
    //第一个数值登上擂台
    tmp = num[0]
    for j := 0; j < 5; j++ {
        //打擂比较最大值：最小值改为<就好了
        if num[j] > tmp {
            tmp = num[j]
        } else {
            continue
        }
    }
    fmt.Println("最大值：", tmp)
​
}
PS F:\goProject\src\dev_code\day10\example2\main> go run .\main.go
请输入第1个数字:55
请输入第2个数字:22
请输入第3个数字:65
请输入第4个数字:85
请输入第5个数字:12
数据输入完成
最大值： 85

冒泡排序

package main
​
import "fmt"
​
//冒泡排序
func main() {
    var (
        num [5]int
        sum int
    )
    for i := 0; i < 5; i++ {
        fmt.Printf("请输入第%d个数字", i+1)
        fmt.Scan(&num[i])
    }
    //外循环，比较的轮次
    for k := 1; k < 5; k++ {
         //内循环，交换数值最大的数值，换到最后
        for j := 0; j < 5-k; j++ {
            if num[j] > num[j+1] {
                sum = num[j+1]   //数值交换可以：num[j],num[j+1]=num[j+1],num[j]
                num[j+1] = num[j]
                num[j] = sum
            }
        }
    }
        fmt.Println(num)
    for l := 0; l < 5; l++ {
        fmt.Printf("第%d个数值是%d\n", l+1, num[l])
    }
​
}
​
PS F:\goProject\src\dev_code\day10\example2\main> go run .\main.go
请输入第1个数字12
请输入第2个数字2
请输入第3个数字56
请输入第4个数字78
请输入第5个数字53
[2 12 53 56 78]
第1个数值是2
第2个数值是12
第3个数值是53
第4个数值是56
第5个数值是78

示例：定义不定长数组添加元素

package main
​
import "fmt"
​
func main() {
    var (
        names []string
        name  string
    )
    for i := 0; i < 5; i++ {
        fmt.Printf("请输入第%d个人的姓名", i+1)
        fmt.Scan(&name)
        //数组元素添加
        names = append(names, name)//使用追加的方式，追加到数组内
        fmt.Println("添加成功")
    }
    fmt.Println(names)
}
PS F:\goProject\src\dev_code\day10\example3\main> go run .\main.go
请输入第1个人的姓名ll
添加成功
请输入第2个人的姓名lo
添加成功
请输入第3个人的姓名lk
添加成功
请输入第4个人的姓名lm
添加成功
请输入第5个人的姓名lj
添加成功
[ll lo lk lm lj]

冒泡排序：定义不定长数组添加元素

package main
​
import "fmt"
​
//冒泡排序
func main() {
    var (
        num []int
        sum int
    )
​
    for i := 0; i < 6; i++ {
        fmt.Printf("请输入第%d个数字", i+1)
        fmt.Scan(&sum)
        num = append(num, sum) //使用追加的方式，追加到数组内
    }
    //外循环，比较的轮次
    for k := 1; k < len(num); k++ {
        //内循环，交换数值最大的数值，换到最后
        for j := 0; j < len(num)-k; j++ {
            if num[j] > num[j+1] {
                num[j], num[j+1] = num[j+1], num[j]
            }
        }
    }
    fmt.Println(num)
    for l := 0; l < len(num); l++ {
        fmt.Printf("第%d个数值是%d\n", l+1, num[l])
    }
}
PS F:\goProject\src\dev_code\day10\example2\main> go run .\main.go
请输入第1个数字23
请输入第2个数字25
请输入第3个数字68
请输入第4个数字1
请输入第5个数字26
请输入第6个数字3
[1 3 23 25 26 68]
第1个数值是1
第2个数值是3
第3个数值是23
第4个数值是25
第5个数值是26
第6个数值是68

4，多维数组

多维数组声明方式:

var variable_ name [SIZE1][SIZE2]...[SIZEN] variable_ type
[1,2,3,4,5,6,7,8,9] 一维数组里面是元素.
[[1,2],[3,4],[5,6,7],[8,9]] 二维中有一维数组
[ [[1,2],[3,4]], [[5,6,7],[8,9]] ]三维有多少二维数组

以下实例声明了三维的整型数组

var threedim [5][10][4]int

二维数组

二维数组是最简单的多维数组，二维数组本质上是由- -维数组组成的。二维数组定义方式如下:

var arrayName [ x ][ y ] variable_ type

variable_ type 为数据类型, arrayName 为数组名,二维数组可认为是一个表格， x 为行，y为列，下图演示了一个二维数组a为三行四列:

示例：

package main
​
import "fmt"
​
//定义二位数组[[1,2,3],[4,5,6]]
func main() {
    //声明二位数组
    var nums [][]int
    //定义一维数组
    row1 := [3]int{1, 2, 3}
    row2 := [3]int{4, 5, 6}
    //一维数组作为元素添加到二位数组，使用append（）函数向空的二维数组添加两行一维数组
    nums = append(nums, row1[:])
    nums = append(nums, row2[:])
    fmt.Println("二维数组中的第一个元素：", nums[0])
    fmt.Println("二维数组中的第二个元素：", nums[1])
    fmt.Println("二维数组中第一个一维数组的第一个元素：", nums[0][0])
​
}
[Running] go run "f:\goProject\src\dev_code\day10\example4\main\main.go"
二维数组中的第一个元素： [1 2 3]
二维数组中的第二个元素： [4 5 6]
二维数组中第一个一维数组的第一个元素： 1
​
[Done] exited with code=0 in 0.603 seconds

初始化二维数组

多维数组可通过大括号来初始值。以下实例为一个3行4列的二维数组:

a:=[3][4]int{
{0, 1, 2, 3}，/*第一行索引为0*/
{4, 5, 6，7}，/*第二行索引为1 */
{8, 9, 10, 11}， /*第三行索引为2 */

注意：

以上代码中倒数第二行的}必须要有逗号，因为最后一行的}不能单独一行，也可以写成这样: .

a := [3][4]int{
{o,1,2,3}，    /*声第一行索引为0 */
{4,5,6,7}，    /*第二行索引为1 */
{8，9, 10, 11}} /*第三行索引为2“/

示例:实例初始化一个2行2列的二维数组

package main
​
import "fmt"
​
func main() {
    //创建二维数组
    test := [2][2]string{}
    //向二维数组添加元素
    test[0][0] = "张三"
    test[0][1] = "张四"
    test[1][0] = "李三"
    test[1][1] = "李四"
    //显示结果
    fmt.Println(test)
}
[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
[[张三 张四] [李三 李四]]
​
[Done] exited with code=0 in 0.578 seconds

示例：

package main
​
import "fmt"
​
//定义二位数组[[1,2,3],[4,5,6]]
func main() {
    //初始化二维数组
    nums := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
​
    fmt.Println("二维数组中的第一个元素：", nums[0])
    fmt.Println("二维数组中的第二个元素：", nums[1])
    fmt.Println("二维数组中第一个一维数组的第一个元素：", nums[0][0])
​
}
[Running] go run "f:\goProject\src\dev_code\day10\example4\main\main.go"
二维数组中的第一个元素： [1 2 3]
二维数组中的第二个元素： [4 5 6]
二维数组中第一个一维数组的第一个元素： 1
​
[Done] exited with code=0 in 0.563 seconds

访问二维数组

二维数组通过指定坐标来访问。如数组中的行索引与列索引，例如:实例访问了二维数组val第三行的第四个元 素。

val := a[2][3]
或
var value int=a[2][3]
​

二维数组可以使用循环嵌套来输出元素：

package main
​
import "fmt"
​
func main() {
    //数组3行4列
    var a = [3][4]int{{1, 5, 2, 4}, {8, 4, 3, 9}, {7, 5, 1, 8}}
    //输出数组元素
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            fmt.Printf("a[%d][%d]=%d\n", i, j, a[i][j])
        }
    }
​
}
[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
a[0][0]=1
a[0][1]=5
a[0][2]=2
a[0][3]=4
a[1][0]=8
a[1][1]=4
a[1][2]=3
a[1][3]=9
a[2][0]=7
a[2][1]=5
a[2][2]=1
a[2][3]=8

示例：

package main
​
import "fmt"
​
//定义二位数组[[1,2,3],[4,5,6]]
func main() {
    //初始化二维数组
    nums := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    //遍历二位数组中的每个元素
    //外层读行
    for i := 0; i < 2; i++ {
        //内层读列
        for j := 0; j < 3; j++ {
            fmt.Println(nums[i][j])
        }
    }
​
}
[Running] go run "f:\goProject\src\dev_code\day10\example4\main\main.go"
1
2
3
4
5
6

示例：创建各个维度元素数量不一致的多维数组

package main
​
import "fmt"
​
func main() {
    //创建空的二位数组
    value := [][]string{}
    //创建三个以为数组，各数组长度不一致
    test1 := []string{"张三", "张四", "张五"}
    test2 := []string{"李三"}
    test3 := []string{"王三", "王四"}
    //使用append()函数将一维数组添加进二维数组
    value = append(value, test1)
    value = append(value, test2)
    value = append(value, test3)
    //循环输出
    for i := range value {
        fmt.Printf("test:%d\n", i+1)
        fmt.Println(value[i])
    }
​
}
[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
test:1
[张三 张四 张五]
test:2
[李三]
test:3
[王三 王四]
​
[Done] exited with code=0 in 0.538 seconds

三维数组示例

package main
​
import "fmt"
​
func main() {
    //创建空的二位数组
    value := [][][]string{}
    value1 := [][]string{}
    value2 := [][]string{}
    //创建三个以为数组，各数组长度不一致
    test1 := []string{"张三", "张四", "张五"}
    test2 := []string{"李三"}
    test3 := []string{"王三", "王四"}
    test4 := []string{"赵二", "赵三"}
    //使用append()函数将一维数组添加进二维数组
    value1 = append(value1, test1)
    value1 = append(value1, test2)
    value2 = append(value2, test4)
    value2 = append(value2, test3)
    value = append(value, value1)
    value = append(value, value2)
​
    fmt.Println("三维数组value=", value)
    //循环输出
    for i := range value {
        for j := range value {
            fmt.Printf("value[%d][%d]\n", i, j)
            fmt.Println(value[i][j])
        }
    }
​
}
​
[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
三维数组value= [[[张三 张四 张五] [李三]] [[赵二 赵三] [王三 王四]]]
value[0][0]
[张三 张四 张五]
value[0][1]
[李三]
value[1][0]
[赵二 赵三]
value[1][1]
[王三 王四]
​
[Done] exited with code=0 in 0.533 seconds

5，向函数中传递数组

如果想向函数传递数组参数，需要在函数定义时，声明形参为数组，可以通过以下两种方式来声明:

方式一

形参设定数组大小：

void myFunction(param [10]int)
{
.
.
.
}

方式二

形参为设定数组大小：

void myFunction(param []int)
{
.
.
.
}

示例：函数接收者整型数组参数，另一个参数指定了数组元素的个数，并返回平均值：

package main
​
import (
    "fmt"
)
​
//定义数组
var num [5]int
​
func main() {
    num = [5]int{10, 20, 30, 40, 50}
    fmt.Println("元素的和为：", sum(num))
}
​
//数组传入
func sum(a [5]int) int {
    //求和的变量
    s := 0
    //求和过程
    for i := range a {
        s += a[i]
    }
    return s
}
[Running] go run "f:\goProject\src\dev_code\day10\example6\main\main.go"
元素的和为： 150
​
[Done] exited with code=0 in 0.557 seconds
LiuHuan303
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
索引和切片的基本使用
ghf183184的博客
03-11 1199
整数索引和切片的基本使用 arr = np.arange(8) #获取索引为5的元素 arr[5]————>5 #获取索引为3-5的元素，但不包括5 arr[3:5]————>array([3,4]) 二维数组的索引方式 在二维数组中，每个索引位置上的元素不再是一个标量了，而是一个一维数组 arr = np.array([[1,2,3],[4,5,6],[7,8,9]]) #获取索引...
python 基础学习-07-列表
weixin_41447550的博客
04-25 562
1. 序列（sequence） 1.1 基本概念 序列是Python中最基本的一种数据结构（如布尔型 整型 字符串等）。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引。 序列相当于一个队列，每个位置按照一定顺序站队。就如同排队站列一样，一号位站某人，二号位站某人。 数据结构指计算机中数据存储的方式（存东西的方式有很多种，计算机...
Go语言特定的数组
weixin_44189499的博客
04-17 131
指定一个索引和对应值列表的方式初始化 type Currency int const ( USD Currency = iota // 美元 EUR // 欧元 GBP // 英镑 RMB // 人民币 ) symbol := [...]string{USD: "$", ...
数组（一）
pengzhisen123的博客
10-28 281
1、概念 同一种类型数据的集合。其实数组就是一个容器。 2、数组的好处 可以自动给数组中的元素从0开始编号，方便操作这些元素。 3、数组的格式 1、格式1： 元素类型 []  数组名=new 元素类型[元素个数或数组长度]； 示例： int[] arr=new int[8]; 2、格式2： 元素类型[] 数组名=new 元素类型[] {元素，元素，......}; 示例：int
第八章 数组
Girasoles的博客
11-12 3267
第八章 数组
深入理解 Go 语言——动态数组Slice
JackWu1024
10-25 427
Slice 又称动态数组，依托底层数组实现。在 Go 语言中，Slice 是一个引用类型，它比数组更加灵活，更适合处理序列数据。它不仅可以动态地改变自己的大小，还可以进行方便的切片操作。Slice 的定义非常简洁，只有三个字段：指针、长度和容量。a
Go语言——从数组中截取切片
热门推荐
weixin_42117918的博客
08-21 1万+
Go语言中 从数组中截取切片： 1） 如果没有指定max：max的值为截取对象（数组、切片）的容量 2） 如果指定max：max 值不能超过原对象（数组、切片）的容量。 3）利用数组创建切片，切片操作的是同一个底层数组。 代码实例： package main import "fmt" func main() { arr:=[10]int{1,2,3,4,5,6,7,8,9,...
大家一起学Golang——Go语言简介与安装
01-08
大家一起学Golang ——Go语言简介与安装 go语言简介 Go语言是有google公司推出的一门编程语言，是开源，静态编程语言，语法简洁，天生支持并发。 2007年由Robert Griesemer, Rob Pike, Ken Thompson主持开发，又来...
大家一起学Golang——结构体、方法
01-07
大家一起学Golang——结构体、方法 结构体类型 空结构体 结构体标签 匿名字段 方法 重写 结构体类型 结构体类型通过一系列的且唯一的字段来声明。在go中数组切片只能存储同一类型的数据，但结构体用户可以自定义将...
go代码-golang一维数组
07-14
虽然数组长度固定，但Go语言提供了一种灵活的数据结构——切片（slice），它是数组的动态视图。我们可以从数组创建切片，并改变其长度： ```go slice := arr[1:3] // 创建一个从索引1开始到3结束的切片 ``` 切片...
云计算之go语言——基础语法(下)
01-08
Go 语言中 range 关键字用于 for 循环中迭代数组(array)/切片(slice)/通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。 2，实例 range01.go ...
Go语言深度探索：切片与数组的奥秘
07-23
本文将深入探讨Go语言中的两个核心数据结构——切片（Slice）和数组（Array）。我们将从定义、特点、区别以及应用场景等方面进行全面分析，并通过具体的代码示例加深理解。 #### 一、Go语言的数据结构：切片与数组 ...
Golang做API开发离不开签名验证，如何设计 ?
leyang0910的博客
08-13 336
在API开发中，签名验证是一种常见的安全措施，用于确保请求的完整性和来源的可靠性。以下是设计一个签名验证机制的步骤和示例代码。
【Golang】golang安装一些依赖包时总是失败
youngwhz1的专栏
08-16 186
/windows环境(不设置GO111MODULE为on也可以下载成功，是因为默认开启)export GOPROXY="https://goproxy.cn,direct" # 代理仓库配置。镜像站点中，direct可以指示Go回源到模块版本的源地址去抓取，比如github。（1）默认GOPROXY=https://proxy.golang.org,direct，国内无法访问。比如安装gin包：go get -u github.com/gin-gonic/gin。//windows环境设置代理。
在Go中理解栈和先进先出原则
jzpfbpx的博客
08-16 197
在本博文中，我们将探讨如何在 Go 中实现和使用堆栈，以及堆栈如何遵循先进先出 (FIFO) 原则。Push方法将一个新的元素追加到片段的末尾，而Pop方法则从片段中删除并返回最后一个元素。堆栈的主要特点是遵循后进先出（LIFO）原则：最后一个添加到堆栈的元素是第一个被移除的元素。当我们运行这段代码时，我们可以看到元素从堆栈中移除的顺序与添加的顺序相反。当我们运行这段代码时，我们可以看到元素是按照添加的顺序从队列中移出的。使用堆栈实现队列的一种方法是使用两个堆栈：一个用于添加元素，另一个用于移除元素。
使用Go语言将PDF文件转换为Base64编码
qq_45519030的博客
08-15 532
本文介绍了如何使用 Go 语言将 PDF 文件转换为 Base64 编码，并保存到文件中。
【Golang】go mod的使用
最新发布
youngwhz1的专栏
08-16 249
go get http://golang.org/x/text@342b2e 拉取 hash 为 342b231 的 commit，最终可能转换为 v0.3.2。创建go.mod文件后，直接go run 或 go build 将会自动下载依赖包，并将依赖关系和版本写到go.mod和go.sum文件中。go get http://golang.org/x/text@latest 拉取最新的版本，若存在tag，则优先使用。go mod tidy: 拉取缺少的模块，移除不用的模块。
Go语言基础--数据类型相互转换、指针
qq_59634082的博客
08-15 938
/在将 String 类型转成 基本数据类型时，要确保 String 类型能够转成有效的数据，比如 我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数，如果这样做，Golang 直接将其转成 0 ， 其它类型也是一样的道理. float => 0， bool => false。sf := strconv.FormatFloat(f, 'f', -1, 64) // 'f'表示固定点数表示，-1表示精度（自动），64表示float64。
golang切片和数组的区别
07-27
- *1* [Golang 语言中数组和切片的区别](https://blog.csdn.net/weixin_44014995/article/details/115434874)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值