Go语言的基本类型有:整形、浮点型、布尔型、字符串,还有切片、结构体、函数、map、通道等。
整形
整形分为以下两大类
- 按长度分为:int8,int16,int32,int64
- 对应的无符号整型:uint8,uint16,uint32,uint64.
其中uint8就是byte类型,int16对应c中的short型,int64对应c语言中的long型。
自动匹配平台的int和uint
Go语言有自动匹配特定平台整形长度的类型-int和uint。
在使用int和uint时,不能假定它是32位和64位的整形,而是考虑int和uint可能在不同平台上的差异。
那些情况下使用int和uint
逻辑对整型范围没有特殊要求时使用。
在二进制传输,读写文件的结构描述时,为了保持文件的结构不会收到不同编译目标平台字节长度的影响,不要使用int和uint。
浮点型
Go语言提供了两种精度的浮点数 float32 和 float64
这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到:
- 常量 math.MaxFloat32 表示 float32 能取到的最大数值,大约是 3.4e38;
- 常量 math.MaxFloat64 表示 float64 能取到的最大数值,大约是 1.8e308;
- float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324。
浮点数会有一个精度的限制。所以应该优先使用float64,比如以下程序
package main
import "fmt"
func main() {
var f float32 = 1677721666 // 1 << 24
fmt.Println(f)
fmt.Println(f + 1)
fmt.Println(f == f+1) // "true"!
}
结果:
1.6777217e+09
1.6777217e+09
true
会有精度的丢失,输出结果为true
使用float64则正常
package main
import "fmt"
func main() {
var f float64 = 1677721666 // 1 << 24
fmt.Println(f)
fmt.Println(f + 1)
fmt.Println(f == f+1) // "true"!
}
结果:
1.677721666e+09
1.677721667e+09
false
浮点数在声明的时候可以只写整数部分或者小数部分
package main
import "fmt"
func main() {
const e = .71828 // 0.71828
const f = 1. // 1
fmt.Println(e, f)
}
结果:
0.71828 1
可以使用科学记数法记录很小或者很大的数,通过e或来制定指数部分。
const Avogadro = 6.02214129e23 // 阿伏伽德罗常数
const Planck = 6.62606957e-34 // 普朗克常数
fmt.Println(e, f)
fmt.Println(Avogadro, Planck)
结果:
6.02214129e+23 6.62606957e-34
用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}
结果:
3.141593
3.14
复数
在计算机中,复数是由两个浮点数表示的,其中一个表示实部(real),一个表示虚部(imag)。
Go语言中复数的类型有两种,分别是 complex128(64 位实数和虚数)和 complex64(32 位实数和虚数),其中 complex128 为复数的默认类型。
复数的值由三部分组成 RE + IMi,其中 RE 是实数部分,IM 是虚数部分,RE 和 IM 均为 float 类型,而最后的 i 是虚数单位。
复数的声明
package main
import "fmt"
func main() {
var a complex128 = complex(6, 9)
fmt.Println(a)
}
结果:
(6+9i)
也可以通过下面的方式申请
b := complex(9, 8)
fmt.Println(b)
fmt.Println(real(b))
fmt.Println(imag(b))
对于一个复数z := complex(x, y)
,可以通过Go语言的内置函数real(z)
来获得该复数的实部,也就是 9;通过imag(z)
获得该复数的虚部,也就是 8。
复数也可以用==
和!=
进行相等比较,只有两个复数的实部和虚部都相等的时候它们才是相等的。
布尔型
布尔型数据在Go语言中意bool类型进行声明,布尔类型数据只有ture和false两个值
一元操作符!对应逻辑非操作,因此!true
的值为 false
package main
import "fmt"
func main() {
var a int = 5
var b int = 10
fmt.Println(a != b)//true
}
布尔值可以和 &&(AND)和 ||(OR)操作符结合,并且有短路行为,如果运算符左边的值已经可以确定整个布尔表达式的值,那么运算符右边的值将不再被求值
&&
的优先级高于 ||
布尔型无法参与数值运算,也无法与其他类型进行转换
字符串
字符串在Go语言中以原生数据类型出现,使用字符串就像使用其他原生数据类型一样。
字符串的值为双引号的内容,可以在Go语言的源码中直接添加非ASCII码字符,代码如下:
import "fmt"
func main() {
str := "hello go"
ch := "中文"
fmt.Println(str, ch)
}
字符串转义符
转移符 | 含义 |
---|---|
\r | 回车符 |
\n | 换行符 |
\t | 制表符 |
’ | 单引号 |
" | 双引号 |
\ | 反斜杠 |
fmt.Println("str=\"c:\\go\\bin\\go.exe\"")
结果:
str="c:\go\bin\go.exe"
可以使用``括起来多行字符串,进行原样输出。
在`间的所有代码都不会被编译器识别,而是作为字符串的一部分。
字符
字符串中的每一个元素叫做“字符”,在遍历或者单个获取字符串元素时可以获得字符。
Go语言的字符有以下两种:
- 一种是 uint8 类型,或者叫 byte 型,代表了 ASCII 码的一个字符。
- 另一种是 rune 类型,代表一个 UTF-8 字符,当需要处理中文、日文或者其他复合字符时,则需要用到 rune 类型。rune 类型等价于 int32 类型。
byte 类型是 uint8 的别名,对于只占用 1 个字节的传统 ASCII 编码的字符来说,完全没有问题,例如 var ch byte = ‘A’,字符使用单引号括起来
使用fmt.Printf中的“%T”动词可以输出变量的实际类型
package main
import "fmt"
func main() {
var a byte = 'a'
var b rune = '你'
fmt.Printf("%d, %T \n", a, a)
fmt.Printf("%d, %T", b, b)
}
结果:
97, uint8
20320, int32