GO ——奇妙的数组

最新推荐文章于 2024-11-07 23:56:43 发布
最新推荐文章于 2024-11-07 23:56:43 发布
阅读量300 收藏
点赞数
文章标签： 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
关注
索引和切片的基本使用
ghf183184的博客
03-11 1226
整数索引和切片的基本使用 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 607
1. 序列（sequence） 1.1 基本概念 序列是Python中最基本的一种数据结构（如布尔型 整型 字符串等）。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引。 序列相当于一个队列，每个位置按照一定顺序站队。就如同排队站列一样，一号位站某人，二号位站某人。 数据结构指计算机中数据存储的方式（存东西的方式有很多种，计算机...
Go语言特定的数组
weixin_44189499的博客
04-17 147
指定一个索引和对应值列表的方式初始化 type Currency int const ( USD Currency = iota // 美元 EUR // 欧元 GBP // 英镑 RMB // 人民币 ) symbol := [...]string{USD: "$", ...
数组（一）
pengzhisen123的博客
10-28 301
1、概念 同一种类型数据的集合。其实数组就是一个容器。 2、数组的好处 可以自动给数组中的元素从0开始编号，方便操作这些元素。 3、数组的格式 1、格式1： 元素类型 []  数组名=new 元素类型[元素个数或数组长度]； 示例： int[] arr=new int[8]; 2、格式2： 元素类型[] 数组名=new 元素类型[] {元素，元素，......}; 示例：int
第八章 数组
Girasoles的博客
11-12 3348
第八章 数组
深入理解 Go 语言——动态数组Slice
JackWu1024
10-25 537
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,...
GoC练习1——标记数组
2301_81605301的博客
12-31 609
假设我们用半径为10的橙色（13号色）实心圆表示硬币正面，用半径为10的灰色（8号色）实心圆表示硬币反面。请编程画出翻转后每个硬币的状态。小 Q 面前的桌子上有N个硬币，有些正面朝上，有些反面朝上。现在他将x至y连续一段的硬币翻转一面，请问这N个硬币中有多少个硬币正面朝上？第二行为 N个0和1，表示硬币 i的状态。第三行为两个整数x和y（x<=y），表示x至y连续一段需要翻转。第一行一个整数N，表示桌子上有 N 个硬币。请编程画出翻转后每个硬币的状态。请编程画出翻转后每个硬币的状态。
golang数据结构与算法——稀疏数组、队列和链表
qq_39280718的博客
08-15 392
稀疏数组、队列和链表
[Unity]随机装备属性随机数生成物品概率——随机数组物品概率
BuladeMian的博客，菜得抠脚，菜得真实
12-02 1524
参考资料1， 代码接着参考资料2继续。 Test_CubeSpawn.cs脚本中添加一个变量 ... /// <summary> /// 物品价值 /// </summary> public int value; ... Test_CubeSpawnManager.cs脚本中添加一个函数 ...
大家一起学Golang——Go语言简介与安装
01-08
大家一起学Golang ——Go语言简介与安装 go语言简介 Go语言是有google公司推出的一门编程语言，是开源，静态编程语言，语法简洁，天生支持并发。 2007年由Robert Griesemer, Rob Pike, Ken Thompson主持开发，又来...
Go核心开发学习笔记(十七) —— 数组
weixin_41047549的博客
05-04 847
数组与C差不多 array，切片是独有 slice 数组 数组在Golang中为值类型，定义方法如下： var intArray [3]int //定义一个整型数组，包含三个元素，其中下标为0,1,2 var flArray [3]float64 //定义一个float64型数组，包含...
Go数组与切片
微信公众号: 后端码匠
10-29 1301
go数组与切片 Go 语言数组 Go 语言提供了数组类型的数据结构。 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。 相对于去声明 number0, number1, …, number99 的变量，使用数组形式 numbers[0], numbers[1] …, numbers[99] 更加方便且易于扩展。 数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。 声明数组
Go的JSON转化
weixin_44719499的博客
11-06 429
在Go语言中，处理JSON（JavaScript Object Notation）数据非常常见，特别是在与Web服务交互时。Go提供了内置的包来支持JSON的序列化（将Go对象转换为JSON格式）和反序列化（将JSON格式的数据解析为Go对象）。
go语言生态
qq_25881443的博客
11-05 169
最近在看golang，因为是javaer，所以突发奇想，不如开发一个类似于 Maven 或 Gradle 的构建工具来管理 Go 项目的依赖，众所周知，构建和发布是一个复杂的任务，但通过合理的设计和利用现有的工具与库，可以实现一个功能强大且灵活的工具。Go 标准库：Go 的标准库提供了强大的编译和构建功能（如 go build, go install 等命令），可以通过调用这些命令或直接使用相关库来进行构建。Go 语言：由于我们要构建的是 Go 项目的构建工具，选择 Go 语言本身作为开发语言是合理的。
基于Prometheus的client_golang库实现应用的自定义可观测监控
penngo的专栏
11-04 885
Prometheus的client_golang库实现应用可观测监控，使用Go语言实现，编译更简单。
深入理解Go语言的接口与多态性
最新发布
weixin_52088134的博客
11-07 352
在Go语言中，接口是一组方法的集合。接口类型定义了若干方法，并规定了实现该接口的类型必须拥有这些方法。与许多面向对象语言不同，Go语言的接口实现是隐式的，即一个类型只要拥有接口要求的方法，就被认为实现了该接口，而不需要显式地声明实现关系。这种设计使Go语言的接口更为灵活，也减少了冗余代码。这个接口包含了一个方法Speak，任何类型只要实现了Speak方法，它就实现了Speaker接口。Go语言的接口和多态性为构建灵活、可扩展的程序提供了强有力的支持。通过接口，可以实现多态性和代码复用，提升代码的可维护性。
Go 指针的使用
weixin_44719499的博客
11-07 544
在Go语言中，指针（Pointer）是一种能够存储变量地址的数据类型。Go的指针使用比较简单，并且避免了许多其他编程语言中的复杂性，比如指针算术运算。指针的使用可以提高程序性能（避免不必要的复制），也可以用于共享数据，传递引用。
golang通用后台管理系统04（jwt的Token认证）
wangwei的博客
11-04 213
2. JWT 的TOKEN认证。1.修改之前的接口路由文件。
Go语言深入解析：复合类型——数组、切片与Map详解
在Go语言中，复合类型是一种组合数据类型，主要包括结构体、数组、切片和映射(Maps)。这些类型为开发者提供了灵活且高效的数据组织方式。 1. **数组**： - Go语言中的数组类似于Pascal风格，与C语言不同，数组大小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值