重拾Go语言2

Horizon629

已于 2022-06-21 16:47:19 修改

阅读量89

点赞数 1

分类专栏： Go 文章标签： golang 开发语言后端

于 2022-06-20 23:29:26 首次发布

本文链接：https://blog.csdn.net/weixin_61814212/article/details/125364224

版权

Go 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1.常量

package main

import "fmt"

func main() {
	//1.定义常量
	const PATH string = "www.baidu.com"
	const PI = 3.14
	fmt.Println(PATH)
	//与变量不同的是，常量定义后不使用不会报错
	//fmt.Println(PI)

	//2.定义一组常量
	const C1, C2, C3 = 100, 3.14, "haha"
	const (
		a int    = 100
		b        //不赋值的话与上一行一致
		c string = "curry"
		d
		e
	)
	fmt.Printf("%T,%d\n", a, a)
	fmt.Printf("%T,%d\n", b, b)
	fmt.Printf("%T,%d\n", c, c)
	fmt.Printf("%T,%d\n", d, d)
	fmt.Printf("%T,%d\n", e, e)

}

输出结果：

www.baidu.com
int,100
int,100
string,curry
string,curry
string,curry

2.iota关键字

package main

import (
	"fmt"
)

func main() {
	const (
		A = iota   //0
		B          //1
		C          //2
		D = "haha" //iota=3
		E          //haha iota=4
		F = 100    //iota=5
		G          //100 iota=6
		H = iota   //7
		I          //iota=8
	)

	//遇到新的常量组，iota变为0
	const (
		J = iota //0
	)

	fmt.Println(A)
	fmt.Println(B)
	fmt.Println(C)
	fmt.Println(D)
	fmt.Println(E)
	fmt.Println(F)
	fmt.Println(G)
	fmt.Println(H)
	fmt.Println(I)
	fmt.Println(J)
}

输出结果：

0
1
2
haha
haha
100
100
7
8
0

3.字符串

package main

import "fmt"

func main() {
	//'A'与"A"的区别
	v1 := 'A' //打印会输出对应ASCII码
	v2 := "A"
	fmt.Printf("%T,%d\n", v1, v1)
	fmt.Printf("%T,%s\n", v2, v2)
	//转义字符
	fmt.Println("\"Hello World\"")
}

运行结果：

int32,65
string,A
"Hello World"

4.关系运算符

与&（将所有条件式运算一遍）

短路与&&（遇到0，即假时便结束，提高运算效率）

5.键盘输入和打印输出

package main

import "fmt"

func main() {
	/*
		格式化打印占位符：
			%v,原样输出
			%T,打印类型
			%t,bool类型
			%s,字符串
			%f,浮点
			%d,10进制的整数
			%b,2进制的整数
			%o,8进制
			%x,%X,16进制
			%x,0-9，a-f
			%X,0-9,A-F
			%c,打印字符
			%p,打印地址

	*/

	//输入
	var x int
	var y float64
	fmt.Println("请输入一个整数，一个浮点类型")
	fmt.Scanln(&x, &y) //读取键盘的输入，通过操作地址，赋值给x和y
	fmt.Printf("x的数值:%d,y的数值：%f\n", x, y)
}

输出结果：

30 3.14
x的数值:30,y的数值：3.140000

6.随机数

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	/*
		生成随机数random：
			伪随机数，根据一定的算法公式算出来的
	*/
	num1 := rand.Int()
	fmt.Println(num1)

	for i := 0; i < 5; i++ {
		num := rand.Intn(10) //产生[0,10)范围内的随机数
		fmt.Println(num)
	}
	//设置种子数
	//time.Now为当前的时间，类型为time对象，因此用Unix获取到int64类型。
	//时间戳：指定时间，距离1970年1月1日0点0分0秒之间的时间差值，Unix为秒，UnixNano为纳秒
	rand.Seed(time.Now().Unix())
	rand.Seed(time.Now().UnixNano())
	/*for i := 0; i < 10; i++ {
		fmt.Println(rand.Intn(10))
	}*/
	for i := 0; i < 10; i++ {
		fmt.Println("-->", rand.Intn(10)+3) //[3,13) //不改变种子数的话输出结果不会改变
	}
}

输出结果：

5577006791947779410
7
7
9
1
8
--> 12
--> 3
--> 4
--> 5
--> 11
--> 10
--> 5
--> 12
--> 4
--> 7

7.数组的遍历（for range）

package main

import "fmt"

func main() {
	//range,词义“范围”
	//不需要操作数组的下标，到达数组的末尾，自动结束for range循环，
	//每次从数组中获取下标和对应的数值
	arr1 := [5]int{1, 2, 3, 4, 5}
	for index, value := range arr1 {
		fmt.Printf("下标是:%d,数值是：%d\n", index, value)
	}
	sum := 0
	for _, v := range arr1 {
		sum += v
	}
	fmt.Println(sum)
}

输出结果：

下标是:0,数值是：1
下标是:1,数值是：2
下标是:2,数值是：3
下标是:3,数值是：4
下标是:4,数值是：5
15

8.切片

package main

import "fmt"

func main() {
	/*
		切片slice：同数组类似，也叫做变长数组或者动态数组。
		特点：变长
	*/
	//切片
	s1 := []int{1, 2, 3, 4, 5}
	printSlice(s1)
	s2 := make([]int, 3, 8) //三个参数分别为：储存数据的类型，长度，容量
	printSlice(s2)
	s2[0] = 1
	s2[1] = 2
	s2[2] = 3
	printSlice(s2)
	//s2[4]，报错。虽然最大容量为8，但是长度最大为3
	//append()
	s2 = append(s2, 4, 5) //参数分别为切片以及添加的数据
	printSlice(s2)
	s2 = append(s2, 6, 7, 8, 9, 10) //虽然长度超过了容量，但是不会报错，因为会自动扩容
	printSlice(s2)

	//append 第二个参数slice
	s2 = append(s2, s1...) //加...是编译器不会将s1看成一个元素，而是将s1的元素追加
	printSlice(s2)
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

输出结果：

len=5 cap=5 slice=[1 2 3 4 5]
len=3 cap=8 slice=[0 0 0]
len=3 cap=8 slice=[1 2 3]
len=5 cap=8 slice=[1 2 3 4 5]
len=10 cap=16 slice=[1 2 3 4 5 6 7 8 9 10]
len=15 cap=16 slice=[1 2 3 4 5 6 7 8 9 10 1 2 3 4 5]

package main

import "fmt"

func main() {
	/*
		切片Slice：
			1.每一个切片引用了一个底层数组
			2.切片本身不存储任何数据，都是这个底层数组储存，所以修改切片也就是修改这个数组中的数据
			3.当向切片中添加数据时，如果没有超过容量，直接添加，如果超过容量，自动扩容（成倍增长）
			4.切片一旦扩容，就是重新指向一个新的底层数组

	*/
	s1 := []int{1, 2, 3}
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:3,cap:3
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 4, 5) //len:5,cap:6
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1) //原先的容量不够，重新开辟地址，使指针指向新地址

	s1 = append(s1, 6, 7, 8) //len:8,cap:12
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1) //原先的容量不够，重新开辟地址，使指针指向新地址

	s1 = append(s1, 9, 10) //len:10,cap:12
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1) //原先的容量足够，地址不改变
}

输出结果：

[1 2 3]
len:3,cap:3
0xc0000ae078
[1 2 3 4 5]
len:5,cap:6
0xc0000c0060
[1 2 3 4 5 6 7 8]
len:8,cap:12
0xc000086060
[1 2 3 4 5 6 7 8 9 10]
len:10,cap:12
0xc000086060