Golang语言循环、指针、结构体和切片（打卡✏️第二天）｜Go主题月

头像
微芒不朽
阅读 6 分钟
头图

image

Go 语言循环语句

for循环是一个循环控制结构，可以执行指定次数的循环。

for init; condition; post { }
init： 一般为赋值表达式，给控制变量赋初值；
condition： 关系表达式或逻辑表达式，循环控制条件；
post： 一般为赋值表达式，给控制变量增量或减量。

for i:=1;i<100;i++{
    fmt.Println(i)
}

for range

for循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环

for key, value := range oldMap {
    newMap[key] = value
}

求和

var sum = 0
for i:=1;i<100;i++{
    sum+=i
}
fmt.Println(sum) //4950

for省略的形式

省略形式1

sum:=0
for;sum<=100;{
    sum+=sum
}
fmt.Println(sum)

省略形式2

sum:=0
for sum<=10 {
    sum+=sum
}
fmt.Println(sum)

range

str:=[]string{"躲躲","前端开发"}
for i,s :=range str{
    fmt.Println(i,s) //0 躲躲 1 前端开发    
}
numbers :=[6] int{1,2,3,4,5}
for i,s :=range numbers{
    fmt.Println(i,s) //0 1    1 2    2 3    3 4    4 5    5 0
}
numbers :=[]int{1,2,4,5}
for i,s :=range numbers{
    fmt.Println(i,s)
}

函数

1.函数是基本的代码块，用于执行一个任务。
2.Go 语言最少有个 main() 函数。
3.你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
4.函数声明告诉了编译器函数的名称，返回类型，和参数。
5.Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

函数放在main函数里面去执行

func max(num1,num2 int) int{
  return num1+num2
}
fmt.Println(max(1,2))

返回多个参数

func strs(a,b string) (string,string){
    return a,b
}
var a,b= strs("詹躲躲","前端开发") 
fmt.Println(a,b) //詹躲躲 前端开发

函数参数

传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

func swap(num1,num2 int) int{
    var temp int
    temp = num1
    num1 = num2
    num2 = temp
    return temp
}
ret:=swap(1,10)
fmt.Println(ret) //1

引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

var a int = 100
var b int= 200
swap(&a,&b)

func swap(num1 *int,num2 *int){
    var temp int
    temp = *num1
    *num1 = *num2
    *num2 = temp
    fmt.Println(num1) //0xc0000ac058
}
// var s1,t1 = "abcd", "abcde"
// var s2,t2 = "ae","aea"
// ret:=findTheDifference(s1,t1)
// ret1:=findTheDifference(s2,t2)
// fmt.Println(ret)
// fmt.Println(ret1)
// }
// func findTheDifference(s string, t string) byte {
//     return t[len(s):]
// }

函数作为实参

    getSqure:=func(x float64) float64{
        return math.Sqrt(x)
    }
    fmt.Println(getSqure(9)) //3

声明一个函数类型

fmt.Println(math.Sqrt(9)) //3
testCallBack(1,CallBack)
type cb func(int) int
func testCallBack(x int,f cb){
    f(x)
}

func CallBack(x int) int{
    fmt.Println(x) //1
    return x
}

变量作用域

作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。
Go 语言中变量可以在三个地方声明：
函数内定义的变量称为局部变量
函数外定义的变量称为全局变量
函数定义中的变量称为形式参数

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。
声明局部变量

var a, b, c int

声明全局变量

var g int

Go 语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑。
形式参数
形式参数会作为函数的局部变量来使用。

fmt.Println(math.Sqrt(9)) //3
c:=sum(20,23)
fmt.Println(c) //43
func sum(x,y int)int{
    fmt.Printf("sum中的变量x: %d",x) //20
    fmt.Printf("sum中的变量y: %d",y) //23
    return x+y
}

数组

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

声明数组

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之旅。

go后端前端
微芒不朽
1.2k 声望1.3k 粉丝
« 上一篇
Golang语言学习笔记（打卡✏️第一天）｜Go主题月
下一篇 »
Golang语言（打卡✏️第三天）map、递归、报错和练习题｜Go主题月

引用和评论

推荐阅读
头像
Spring Boot起步，CRUD、错误处理与宝塔部署

微芒不朽赞 3阅读 643

头像
CSS团队协作规范

寒青赞 36阅读 4k

头像
前端如何入门 Go 语言

robin赞 26阅读 7.7k评论 8

头像
100个React最佳实践小技巧

夕水赞 17阅读 2.7k评论 4

头像
不使用 JS 纯 CSS 获取屏幕宽高

南城FE赞 15阅读 2.2k评论 3

头像
前端开发工具

寒青赞 15阅读 4.7k

头像
开发插件集合

寒青赞 12阅读 3.1k

0 条评论
得票最新