Day5 Type

Background

对於变数的Type，能够依据他们的特性分为两种，分别为不可变的Static type以及可变的 Dynamic type。

静态型别 Static type: 静态型别是宣告变数时指定的型别，指的是一个变数的型别是永恒不变的，一般的普通变数只有静态型别。
动态型别 Dynamic type:动态型别是由介面型别变数赋值的具体值的型别来决定的，且除了动态型别外还有着动态值，这两者彼此是相对应的。之所以被称作动态型别，是因为介面型别的动态型别是会变化的。

而这章节主要就是介绍静态型别，像是Boolean、String....等。

Boolean 布林

长度1bit，只能拿来当作true, false使用。

且在Go中Bool不能当作0或1使用(不能与数字作比较)

func main() {
	var b bool = false
	fmt.Println(b)
	if b == false{
		fmt.Println("b == false")
	}
}

运算後会得结果

false
b == false

Numbers 数字

数字可以根据长度与浮点数等因素有着各种不同的型态，像是int、float等。

Int

int8, int16, int32, int64

看名字就知道int後头的数字代表的是长度bit

举例来说8bit表示排列组合有着2的八次方⇒ 256种可能性，这也就是一个byte的大小，

因此256种可能性会从-128 ~ 127

下面有个错误的范例

package main

import (
	"fmt"
)

func main() {
	var a int8 = 128;
	fmt.Print(a)
}

运算後会得结果

# command-line-arguments
./variables.go:7:6: constant 128 overflows int8

uint

uint8, uint16, uint32, uint64

和int相同，但unsigned就是没正负号意思。

如果是uint8则可以存在256种可能性0~255)

package main

import (
	"fmt"
)

func main() {
	var a uint8 = 128;
	fmt.Print(a)
}

运算後会得结果

float

float32, float64

通常都是拿精准度较高的float64做使用，

毕竟小数点会有误差，使用float32误差会比float64来得大。

此外，Go语言当中并没有double

complex

complex64, complex128

复数，较少用到，不过内建有这种型别运算时十分方便。

package main

import (
	"fmt"
)

func main()  {
	var a complex64 = 2.4 + 3i
	fmt.Print(a)
}

运算後会得结果

(2.4+3i)

Char 字串

Go当中没有char的型别。

通常以string 或是 rune 来代替

string

package main

import (
	"fmt"
)

func main() {
	var s string = "Hello World"
	fmt.Println(s)
}

运算後会得结果

Hello World

要注意的是，string中的字无法改变那怎麽办？常见办法有以下：

用string[0:1]直接串文字
用fmt.Sprint()串文字
用Slice[] Append方法来接文字

由於string中的文字没办法改，要创新的变数来接收。

rune

rune意思是符号，简单理解为UTF-8中的一个符号。

因为Go语言中预设使用UTF-8编码。

而UTF-8编码中的每个字元长度不是固定，以8bit为基本长度，范围为1~4个字节(1byte ~ 4bytes)

package main

import (
	"fmt"
)

func main()  {
	var r = []rune("0")
	fmt.Println(r)

	r = []rune("Hello World")
	fmt.Println(r)
}

运行後可得结果

[48]
[72 101 108 108 111 32 87 111 114 108 100]

长度怎麽算

长度到底是算符号数还是byte数？

func main() {
	a := "哈罗 世界"
	fmt.Println(a)
	n := 0
	for range a{
		n++
	}
	fmt.Println(len(a))
	fmt.Println(n)
}

运行後可得结果

哈罗 世界
13
5

运行後可得知，以for range迭代出的长度，就是以bytes计算，

而len()打印出的长度则是符号数，每个文字只算一个

byte

byte用法非常多，通常会配合Slice[]使用。

package main

import (
	"fmt"
)

func main()  {
	var b = []byte("0")
	fmt.Println(b)

	b = []byte("Hello World")
	fmt.Println(b)
}

运行後可得

[48]
[72 101 108 108 111 32 87 111 114 108 100]

这边看起来byte好像跟rune很类似，但是

package main

import (
	"fmt"
)

func main()  {
	var a = []byte("哈罗 世界")
	fmt.Println(a)

	var b = []rune("哈罗 世界")
	fmt.Println(b)
}

运行後可得结果

[229 147 136 229 155 137 32 228 184 150 231 149 140]
[21704 22217 32 19990 30028]

与上述一样，rune所记录的是每个字元的记忆体位置而非bytes数。

C vs Go

这边附上C语言与Go类型对比

C	Go
char	byte
singed char	int 8
unsigned char	uint8
short	int16
unsigned short	uint16
int	int32
unsigned int	uint32
long	int32
unsigned long	uint32
long long int	int64
unsigned long long int	uint64
float	float32
double	float64
size_t	uint

虽然C语言的int固定长度为4，但Go语言自己类型的int与uint在32位与64位下分别对应长度为4与8个字节，这是需要注意的一点。

正规表示法 Regular Expression

最後则提及一下Go的正规表示法如何使用，它主要是透过内建包regexp来做实作，下面我们就举个范例来说明

package main
import (
    "fmt"
    "regexp"
)
func main() {
    buf := "abc azc a1c aac aab a3c bac"

    reg1 := regexp.MustCompile(`a[0-9]c`)
    if reg1 == nil {
        fmt.Println("regexp err")
        return
    }
    
    result := reg1.FindAllStringSubmatch(buf, -1)
    fmt.Println("result = ", result)
}

运行後可得结果