Go语言入门（四）——go语言的数据类型

bool类型

bool类型是最简单的数据类型，只有true和false两种取值，具体使用与C++中相似，下面给出示例代码，代码中涉及到格式化输出的知识：%T是输出变量的类型，%v是输出变量的值（如果是一个字符会输出字符对应的ascii码）

package main
import "fmt"

func main(){
	var a1 bool=true
	var a2 bool=false
	var b1 = true
	var b2 = false
	c1 := true
	c2 := false
	fmt.Printf("%T\t%v\n", a1, a1)
	fmt.Printf("%T\t%v\n", a2, a2)
	fmt.Printf("%T\t%v\n", b1, b1)
	fmt.Printf("%T\t%v\n", b2, b2)
	fmt.Printf("%T\t%v\n", c1, c1)
	fmt.Printf("%T\t%v\n", c2, c2)
}

整型

取值范围为整数集的类型为整型
进制
进制可以分为二进制、十进制、八进制、十六进制等，在go中在整型前面加上0则表示其为八进制，在整型前加上0x则其为十六进制。对于格式化输出%d为十进制格式输出，%b为二进制格式输出，%o和%O为八进制输出，%x和%X为十六进制输出

package main
import "fmt"

func main(){
	var a int = 10
	var b int = 077
	var c int = 0xff
	fmt.Printf("%d \n", a)
	fmt.Printf("%b \n", a)
	fmt.Printf("%o \n", b)
	fmt.Printf("%x \n", c)
	fmt.Printf("%O \n", b)
	fmt.Printf("%X \n", c)
} 

浮点型

浮点类型包括float32、float64、complex64、complex128，其中float为实数，complex为虚数

package main
import (
	"fmt"
	"math"
	)
	
func main(){
	var a1 float32=3.14
	var b1 float64=3.14
	fmt.Printf("%f\n", a1)
	fmt.Printf("%f\n", b1)
	fmt.Printf("%f\n", math.Pi)
	fmt.Printf("%.1f\n", math.Pi)
	fmt.Printf("%.2f\n", math.Pi)
	fmt.Printf("%.3f\n", math.Pi)
	fmt.Printf("%.4f\n", math.Pi)
	
	var a complex64
	var b complex128
	a = 1 + 2i
	b = 3 + 5i
	fmt.Println(a)
	fmt.Println(b)
}

常量

由于常量可以通过类型推导得出，所以定义常量可以不用写常量类型
形式

const 常量名 [常量类型] = 常量的值

常规定义
const 常量名 常量类型 = 常量值

const PI float64=3.1415926

类型推导定义
const 常量名 = 常量值

const PI = 3.1415926

批量赋值

package main
import "fmt"


func main(){
	const (
	A=32
	B=9.8
	C="hello"
	D=56
	)
	fmt.Println(A, B, C, D)
}

字符串

字符串是常用的类型，使用""表示单行字符串，使用``表示多行字符串，其中多行字符串的符号注意是键盘上1左侧的反引号，而不是单引号
字符串类型

package main

import "fmt"

func main(){
	var s1 string="hello"
	var s2="world"
	var s3=`
	hello,
	world
	`
	s4:="hello"
	fmt.Printf("%T\n", s1)
	fmt.Printf("s1:%v\n", s1)
	fmt.Printf("s2:%v\n", s2)
	fmt.Printf("s3:%v\n", s3)
	fmt.Printf("s4:%v\n", s4)
}

字符串拼接
字符串拼接可以直接用+进行，在实例中s5和s1 + “,” + s2使用的是直接用+进行拼接；使用Sprintf进行格式化拼接，Sprintf的格式与直接输出的格式相似，但是他的输出并不是输出到屏幕，而是返回一个字符串；还可以使用strings.Join进行拼接，join会先根据字符串数组的内容，计算出一个拼接之后的长度，然后申请对应大小的内存，一个一个字符串填入，在已有一个数组的情况下，这种效率会很高，但是本来没有，去构造这个数据的代价很高；拼接时可以创建一个缓冲区，然后像缓冲区写入字符串，最后以字符形式输出缓冲区即可。缓冲区对内存的增长也有优化，如果能预估字符串的长度，还可以用buffer.Grow()接口来设置容量。

package main

import (
	"fmt"
	"strings"
	"bytes"
	)

func main(){
	var s1 string="hello"
	var s2="world"

	
	s5 := s1 + s2
	s6 := fmt.Sprintf("s1:%s, s2:%s", s1, s2)
	fmt.Printf("s6:%v\n", s6)
	fmt.Printf("s5:%v\n", s5)
	fmt.Printf("%v\n", s1 + "," + s2)
	fmt.Printf("%v\n", strings.Join([]string{s1, s2}, ","))

	var buffer bytes.Buffer
	buffer.WriteString(s1)
	buffer.WriteString(",")
	buffer.WriteString(s2)
	fmt.Printf("buffer.String():%v\n", buffer.String())
}

字符串索引与切片
索引和切片的用法和python相似，但是尤为注意的是如果用%v输出索引的字符输出的是ascii码，而%c才是字符。

package main

import (
	"fmt"
	)

func main(){
	var s1 string="hello"
	fmt.Printf("ascii 1:%v, char 1:%c, 1-3:%v\n", s1[1], s1[1], s1[1:3])
}

字符串还可以用split划分成字符串数组，下面用以“，”划分为例

import (
	"fmt"
	"strings"
	)

func main(){
	s := "Hello,world"
	s1 := strings.Split(s, ",")
	fmt.Printf("%v\n", s1)
}

字符串模式匹配
string中有很多模式匹配的函数
Contains：判断字符串中是否含有某个子串
HasPrefix:判断字符串中是否以一个子串开头
HasSuffix:判断字符串中是否以一个子串结束
Index:判断第一次出现的子串的位置
LastIndex:判断最后一次出现的子串的位置

package main

import (
	"fmt"
	"strings"
	)

func main(){
	s := "Hello,world"
	fmt.Printf("Contains in:%v\n", strings.Contains(s, "Hello"))
	fmt.Printf("HasPrefix in:%v\n", strings.HasPrefix(s, "Hello"))
	fmt.Printf("HasSuffix in:%v\n", strings.HasSuffix(s, "world"))
	
	fmt.Printf("Contains not in:%v\n", strings.Contains(s, "hello"))
	fmt.Printf("HasPrefix not in:%v\n", strings.HasPrefix(s, "hello"))
	fmt.Printf("HasSuffix not in:%v\n", strings.HasSuffix(s, "World"))
	
	fmt.Printf("Index:%v\n", strings.Index(s, "l"))
	fmt.Printf("LastIndex:%v\n", strings.LastIndex(s, "l"))
}

字符串转大写和转小写

package main

import (
	"fmt"
	"strings"
	)

func main(){
	s := "Hello,world"
	s1 := strings.ToUpper(s)
	s2 := strings.ToLower(s)
	fmt.Printf("%v, %v\n", s1, s2)
}