Golang语言循环、指针、结构体和切片(打卡✏️第二天)|Go主题月(下)

简介: Go 语言循环语句 for循环是一个循环控制结构,可以执行指定次数的循环。

数组



数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。


声明数组


var variable_name [SIZE] variable_type
var balance [10] float32
fmt.Println(balance) //[0 0 0 0 0 0 0 0 0 0]


初始化数组


var balance =[5]int{1,2,4,5,7}
balance:=[5]int{1,2,4,5,7} //字面量


数组推断



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


person:=[...]string{"詹","躲躲"}
fmt.Println(person) //[詹 躲躲]

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。


var i [10]int
fmt.Println(i) //[0 0 0 0 0 0 0 0 0 0]

将索引为 1 和 3 的元素初始化


arr:=[10]string{1:"詹",3:"躲躲"}
fmt.Println(arr) //[ 詹  躲躲      ]


多维数组



三维数组


var threedim [2][3][4]int
fmt.Println(threedim) //[[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[0 0 0 0] [0 0 0 0] [0 0 0 0]]]
arr:=[][]int{}
row1:=[]int{1,2,3}
row2:=[]int{4,5,6}
arr = append(arr,row1)
arr = append(arr,row2)
fmt.Println(arr[0]) //[1,2,3]
fmt.Println(arr[1]) //[4,5,6]


初始化二维数组


a:=[3][4]int{
    {1,2,3,5},
    {1,2,3,5},
    {1,2,3,5},
}
fmt.Println(a) //[[1 2 3 5] [1 2 3 5] [1 2 3 5]]
数组5行2列
arr:=[5][2]int{{0,0},{1,0},{0,2},{0,2},{1,1}}
var i,j int
for i=0;i<5;i++{
    for j=0;j<2;j++{
        fmt.Printf("数组元素arr[i][j]:%d\n",i,j,arr[i][j])
    }
}
%!(EXTRA int=0, int=0)数组元素arr[i][j]:0
%!(EXTRA int=1, int=0)数组元素arr[i][j]:1
%!(EXTRA int=0, int=1)数组元素arr[i][j]:1
%!(EXTRA int=1, int=0)数组元素arr[i][j]:2
%!(EXTRA int=0, int=0)数组元素arr[i][j]:2
%!(EXTRA int=1, int=2)数组元素arr[i][j]:3
%!(EXTRA int=0, int=0)数组元素arr[i][j]:3
%!(EXTRA int=1, int=2)数组元素arr[i][j]:4
%!(EXTRA int=0, int=1)数组元素arr[i][j]:4
%!(EXTRA int=1, int=1)


指针



Go 语言的取地址符是 &,放到一个变量前使用就会返回相应变量的内存地址

一个指针变量指向了一个值的内存地址。


var a int =20 //实际变量
var b *int //指针变量

指针变量的存储地址


b = &a  
 fmt.Printf("指针变量的地址:%x",b) //指针变量的地址:c000016098


空指针



var  ptr *int
 fmt.Printf("ptr 的值为 : %x\n", ptr  )


语言结构体



Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型。


结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。


定义结构体


结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型,结构体中有一个或多个成员。type 语句设定了结构体的名称。

type Person struct{
    name string
    age int
    sex string
    id string
}
fmt.Println(Person{"詹躲躲",19,"男","2133321321"}) //{詹躲躲 19 男 2133321321}
fmt.Println(Person{name:"詹躲躲",age:19,sex:"男",id:"2133321321"}) //{詹躲躲 19 男 2133321321}


忽略字段



fmt.Println(Person{name:"詹躲躲",age:19}) //{詹躲躲 19}


访问结构体成员



type Person struct{
    name string
    age int
    sex string
    id string
}
var person Person
person.name = "许嵩"
fmt.Println(person) //{许嵩 0  }


结构体作为函数参数


var person1 Person
person1.name = "许巍"
var person2 Person
person2.name="赵雷"
printStruct(person1) //结构体的数据:许巍
printStruct(person2) //结构体的数据:赵雷
type Person struct{
    name string
    age int
    sex string
    id string
}
func printStruct(person Person){
    fmt.Printf("结构体的数据:%s",person.name) 
}


结构体指针


var person1 Person
person1.name = "许巍"
var person2 Person
person2.name="赵雷"
printStruct(&person1) //结构体的数据:许巍
printStruct(&person2) //结构体的数据:赵雷
type Person struct{
    name string
    age int
    sex string
    id string
}
func printStruct(person *Person){
    fmt.Printf("结构体的数据:%s",person.name) 
}


语言切片



切片是对数组的抽象。


切片初始化


a:=[]int{1,2,3} //[1 2 3]
b:=a[:] //[1 2 3]
fmt.Println(a,b)

使用make

a:=make([]int,3,5)
fmt.Println(a) //[0 0 0]
len() 方法获取长度
cap() 可以测量切片最长可以达到多少
a:=[8]int{1,2,3,4,5,6,7,8}
fmt.Println(len(a),cap(a)) //8 8


空的切片


var a []int
if(a==nil){
    fmt.Println("空的切片")
}


切片截取


a:=[8]int{1,2,3,4,5,6,7,8}
fmt.Println("原始大小",a) //[1,2,3,4,5,6,7,8]
fmt.Println("1-4(不包含4)",a[1:4]) //2,3,4
fmt.Println("0-4(不包含4)",a[:4]) //[1,2,3,4]
fmt.Println("4以后的",a[4:]) //5,6,7,8
append()  copy() 函数
var numbers []int
numbers = append(numbers,1)
numbers1:=make([]int,len(numbers),(cap(numbers))*2)
copy(numbers1,numbers)
fmt.Println(numbers) //[1]


范围(Range)


a:=[5]int{1,2,3,4,5}
for i,j :=range a{
    fmt.Println(i,j) //0 1    1 2    2 3    3 4    4 5
}

枚举字符串


for i,j :=range "asdsada"{
    fmt.Println(i,j) //0 97    1 115 2 100    3 115 4 97    5 100 6 97
}

range也可以用来枚举Unicode字符串。第一个参数是字符的索引,第二个是字符(Unicode的值)本身


元气满满的一天。明天继续打卡,继续开启GO之旅。

相关文章
|
1天前
|
安全 Go 开发者
Golang深入浅出之-Go语言并发编程面试:Goroutine简介与创建
【4月更文挑战第22天】Go语言的Goroutine是其并发模型的核心,是一种轻量级线程,能低成本创建和销毁,支持并发和并行执行。创建Goroutine使用`go`关键字,如`go sayHello(&quot;Alice&quot;)`。常见问题包括忘记使用`go`关键字、不正确处理通道同步和关闭、以及Goroutine泄漏。解决方法包括确保使用`go`启动函数、在发送完数据后关闭通道、设置Goroutine退出条件。理解并掌握这些能帮助开发者编写高效、安全的并发程序。
10 1
|
1天前
|
人工智能 Go 调度
掌握Go并发:Go语言并发编程深度解析
掌握Go并发:Go语言并发编程深度解析
|
1天前
|
SQL 关系型数据库 MySQL
Golang数据库编程详解 | 深入浅出Go语言原生数据库编程
Golang数据库编程详解 | 深入浅出Go语言原生数据库编程
|
2天前
|
Go 开发者
Golang深入浅出之-Go语言流程控制:if、switch、for循环详解
【4月更文挑战第21天】本文介绍了Go语言中的流程控制语句,包括`if`、`switch`和`for`循环。`if`语句支持简洁的语法和初始化语句,但需注意比较运算符的使用。`switch`语句提供多分支匹配,可省略`break`,同时支持不带表达式的形式。`for`循环有多种形式,如基本循环和`for-range`遍历,遍历时修改原集合可能导致未定义行为。理解并避免易错点能提高代码质量和稳定性。通过实践代码示例,可以更好地掌握Go语言的流程控制。
11 3
Golang深入浅出之-Go语言流程控制:if、switch、for循环详解
|
2天前
|
Go
Golang深入浅出之-Go语言函数基础:定义、调用与多返回值
【4月更文挑战第21天】Go语言函数是代码组织的基本单元,用于封装可重用逻辑。本文介绍了函数定义(包括基本形式、命名、参数列表和多返回值)、调用以及匿名函数与闭包。在函数定义时,注意参数命名和注释,避免参数顺序混淆。在调用时,要检查并处理多返回值中的错误。理解闭包原理,小心处理外部变量引用,以提升代码质量和可维护性。通过实践和示例,能更好地掌握Go语言函数。
16 1
Golang深入浅出之-Go语言函数基础:定义、调用与多返回值
|
6月前
|
存储 编译器 Go
Golang 语言的多种变量声明方式和使用场景
Golang 语言的多种变量声明方式和使用场景
32 0
|
6月前
|
缓存 编译器 Go
Golang 语言 vendor 在 GOPATH 和 Modules 中的区别
Golang 语言 vendor 在 GOPATH 和 Modules 中的区别
31 0
|
6月前
|
Go 数据中心 微服务
Golang 语言微服务的服务发现组件 Consul 的系统架构介绍
Golang 语言微服务的服务发现组件 Consul 的系统架构介绍
59 0
|
1月前
|
SQL 前端开发 Go
编程笔记 GOLANG基础 001 为什么要学习Go语言
编程笔记 GOLANG基础 001 为什么要学习Go语言
|
6月前
|
存储 JSON Go
Golang 语言 gRPC 服务怎么同时支持 gRPC 和 HTTP 客户端调用?
Golang 语言 gRPC 服务怎么同时支持 gRPC 和 HTTP 客户端调用?
76 0