Go基础语法学习总结(一)

内置类型

值类型

  • bool
  • int(32 or 64)、int8、int16、int32、int64
  • uint(32 or 64)、uint8(byte)、uint16、uint32、uint64
  • float32、float64
  • string
  • complex64、complex128 [complex:复杂的,复合的,复数类型]
  • array – 固定长度数组
类型 长度(字节) 默认值 说明
bool 1 false
byte 1 0 uint8
rune 4 0 Unicode Code Point, int32
int, uint 4或8 0 32 或 64 位
int8, uint8 1 0 -128 ~ 127, 0 ~ 255,byte是uint8 的别名
int16, uint16 2 0 -32768 ~ 32767, 0 ~ 65535
int32, uint32 4 0 -21亿~ 21亿, 0 ~ 42亿,rune是int32 的别名
int64, uint64 8 0
float32 4 0.0
float64 8 0.0
complex64 8
complex128 16
uintptr 4或8 以存储指针的 uint32 或 uint64 整数
array 值类型
struct 值类型
string “” UTF-8 字符串
slice nil 引用类型
map nil 引用类型
channel nil 引用类型
interface nil 接口
function nil 函数

其中,uint8就是我们熟知的byte型,int16对应C语言中的short型,int64对应C语言中的long型。

Go语言中以bool类型进行声明布尔型数据,布尔型数据只有true(真)false(假)两个值。

1
2
3
4
注意:
布尔类型变量的默认值为false。
Go 语言中不允许将整型强制转换为布尔型.
布尔型无法参与数值运算,也无法与其他类型进行转换。

Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(“)中的内容。

字符串的常用操作

方法 介绍
len(str) 求长度
+或fmt.Sprintf 拼接字符串
strings.Split 分割
strings.Contains 判断是否包含
strings.HasPrefix,strings.HasSuffix 前缀/后缀判断
strings.Index(),strings.LastIndex() 子串出现的位置
strings.Join(a[]string, sep string) join操作

字符

字符用单引号'包裹起来

Go 语言的字符有以下两种:

1
2
uint8类型,或者叫 byte 型,代表了ASCII码的一个字符。
rune类型,代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时,则需要用到rune类型。rune类型实际是一个int32。 Go 使用了特殊的 rune 类型来处理 Unicode,让基于 Unicode的文本处理更为方便,也可以使用 byte 型进行默认字符串处理,性能和扩展性都有照顾。

字符串底层是一个byte数组,所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成,所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符,一个rune字符由一个或多个byte组成。

数组

1
2
长度是数组类型的一部分,因此,var a[5] int和var a[10]int是不同的类型。
指针数组 [n]*T,数组指针 *[n]T

值拷贝行为会造成性能问题,通常会建议使用 slice,或数组指针。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main
import (
"fmt"
)
func test(x [2]int) {
fmt.Printf("x: %p\n", &x)
x[1] = 1000
}
func main() {
a := [2]int{}
fmt.Printf("a: %p\n", &a)
test(a)
fmt.Println(a)
}

输出结果:

1
2
3
a: 0xc42007c010
x: 0xc42007c030
[0 0]

数组遍历

1
2
3
4
for i := 0; i < len(a); i++ {
}
for index, v := range a {
}

数组初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 全局
var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}

// 局部
a := [3]int{1, 2} // 未初始化元素值为 0。
b := [...]int{1, 2, 3, 4} // 通过初始化值确定数组长度。
c := [5]int{2: 100, 4: 200} // 使用索引号初始化元素。
d := [...]struct {
name string
age uint8
}{
{"user1", 10}, // 可省略元素类型。
{"user2", 20}, // 别忘了最后一行的逗号。
}

引用类型(指针类型)

  • slice – 序列数组(最常用)
  • map – 映射
  • chan – 管道

map

map是一种无序的基于key-value的数据结构,Go语言中的map是引用类型,必须初始化才能使用。

Go语言中 map的定义语法如下

1
map[KeyType]ValueType

其中:

KeyType:表示键的类型 ValueType:表示键对应的值的类型

map类型的变量默认初始值为nil,需要使用make()函数来分配内存。语法为:

1
make(map[KeyType]ValueType, [cap])

其中cap表示map的容量,该参数虽然不是必须的,但是我们应该在初始化map的时候就为其指定一个合适的容量。

map也支持在声明的时候填充元素,例如:

1
2
3
4
5
6
7
func main() {
userInfo := map[string]string{
"username": "pprof.cn",
"password": "123456",
}
fmt.Println(userInfo)
}

Go语言中有个判断map中键是否存在的特殊写法,格式如下:

1
value, ok := map[key]

使用delete()内建函数从map中删除一组键值对,delete()函数的格式如下:

1
2
3
delete(map, key)
# map:表示要删除键值对的map
# key:表示要删除的键值对的键

内置函数

Go语言拥有一些不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作,例如:len、cap 和 append,或必须用于系统级的操作,例如:panic。因此,它们需要直接获得编译器的支持。

  • append – 用来追加元素到数组、slice中,返回修改后的数组、slice
  • close – 主要用来关闭channel
  • delete – 从map中删除key对应的value
  • panic – 停止常规的goroutine (panic和recover:用来做错误处理)
  • recover – 允许程序定义goroutine的panic动作
  • real – 返回complex的实部 (complex、real imag:用于创建和操作复数)
  • imag – 返回complex的虚部
  • make – 用来分配内存,返回Type本身(只能应用于slice, map, channel)
  • new – 用来分配内存,主要用来分配值类型,比如int、struct。返回指向Type的指针
  • cap – capacity是容量的意思,用于返回某个类型的最大容量(只能用于切片和 map)
  • copy – 用于复制和连接slice,返回复制的数目
  • len – 来求长度,比如string、array、slice、map、channel ,返回长度
  • print、println – 底层打印函数,在部署环境中建议使用 fmt 包

内置接口error

1
2
3
type error interface { //只要实现了Error()函数,返回值为String的都实现了err接口
Error() String
}
有用就打赏一下作者吧!