Go语言笔记

目录

一、变量声明

二、流程控制

if(条件判断)

for(循环结构) 

 Switch(简化if)

goto(跳出循环)

三、运算符

1、算数运算符

2、关系运算符

3、逻辑运算符

4、位运算符

5、赋值运算符

四、数组

1、数组的定义

2、数组的初始化

3、数组的遍历

五、切片

1、切片的定义和初始化

2、数组转切片

3、切片的容量

4、使用make()函数构造切片

5、append()

6、copy()


一、变量声明

1、函数外的每个语句都必须以关键字开始(var/const/func等)

2、:= 只能在函数内使用

3、_ 多用于占位,表示忽略值

4、const定义,iota从0开始,每增加一行,自动+1

const (
	_  = iota
	KB = 1 << (10 * iota)
	MB = 1 <<(10*iota)
	GB = 1 << (10*iota)
	TB = 1 << (10*iota)
	PB = 1 << (10*iota)
)

5、八进制&十六进制,注:Go语言无法直接定义二进制

    //八进制,0开头
	var ba int = 027

	//十六进制,0f开头
	var sa int = 0xfa

6、字符串,Go语言中的字符串以原生数据类型出现,类似(int/bool/float32等)。默认编码使用UTF-8

6、字符串转义符,使用反引号内部是什么就输出什么,不用加转义符

    //反引号的作用,内部写什么就输出什么,不用加转义符
	s1 := `C:\Users\230900013\go\src`
	s2 := "C:\\Users\\230900013\\go\\src"

二、流程控制

if(条件判断)

    //m只在if判断内部生效
	n := 18
	if m := 12; m > n {
		fmt.Println(" m > n", m, n)
	} else if m == n {
		fmt.Println(" m = n", m, n)
	} else if m < n {
		fmt.Println(" m <>> n", m, n)
	}

for(循环结构) 

    s := "1234567890"
	for i := 0; i < len(s); i++ {
		fmt.Printf("for循环基本格式 %c\n", s[i])
	}

    //Go没有while循环,可以用for循环完成
	for {
		fmt.Println("for无限循环", s)
	}

	n := "anfajakjfkasdjgn"
	for _, b := range n {
		fmt.Printf("for range循环 %c\n", b)
	}

 Switch(简化if)

	switch expr := 4; expr {
	case 2, 4, 6, 8:
		fmt.Println(expr, "是偶数")
	case 1, 3, 5, 7:
		fmt.Println(expr, "是奇数")
	default:
		fmt.Println(expr)
	}

	age := 36
	switch {
	case age < 18:
		fmt.Println(age, "未成年人")
	case age >= 18 && age < 35:
		fmt.Println(age, "青年人")
	case age >= 35 && age < 55:
		fmt.Println(age, "中年人")
		fallthrough//表示向下穿透,满足该case时,也会执行下一个case
	case age >= 55:
		fmt.Println(age, "好好享受退休生活吧")
	default:
		fmt.Println(age, "活着真好")
	}

goto(跳出循环)

    flag := false
	for i := 0; i < 10; i++ {
		for j := 0; j < i; j++ {
			if j == 5 {
				flag = true
				break //跳出内层循环
			}
			fmt.Printf("%d - %d\n", i, j)
		}
		if flag {
			fmt.Printf("over\n")
			break //跳出外层循环
		}
	}

	for i := 0; i < 10; i++ {
		for j := 0; j < i; j++ {
			if j == 5 {
				goto Lable
			}
			fmt.Printf("%d - %d\n", i, j)
		}
	}

Lable:
	fmt.Println("这里用到了跳转")

三、运算符

1、算数运算符

+、-、*、/、%(++、--在go语言中是单独的语言,不能放在=右边)

2、关系运算符

==、!=、>、>=、<、<=

3、逻辑运算符

&&、||、!

4、位运算符

&:参与运算的两数各对应的二进位相与

|:参与运算的两数各对应的二进位相或

^:参与运算的两数各对应的二进位相异或,当两对应的二进位相异时,结果为1

<<:左移n位,高位丢弃,低位补0

>>:右移n位

5、赋值运算符

=、+=、-+、*=、/=、%=、<<=、>>=、&=、|=、^=

四、数组

1、数组的定义

var 数组变量名 [元素数量] T

var a [5]int
var b [5]bool

2、数组的初始化

    //方法一
	var a [5]int
	a = [5]int{0, 1, 2, 3, 4}
	fmt.Println(a)

	//方法二
	b := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
	fmt.Println(b)

	//方法三,根据索引初始化
	c := [5]int{0:5, 4:20}
	fmt.Println(c)

3、数组的遍历

    //根据索引遍历
	str := [...]string{"wo", "ttt", "fff", "sss", "rrr"}
	for i := 0; i < len(str); i++ {
		fmt.Println(str[i])
	}

	//for range
	for _, i := range str {
		fmt.Println(i)
	}

五、切片

1、切片的定义和初始化

var name []T

    var age []int
	var name []string

	age = []int{18, 20, 5, 36}
	name = []string{"Linda", "Lucy", "Lily", "Kity"}

	var flag = []bool{false, true, false, true}
	temp := []string{"int", "string", "bool"}

2、数组转切片

    //左包含,右不包含
	str := [...]string{"wo", "ttt", "fff", "sss", "rrr", "ooo", "pip"}
	a1 := str[1:4]  //str取下标1-3的元素
	a2:=str[:3] 	//==> 0-2
	b1:=str[3:] 	//==> 3-len(str)
	c1:=str[:]		//==> 0-len(str)

3、切片的容量

切片的容量是指底层数组的容量

4、使用make()函数构造切片

make([] T, size, cap)

T:切片的元素类型

size:切片中元素的数量

cap:切片的容量

//int类型切片,长度5,容量10
a:=make([]int, 5, 10)

5、append()

    //int类型切片,长度5,容量10
	a := []int{0, 1, 2, 3}
	fmt.Printf("a=%v, len=%v, cap=%v\n", a, len(a), cap(a))

	//append 之后,容量会自动增加
	a = append(a, 12)
	fmt.Printf("a=%v, len=%v, cap=%v\n", a, len(a), cap(a))

	//将B切片追加到A切片, ...表示拆分
	b := []int{7, 8, 9, 10}
	a = append(a, b...)
	fmt.Printf("a=%v, len=%v, cap=%v\n", a, len(a), cap(a))

6、copy()

copy是深拷贝, := 赋值的方式是浅拷贝

	str := []string{"a", "b", "c", "d", "f"}
	stra := str
	var strb = make([]string, 5, 10)
	copy(strb, str)
	fmt.Printf("str=%v, stra=%v, strb=%v\n", str, stra, strb)

	str[0] = "test"
	fmt.Printf("str=%v, stra=%v, strb=%v\n", str, stra, strb)

7、删除

切片没有删除方法,需要通过append操作间接实现删除元素操作。通过拼接,删除的元素实际是被覆盖了,原始指向的底层数组,内容也被改变,观察最终打印的arr,可以清晰看到切片和底层数组之间的关系变化

	arr := [...]int{1, 2, 3, 4, 5, 6, 7}
	s := arr[:]
	fmt.Println(s, len(s), cap(s))

	s = append(s[0:1], s[2:]...)
	fmt.Println(s, len(s), cap(s))
	fmt.Println(arr)

六、指针

Go语言不存在指针操作,只需要记住两个符号

&:取地址

*:根据地址取值

总结:取地址符号`&`和取值符号`*`是一对互补操作,`&`取出地址,`*`根据地址取出地址指向的值。

    n := 10
	//p 取n存储的地址,data 是取该地址中存储的数据
	p := &n
	data := *p
	fmt.Println(p, data)

七、make

make用于分配并初始化slice、map、chan类型的对象。make函数返回初始化的内存空间,并返回该内存空间的引用(即指针)。与new不同的是,new仅分配内存空间,不进行初始化。

	//int类型的slice,长度0,容量5
	s := make([]int, 0, 5)

	// m是一个string到int的映射,它现在是空的,但可以使用m[key] = value的方式来添加元素。
	m := make(map[string]int)
	m["name"] = 1

	// ch是一个int类型的channel,现在它是空的,但可以用于在goroutines之间进行通信。
	ch := make(chan int)

总结:

1、make用于slice/map/channel的内存分配和初始化

2、它返回初始化(非零)的slice/map/channel的引用

3、对于slice,make函数允许指定长度和容量

4、对于map、channel,make函数只分配内存,没有长度或容量的概念

5、make与new不同,new仅分配内存,不进行初始化。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值