文章目录
- 基础语法
- 值
- 变量
- 常量
- 运算符
- 指针
- new 和 make 区别
- 字符串
- byte 和 rune 类型
- 流程控制
- for 循环
- If else 分支
- switch 分支
基础语法
项目代码地址:02-basicgrammar
值
- 基本类型值
Go 最基础的数据类型,比如整型、浮点型、布尔型。
- 复合类型值
由基本类型组成的复杂数据类型,比如数组、切片、结构体、函数、map、通道、接口、字符串。
- 指针类型值
指针类型的变量与指针类型值绑定,它内部存储的是另外一个内存单元的地址。
简单示例:
// 值
func function01() {fmt.Println(123_456) // 123456fmt.Println("go" + "lang") // golangfmt.Println("1 + 1 = ", 1+1) // 1 + 1 = 2fmt.Println("3 / 2 = ", 3/2) // 3 / 2 = 1fmt.Println("7.0 / 3 = ", 7.0/3) // 7.0 / 3 = 2.3333333333333335fmt.Println(true && false) // falsefmt.Println(true || false) // truefmt.Println(!true) // false
}
Go 中的值类型和引用类型:
- 值类型:int系列、float系列、bool、string、数组、结构体
- 引用类型:指针、slice切片、管道channel、接口interface、map、函数
值类型:变量直接存储值,内存通常在栈中分配
引用类型:变量存储的是一个地址,地址空间存储真正的值,内存通常在堆中分配
在Go语言中,所有东西都是以值的形式存在的,只有值传递没有引用传递。
- 传值:你是你,我是我
- 传指针:你是你,我是我,但我们共同指向他
- 传“引用”:你是你,我是我,但我们有一部分共同指向他
// 指针类型
func function02() {a := 1ptr := func(b *int) {fmt.Println(&b, b) // 0xc000088028 0xc00000a0c8*b = 2fmt.Println(*b) // 2}fmt.Println(&a) // 0xc00000a0c8ptr(&a)fmt.Println(a) // 2
}// 引用类型
func function03() {s := []int{1, 2}ref := func(a []int) {fmt.Printf("%p\n", &a) // 0xc000008060a[1] = 0fmt.Println(a) // [1 0]}fmt.Printf("%p\n", &s) // 0xc000008048ref(s)fmt.Println(s) // [1 0]
}
不难看出,上述在传递参数过程中都是进行值传递的。尽管切片是引用类型,但传递时仍然会拷贝新的变量,只不过新变量的底层结构有对另一个基础类型的指向。
Go 的引用类型不同于 C++ 的引用,引用并不是同一个地址,不过底层指针是同一个指向。
对比 C++ 的引用:引用传递地址不变,a,b变量共享同一地址
#include<iostream>
using namespace std;struct Node {int a, b, c;
};void func(Node &a) {cout << &a << endl; // 0x7ffc43a4a21c
}int main() {Node b = {1, 2, 3};func(b);cout << &b << endl; // 0x7ffc43a4a21creturn 0;
}
额外补充,切片容易踩的坑:
切片在运行时由三个字段构成,值拷贝创建副本也就是对 Data、Len、Cap字段进行拷贝,而 Data 指针指向与原slice 同一地址。
type SliceHeader struct {Data uintptr // 指向底层数组的指针Len int // 切片长度Cap int // 切片容量
}
所以在副本中修改元素时,原 slice 的元素也会被修改。但是修改的是副本的 Len、Cap 时,原 slice 保持不变。如果副本由于扩容导致 Data 地址重新分配,那么之后副本的操作完全无法影响到原 slice。
// 传"引用"
func function04() {a := make([]int, 1, 2) // 指定len(a)=1,cap(a)=2a[0] = 1fmt.Println(len(a), cap(a), a) // 1 2 [1]ref := func(b []int) {b[0] = 4fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 1 2 [4] 1 2 [4]b = append(b, 2)fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 2 2 [4 2] 1 2 [4]b[0] = 0fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 2 2 [0 2] 1 2 [0]b = append(b, 3)fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 3 4 [0 2 3] 1 2 [0]b[0] = 1fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 3 4 [1 2 3] 1 2 [0]}ref(a)
}
上面的例子阐明了两点:
- “引用” 是我们共同一部分指向它:b 添加元素后,len 变为 2,而原 a 的 len 还是 1,所以切片的第一个元素是被共同指向的
- 扩容后“引用”的元素地址改变:b 扩容后,cap 变为 4,Data 地址改变,再修改第一个元素时,不再能影响原 a 的元素
如果上述不能理解,可以先放着,等下章学习了切片等类型后,再来回顾。
变量
常用两种声明变量格式:
-
var
用来声明变量,标准声明格式:var 变量名 变量类型
-
:=
短变量只能用于声明局部变量,不能用于全局变量声明,即在函数或方法内部使用。
变量只声明未初始化,则为默认值。
// 变量
func function05() {var a int64 // 声明未初始化,默认 int64(0)var b string = "ABC" // 标准声明并初始化var c = 1 // 自动类型推导var d, e = 2, "3" // 一次初始化多个变量// 批量声明var (f float64 = 3.1g bool = false)h := .1 // 简短变量声明fmt.Println(a, b, c, d, e, f, g, h) // 0 ABC 1 2 3 3.1 false 0.1
}
常量
var
换为 const
即可定义常量
// 常量
func function06() {const pi = 3.1415// 同时声明多个常量,某个常量省略值,则和上一个相同const (e = 2.7182a // 2.7182b // 2.7182c = 3d // 3)// iota 预声明标识符,表示连续的无类型整数常量,初始值 0const (level1 = iota + 1 // 1level2 // 2level3 // 3_ // 跳过某些值level5 // 5n = 1000 // 在 iota 声明中插队level6 = iota // 6, 需要再使用 iota)// 多个 iota 定义在一行,iota 值逐行增加const (A, B = iota + 1, iota + 2 // 1 2C, D // 2 3E, F // 3 4)// 用来定义数量级const (_ = iotaKB = 1 << (10 * iota) // 1 << (10 * 1)MB = 1 << (10 * iota) // 1 << (10 * 2)GM = 1 << (10 * iota) // 1 << (10 * 3)TB = 1 << (10 * iota) // 1 << (10 * 4))
}
运算符
需要注意的是
++(自增)
和--(自减)
在 Go 中是单独的语句,并不属于运算符&^
按位清除;z := x &^ y
,y 中位 1,z 位 0,y 中位 0,z 位为 x 位
// 运算符
func function10() {var a inta++fmt.Println(a) // 1// b := a-- 错误!i++、i--只能单独使用// ++a 错误!没有 ++i、--i 操作x := 11y := (1 << 0) | (1 << 3) // 保证 z 中的第 0 位和第 3 位为 0z := x &^ yfmt.Printf("x = %b\n", x)fmt.Println("\t&^")fmt.Printf("y = %b\n", y)fmt.Println("————————")fmt.Printf("z = %04b\n", z)/*x = 1011&^y = 1001————————z = 0010*/
}
指针
指针用法和其他语言类似,而且 Go 中使用了垃圾回收机制,不需要手动释放内存。
// 指针
func function15() {str := "123"var strPtr *string = &strfmt.Println(str, *strPtr) // 123 123fmt.Println(&str, strPtr, &strPtr) // 0xc000026070 0xc000026070 0xc000088020
}
new 和 make 区别
Go 语言中 new
和 make
是内建的两个函数,主要用来分配内存。
-
new
:用于类型的内存分配,返回值是一个指向新分配类型零值的指针 -
make
:只用于 slice、map、channel 初始化,返回这三个引用类型本身
// new、make
func function16() {a := new(bool)fmt.Printf("%T %t %v\n", a, *a, a) // *bool false 0xc000192068b := make([]int, 1, 2)fmt.Printf("%T %v %p %p %p\n", b, b, b, &b, &b[0]) // []int [0] 0xc0001920b0 0xc000190030 0xc0001920b0
}
这里重点关注 make 后返回的切片引用类型本身 b,可见 b 和 &b[0] 的地址是一样的,都是指向底层数组的指针。而 &b 则是表示当前这个切片结构体的地址。
字符串
在运行时字符串类型表示如下:
type StringHeader struct {Data uintptr // 指向底层字节数组指针Len int // 字节数组长度
}
Go 在编程语言层面对值做了限制,常量值是不可变的,字符串类型值是不可变的,其他则为可变值。
Go 中只允许用双引号和反引号定义字符串,使用单引号定义字符类型。字符串是一个只读的 byte 类型切片,组成每个字符串的元素叫字符,字符变量默认 rune 型。
// 字符串
func function07() {s1 := "123"s2 := "字符串"s3 := `第一行
第二行
第三行
`// s1[0] = '4' // 不能修改s1 += "456" // 123456fmt.Println(len(s1), len(s2), len(s3)) // 3 9 30
}
byte 和 rune 类型
Go 语言字符有两种类型,byte
代表 ASCII 码的一个字符,rune
代表一个 UTF-8 字符。
byte
型,本质上是uint8
rune
型,本质上是int32
特殊的 rune
类型表示 Unicode 编码的整数,能让基于 Unicode 的文本处理更方便,比如处理中文或其他复合字符。
-
内建函数
len()
函数用来获取字符串的 ASCII 字符个数或字节长度。Go 语言的字符串都以 UTF-8 格式保存,每个中文占用 3 个字节 -
unicode/utf8
包提供的utf8.RuneCountInString()
函数用来统计 Unicode 字符数量 -
unsafe
包提供的unsafe.Sizeof
返回数据类型的大小 -
for 循环遍历,对应 ASCII 码;for range 遍历,对应 Unicode 码
// byte、rune
func function08() {var a = 'a'var b byte = 'b'fmt.Println(unsafe.Sizeof(a), unsafe.Sizeof(b)) // 4 1s1 := "Golang语言"fmt.Println(len(s1), utf8.RuneCountInString(s1)) // 12 8for i := 0; i < len(s1); i++ {fmt.Printf("%c", s1[i])} // Golangè¯è¨fmt.Println()for _, s := range s1 {fmt.Printf("%c", s)} // Golang语言
}
读者可能会疑惑,之前代码中 s1 += "456"
这不是修改了字符串本身了吗?
func function09() {// 仅声明字符串var str stringvar stringHeader = (*reflect.StringHeader)(unsafe.Pointer(&str))fmt.Printf("%p %p %d\n", &str, unsafe.Pointer(stringHeader.Data), stringHeader.Len)// 字符串赋值str = "快速入门"fmt.Printf("%p %p %d\n", &str, unsafe.Pointer(stringHeader.Data), stringHeader.Len)// 字符串拼接str += "GO语言"fmt.Printf("%p %p %d\n", &str, unsafe.Pointer(stringHeader.Data), stringHeader.Len)// 字符串转 byte 切片var bytes = []byte(str)fmt.Printf("%p %p %d\n", bytes, unsafe.Pointer(stringHeader.Data), stringHeader.Len)bytes[3] = 1fmt.Println(str)// 0拷贝 byte 切片转换var bytes1 = *(*[]byte)(unsafe.Pointer(&str))fmt.Printf("%p %p %d\n", bytes1, unsafe.Pointer(stringHeader.Data), stringHeader.Len)bytes1[3] = 1fmt.Println(str)
}
0xc000026070 0x0 0
0xc000026070 0x541808 12
0xc000026070 0xc000012108 20
0xc000012120 0xc000012108 20
快速入门GO语言
0xc000012108 0xc000012108 20
快��入门GO语言
unsafe.Pointer
类似于 C 语言中的 void *
指针,能接收任意类型的指针变量转为通用型指针,再可强转为其他指针类型。
分析上述代码:字符串在赋值和拼接后,实际变量的地址没发生变化,但是 stringHeader
的 Data 字节数组改变了地址,证明字符串本身不可被修改,变的是内部的字节数组。上述进行了强转 byte
字节数组,会实际拷贝一份 string
内部的字节数组,要想实现 0 拷贝,则可通过 unsafe.Pointer
转换。
流程控制
for 循环
基本格式:
for 初始语句; 条件表达式; 结束语句 {循环体
}
for - range 循环:
- 数组、切片、字符串返回索引和值
- map返回键和值
- 通道(channel)只返回通道内的值
基本格式:
for k, v := range x {
}
常见的循环写法:
// for
func function11() {i := 1for i < 2 {fmt.Println(i)i++} // 1for j := 8; j < 9; j++ {fmt.Println(j)} // 8for {fmt.Println("loop")break} // loopfor n := 1; n <= 3; n++ {if n%2 == 0 {continue}fmt.Println(n)} // 1 3var num int
flag:num++for num <= 3 {fmt.Println(num)goto flag} // 1 2 3s := []int{11, 12}for k, v := range s {fmt.Println(k, v)} // 0 11; 1 12
}
If else 分支
// if-else
func function12() {score := 70if score < 60 {fmt.Println("不及格")} else if score >= 60 && score <= 80 {fmt.Println("良好")} else {fmt.Println("优秀")} // 良好if err := 1; err != 0 {fmt.Println("没有出错")} // 没有出错
}
switch 分支
switch 不同于 C 语言,break 不写会跳出 case,并且一个分支可以有多个值:
// switch case
func function13() {switch suf := ".a"; suf {case ".html":fmt.Println("页面")case ".doc", ".txt":fmt.Println("文档")case ".js":fmt.Println("脚本文件")default:fmt.Println("其它后缀")} // 其它后缀
}
为了兼容 C 语言的 case 设计,fallthrough
语法可以执行满足条件的 case 的下一个case:
// fallthrough
func function14() {var suf = ".doc"switch suf {case ".html":fmt.Println("页面")case ".doc":fmt.Println("文档")fallthroughcase ".js":fmt.Println("脚本文件")default:fmt.Println("其它后缀")} // 文档 脚本文件
}