Golang系列一：变量和常量

Golang系列一：变量和常量

变量

• 显式的完整声明

var varName dataType [ = value ]

• 短类型声明

varName := value

常量

Golang中常量分为布尔型、字符串型、数值型。

基本数据类型

Golang内置七类基本数据类型（20个具体子类型）
(1) 布尔类型：bool
(2) 整型：byte int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr
(3) 浮点型：float32 float64
(4) 复数：complex64 complex128
(5) 字符：rune
(6) 字符串：string
(7) 错误类型：error

• 布尔类型
  true/false，默认是false

var flag bool
flag = true

flag := false

• 整型

byte int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr

• 浮点型

b := 10.00

• 复数类型
  略

• 字符串
  (1) 访问
  可以通过类似数组的索引访问其字节单元，但是不能修改某个字节的值。

var a = "hello world"
b := a[0]

(2) 转换为切片
可以转换为字节数组，也可以转换为Unicode字数组。

a := "hello world"
b := []byte(a)
c := []rune(a)

(3) 运算

// 拼接
a := "hello"
b := "world"
c := a+b

// 获取字符串长度
len_ := len(a)
fmt.Println(len_)

// 遍历字节数组
for i:=0;i<len(c);i++{
	fmt.Println(c[i])
}

// 遍历rune数组
for i,v := range c{
	fmt.Println(i,v)
}

复合数据类型

指针

// *p和a的值都是11
var a int = 11
p := &a
fmt.Println(*p)

结构体指针

type User struct {
	name string
	age int
}
andes := User{
	name: "andes",
	age: 18,
}
p := &andes
// 通过.访问成员变量
fmt.Println(p.name)

数组

数组一般在创建时通过字面量初始化

a := [3]int{1,2,3}	// 指定长度和初始化字面量
b := [...]int{1,2,3}	// 不指定长度，但是由后面的初始化列表数量来确定其长度
c := [3]int{1:1,2:3}	// 指定总长度，并通过索引进行初始化，没有初始化元素时使用类型默认值
d := [...]int{1:1,2:3}	// 不指定总长度，通过索引值进行初始化，数值长度由最后一个索引值确定，没有指定索引的元素被初始化为类型的零值

数组的特点

(1) 数组创建完长度就固定了，不可以再追加元素；
(2) 数组是值类型的，数组赋值或作为函数参数都是值拷贝；
(3) 数组长度是数组类型的组成部分，[10]int和[20]int表示不同的类型；
(4) 可以根据数组创建切片

数组的相关操作
(1) 数组元素访问

a:=[...]int{1,2,3}
b:=a[0]
fmt.Println(b)
for i,v :=range a{
	fmt.Println(i, v)
}

(2) 数组长度

a:=[...]int{1,2,3}
alen := len(a)
for i:=0;i<alen;i++{
	fmt.Println(i, a[i])
}

切片

Golang数组的定长性和值拷贝限制了其使用场景
Golang提供了切片slice，这是一种变长数组，其数据结构中有指向数组的指针，所以是一种引用类型。

• Golang为切片维护三个元素：
  指向底层数组的指针array
  切片的元素数量
  底层数组的容量

(1) 创建方法1： 由数组创建
语法：array[b:e]

array:=[...]int{0,1,2,3,4,5,6}
// array表示数组名；
// b表示开始索引，默认是0；
// e表示结束索引，默认是len(array)
s1:= array[:4]
s2:= array[1:]
s3:= array[1:3]
fmt.Println(s1)
fmt.Println(s2)
fmt.Println(s3)

(2) 创建方法2：通过内置函数make创建
注意：各元素被默认初始化为切片元素类型的零值

// len=10, cap=10
a:=make([]int, 10)
fmt.Println(a)
// len=10, cap=15
b:=make([]int, 10, 15)
fmt.Println(b)

• 切片支持的操作
  (1) len() 返回切片的长度；
  (2) cap() 返回切片底层数组容量；
  (3) append() 对切片追加元素；
  (4) copy()复制一个切片；

a:=[...]int{0,1,2,3,4,5, 6}
b:=make([]int, 2, 4)
c:=a[0:3]

fmt.Println(len(b)) // 2
fmt.Println(cap(b)) // 4
b = append(b, 1)
fmt.Println(b) // [0 0 1]
fmt.Println(len(b))  // 3
fmt.Println(cap(b))  // 4

b = append(b, c...)
fmt.Println(b) // [0 0 1 0 1 2]
fmt.Println(len(b)) // 6
fmt.Println(cap(b)) // 8

d:=make([]int, 2, 2)
copy(d, c)
fmt.Println(d) // [0,1]
fmt.Println(len(d)) // 2
fmt.Println(cap(d)) // 2

• 字符串和切片的相互转换

str:="hello world!" // 通过字符串字面量初始化一个字符串str
a:=[]byte(str)	// 将字符串转换为[]byte类型切片
b:=[]rune(str)	// 转换为[]rune类型切片

map

字典。格式：map[K]T，其中K可以是任意可以进行比较的类型，T是值类型。
map也是一种引用类型。

• map的创建
  (1) 使用字面量创建

ma:=map[string]int{"a":1,"b":2}
fmt.Println(ma["a"])
fmt.Println(ma["b"])

(2) 使用内置make函数创建

make(map[K]T)	// map的容量使用默认值
make(map[K]T, len)	// map的容量使用给定的len值

mp1:=make(map[int]string)
mp2:=make(map[int]string, 10)

mp1[1] = "tom"
mp2[1] = "tony"

fmt.Println(mp1[1])
fmt.Println(mp2[1])

• map支持的操作
  (1) 单个键访问mapName[key]；
  (2) 使用range遍历，但是不保证每次迭代的元素顺序；
  (3) 使用delete删除键值；
  (4) len()返回map中的键值对数量。

mp := make(map[int]string)
mp[1] = "tom"
mp[2] = "pony"
mp[3] = "jack"
delete(mp, 3)

fmt.Println(mp[1])
fmt.Println(len(mp))

for k, v := range mp{
	fmt.Println("key=", k, "value=", v)
}

struct

结构由多个不同类型元素组合而成

• 创建struct
  (1) struct类型字面量(较少使用)

struct {
	FieldName FieldType
	FieldName FieldType
	FieldName FieldType
}

(2) 自定义struct类型

type TypeName struct{
	FieldName FieldType
	FieldName FieldType
	FieldName FieldType
}

(3) struct类型变量的初始化

type Person struct {
	Name string
	Age int
}

type Student struct {
	*Person
	Num int
}

// 按照类型声明顺序， 逐个赋值（不推荐，一旦struct增加字段，则整个初始化语句会报错）
//a:=Person{"Tom", 21}

// 推荐使用field名字的初始化方式，没有指定的字段默认初始化为类型零值
p := &Person{
	Name : "Jack",
	Age: 22,
}

s := Student{
	Person: p,
	Num: 100,
}