《Go语言圣经》学习笔记：3.基础数据类型

3.1 整形

int8、int16、int32和int64
uint8、uint16、uint32和uint64

注意数值范围，避免溢出

Unicode 字符 rune 类型 和 int32 是等价的，通常用于表示一个 Unicode 码点。这两个名称可以互换使用。

byte 和 uint8 是等价的，byte 类型一般用于强调数值是一个原始的数据，而不是一个小的整数。

3.2 浮点数

Go语言提供了两种精度的浮点数，float32和float64。

用Printf函数的%g参数打印浮点数，将采用更紧凑的表示形式打印，并提供足够的精度，但是对应表格的数据，使用%e（带指数）或%f的形式打印可能更合适。所有的这三个打印形式都可以指定打印的宽度和控制打印精度。

3.3 复数

Go语言提供了两种精度的复数类型：complex64和complex128，分别对应float32和float64两种浮点数精度

内置的complex函数用于构建复数，内建的real和imag函数分别返回复数的实部和虚部：

var x complex128 = complex(1, 2) // 1+2i
var y complex128 = complex(3, 4) // 3+4i
fmt.Println(x*y)                 // "(-5+10i)"
fmt.Println(real(x*y))           // "-5"
fmt.Println(imag(x*y))           // "10"
### 3.4 布尔值
true， false

3.4 布尔值

使用起来也和其他语言没多大区别

布尔值并不会隐式转换为数字值0或1，反之亦然。必须使用一个显式的if语句辅助转换：

func btoi(b bool) int {
    if b {
        return 1
    }
    return 0
}

3.5 字符串

3.5.1 一个字符串是一个不可改变的字节序列

对字符串直接赋值操作是不允许的。但是可以进行拼接，切片。如果想要修改其内部的值可以先转换为byte或者rune切片进行修改，然后再转换为字符串格式。

s1 := "hello"
s2 := "world"
s3 := s1 + " " + s2 	// 拼接，"hello world"
s4 := "bye" + s3[5:] 	// 切片和拼接"bye world"
//s1[0] = 'x'   		// 错误，不能直接修改
s5 := []byte(s1)		// 正确修改方式
s5[0] = 'x'
s1 = string(s5)     	// "xello"

不过当涉及大量字符串拼接时，为了提高效率还是不要使用+,改用strings.Join。请看我我另外一篇的测试《Go进阶—多使用strings.Join进行字符串拼接》

3.5.2 printf参数规约

parameter	description
%d	十进制整形
%x, %o, %b	十六进制，八进制，二进制
%f, %g, %e	浮点数，大指数，科学计数形式
%t	布尔值
%c	rune (Unicode code point)
%s	string字符串
%p	指针
%v	任意值的自身值
%T	输出变量的类型
%%	literal percent sig n (no operand)
%#o/x/X	告诉Printf在用%o、%x或%X输出时生成0、0x或0X前缀。

3.5.3 字符串和数字的转换

将一个整数转为字符串，一种方法是用fmt.Sprintf返回一个格式化的字符串；另一个方法是用strconv.Itoa(“整数到ASCII”)：

x := 123
y := fmt.Sprintf("%d", x)
fmt.Println(y, strconv.Itoa(x)) // "123 123"

如果要将一个字符串解析为整数，可以使用strconv包的Atoi或ParseInt函数，还有用于解析无符号整数的ParseUint函数：

x, err := strconv.Atoi("123")             // x is an int
y, err := strconv.ParseInt("123", 10, 64) // base 10, up to 64 bits

3.5.4 类型自定义输出

在前面的自定类型中提到，可以为自定义的类型自定义一个输出字符串，每一次输出该类型的，就输出该字符串

type Student struct {
	name string
	age uint
	sex string
}
func (s Student) String() string {
	return fmt.Sprintf("name: %s, sex: %s, age: %d", s.name, s.sex, s.age)
}

func main()  {
	s := Student{"Mike", 89, "Male"}
	fmt.Println(s) 		// "name: Mike, sex: Male, age: 89"
}

3.5.5 字符串的访问

内置的 len 函数返回一个字符串的字节数目，不是rune字符数目。
所以操作 s[i] 返回第 i 个字节的字节值。
第 i 个字节不一定是字符串的第 i 个字符，因为对于非 ASCII 字符的 UTF8 编码会要两个或多个字节。

func main()  {
	s := "hello 世界"
	// 这种访问形式没有问题
	for _, val := range s {
		fmt.Printf("%c", val)
		fmt.Println(val)
	}
	// 这种情况是不可以的，当key=6的时候，确实表示的是第六个字符"世"但是s[key]却表示的是s中的第六个字节
	for key := range s {
		fmt.Printf("%c", s[key])
		fmt.Println(s[key])
	}
}

3.6 常量

• 常量的基本特点和C/C++等语言差不多，这里就不赘述
• 常量间的所有算术运算、逻辑运算和比较运算的结果也是常量，对常量的类型转换操作或以下函数调用都是返回常量结果：len、cap、real、imag、complex和unsafe.Sizeof

3.6.1 批量生成常量

如果省略初始化表达式则表示使用前面常量的初始化表达式写法，对应的常量类型也一样的。

const (
    a = 1
    b
    c = 2
    d
)

fmt.Println(a, b, c, d) // "1 1 2 2"

如果想要像其他语言一样有枚举类型的功能，那么就使用itoa

type Weekday int
const (
	Sunday Weekday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

type Flags uint
const (
	FlagUp Flags = 1 << iota // is up
	FlagBroadcast            // supports broadcast access capability
	FlagLoopback             // is a loopback interface
	FlagPointToPoint         // belongs to a point-to-point link
	FlagMulticast            // supports multicast access capability
)

func main()  {
	fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday) // 0, 1, 2, 3, 4, 5, 6
	fmt.Printf("%08b\n", FlagUp) 			//00000001
	fmt.Printf("%08b\n", FlagBroadcast)		//00000010
	fmt.Printf("%08b\n", FlagLoopback)		//00000100
	fmt.Printf("%08b\n", FlagPointToPoint)	//00001000
	fmt.Printf("%08b\n", FlagMulticast)		//00010000
}

3.6.1 无类型常量

只有常量可以是无类型的。

分别是无类型的布尔型、无类型的整数、无类型的字符、无类型的浮点数、无类型的复数、无类型的字符串。

个人理解：只要是个常量就是无类型的对象，这个对象一定有基础类型比如整形，浮点数，布尔值等。但是常量可以提供更高的精准度。

比如math包中定义了以下常量

const (
	E   = 2.71828182845904523536028747135266249775724709369995957496696763 // https://oeis.org/A001113
	Pi  = 3.14159265358979323846264338327950288419716939937510582097494459 // https://oeis.org/A000796
	Phi = 1.61803398874989484820458683436563811772030917980576286213544862 // https://oeis.org/A001622

	Sqrt2   = 1.41421356237309504880168872420969807856967187537694807317667974 // https://oeis.org/A002193
	SqrtE   = 1.64872127070012814684865078781416357165377610071014801157507931 // https://oeis.org/A019774
	SqrtPi  = 1.77245385090551602729816748334114518279754945612238712821380779 // https://oeis.org/A002161
	SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038 // https://oeis.org/A139339

	Ln2    = 0.693147180559945309417232121458176568075500134360255254120680009 // https://oeis.org/A002162
	Log2E  = 1 / Ln2
	Ln10   = 2.30258509299404568401799145468436420760110148862877297603332790 // https://oeis.org/A002392
	Log10E = 1 / Ln10
)

可以看到上面常量的精度都是很高的，但是我们将他转换为变量时候进度就会损失:

var pi float32 = math.Pi   	//3.1415927
var pi float64 = math.Pi	//3.141592653589793

本文主要参考《Go语言圣经》

撩我？
我的公众号：Kyda