Go语言之数据类型详解

(1)类型：

2.1变量：使用var定义变量,类型放在变量名之后。

使用简短模式的限制：

1.定义变量，同时显示初始化

2.不能提供数据类型

3.只能用在函数内部

package main

import (

"fmt"

)

func main() {

var x int

//自动初始化

var y = false

//自动推断数据类型

var x1,y1 int

//定义多个类型相同的变量

var (

x2,y2 int

z1,z2,z3 float32

)

//使用组合方式

num := 12

num2 := 12.3

fmt.Println(x)

fmt.Println(y)

fmt.Println(x1)

fmt.Println(y1)

fmt.Println(x2,y2)

fmt.Println(z1,z2,z3)

fmt.Println(num)

fmt.Println(num2)

}

/*输出结果：

0

false

0

0

0 0

0 0 0

12

12.3

*/

2.2多变量赋值：首先会计算出所有的右值，在完成赋值操作。

命名规范：

1.以字母或者是下划线开始

2.区分大小写

3.使用驼峰命名法

4.局部变量优先使用短名

5.专有名词使用大写

2.3空标识符：

Go中存在“_”，通常作为忽略占位符使用。

空标识符可以用来临时避免编译器对未使用变量和导入包的错误检查。

2.4常量：不支持C/C++中的数字类型。使用const定义常量

package main

import (

"fmt"

)

func main() {

x,y := 1,2

fmt.Println(x,y)

const NUM = "Hello World!"

//定义常量

fmt.Println(NUM)

const (

NUM_0 = 12

NUM_1 = "Haha"

NUM_2 byte = 12

NUM_3 int = 111

)

fmt.Println(NUM_0,NUM_1,NUM_2,NUM_3)

}

/*输出结果：

1 2

Hello World!

12 Haha 12 111

*/

2.5枚举：Go中并没有明确意义的枚举类型，可通过iota标识符实现一组自增常量实现枚举类型。如果iota自增长被打断，必须显式恢复。默认iota的数据类型是int，

可以显示指定数据类型。

常量通常会被编译器在预处理阶段直接展开作为指令数据使用。

package main

import "fmt"

func main() {

const (

a = iota

b

c

d float32 = 12.3

e = iota

f

)

fmt.Println(a,b,c,d,e,f)//0 1 2 12.3 4 5

}

标准库中math中定义了各个数字类型的取值范围。

标准库中strconv可以在不同进制之间进行转换。

使用浮点数时，需要注意小数位的有效精度。

package main

import (

"fmt"

"math"

"strconv"

)

func main() {

fmt.Println(math.MinInt8,math.MaxInt8)

a,b,c := 100,0144,0x64

fmt.Printf("0b%b, %#o, %#x\n",a,a,a)

fmt.Println(a,b,c)

d,_ := strconv.ParseInt("1100100",2,32)

e,_ := strconv.ParseInt("0144",8,32)

f,_ := strconv.ParseInt("64",16,32)

fmt.Println(d,e,f)

}

/*输出结果：

-128 127

0b1100100, 0144, 0x64

100 100 100

100 100 100

*/

2.6别名：Go中提供了专门的别名。

byte alias for uint8

rune alias for int32

别名类型无序转换，可以直接赋值，但是并不是拥有相同的底层结构就属于别名。

2.7引用类型：指的是slice/map/channel

内置函数new按照指定类型长度分配零值内存，返回指针。

引用类型使用make函数创建。

除了使用new/make函数外，也可以使用初始化表达式，编译器生成的指令基本相同。

当new函数为引用类型分配内存的时候，仅仅是分配了字典类型本身所需的内存，没有初始化散列桶等内部属性。

2.8类型转换：

Go强制使用显式类型转换，同样不能将非bool类型结果当做true/false使用。

如果转换的目标是指针、单向通道或者是没有返回值的函数类型，那么必须使用括号。

2.9自定义类型：

type用来自定义数据类型，多个type可以组合成为组。

package main

import (

"fmt"

)

func main() {

type (

user struct {//结构体类型

name string

age int

}

event func(string) bool//函数类型

)

u := user{"tomcat",20}

fmt.Print(u)

f := func(s string) bool{

fmt.Println(s)

return s != ""

}

f("abc")

}

/*输出结果：

{tomcat 20}abc

*/

即便是指定的基础类型是相同的，也是只是表明他们拥有底层的数据结构，但是这是不同的数据类型。，自定义类型不会继承基础类型的其他信息。

2.10未命名类型：

数组、切片、字典、通道等类型是与具体元素类型或者是长度等属性有关叫做未命名类型。

具有相同的基础类型的指针。

具有相同元素类型和长度的数组。

具有相同元素类型的切片。

具有键值类型的字典。

具有数据类型及操作方向的通道。

具有相同字段序列(字段名、字段类型、标签、字段顺序)的结构体。

具有相同签名(参数和返回值列表、不包括参数名称)的函数。

具有相同方法集(方法名、方法签名、顺序)的接口。