Golang-基础知识小结（二）

Golang-基础知识小结（二）

基本数据类型

整型：1. 有符号整型 int8(-128 到 127)、int16(-32768 到 32767)、int32 (-2147483648 到 2147483647)、int64 (-9223372036854775808 到 9223372036854775807)

​ 2.无符号整型uint8(0 到 255)、uint16(0 到 65535)、uint32(0 到 4294967295)、uint64(0 到 18446744073709551615)

​ 3.特殊整型uint、int、uintptr

注1：1.uint8即为byte型，int16对应C语言中的short型，int64对应C语言中的long型；涉及二进制传输或文件读写时，为了保持文件的结构不受到不同编译目标平台字节长度的影响，不要使用 int 和 uint。

注2：uint/int，在32位系统上为uint32/int32，在64位系统上为uint64/int64；uintptr为无符号整型，用来存放指针

示例：Go语言打印不同进制的整型数

func main() {
	var num1 int = 20
	fmt.Printf("%d \n", num1) //打印十进制数 20
	fmt.Printf("%b \n", num1) //打印二进制数 10100

	var num2 int = 07777      //八进制数，以‘0’开头
	fmt.Printf("%o \n", num2) //打印八进制数 7777

	var num3 int = 0xffff
	fmt.Printf("%x \n", num3) //小写十六进制 ffff
	fmt.Printf("%X \n", num3) //大写十六进制 FFFF
}

浮点型：1.float32(最大范围约为3.4e38)

​ 2.float64(最大范围约为1.8e308)

示例：Go语言打印浮点数

func main() {
	var complex1 complex64
	var complex2 complex128
	complex1 = 11 + 2i
	complex2 = 12 + 3i
	fmt.Println(complex1) //(11+2i)
	fmt.Println(complex2) //(12+3i)
}

复数：1.complex64(实部和虚部为32位)

​ 2.complex128(实部和虚部为64位)

示例：Go语言打印复数

func main() {
	var complex1 complex64
	var complex2 complex128
	complex1 = 11 + 2i
	complex2 = 12 + 3i
	fmt.Println(complex1) //(11+2i)
	fmt.Println(complex2) //(12+3i)
}

布尔量：布尔型数据类型只有2个值，true和false。

注：1.默认值为false；2.Go语言不允许将整型强转为布尔类型；布尔型不能参与数值运算，也不能与其他类型转换。

字符串：1.Go语言中以原生类型出现，string ；2.Go语言的字符串的内部实现使用UTF-8编码；3.可以在Go语言中直接添加非ASCII码字符。

示例：Go语言中字符串的基本操作

import (
	"fmt"
	"strings"
)

func main() {
	// 字符串的基本操作
	//定义
	s1 := "golang"
	s2 := "语言"

	//拼接
	s3 := s1 + s2 //拼接方式一
	fmt.Printf("s3=%s \n", s3)
	s4 := fmt.Sprintf("%s%s", s2, s1) //拼接方式二
	fmt.Printf("s4=%s \n", s4)

	//求长度
	fmt.Printf("s3's len=%d \n", len(s3))

	path := "D:\\Go\\src\\bin"                               //定义一个Windows下的文件路径
	fmt.Printf("path's type is %T, path=%#v \n", path, path) //path's type is string, path="D:\\Go\\src\\github.com"

	//分割
	ss := strings.Split(path, "\\")
	fmt.Printf("%#v \n", ss) //[]string{"D:", "Go", "src", "bin"}

	//判断包含
	r := strings.Contains(path, "src")
	if r == true {
		fmt.Println("Contain src.  ")
	} else {
		fmt.Println("Do not contain src.")
	}

	//判断前缀
	r = strings.HasPrefix(path, "D")
	if r == true {
		fmt.Println("Prefix is D.")
	} else {
		fmt.Println("Prefix is not D.")
	}

	//判断后缀
	r = strings.HasSuffix(path, "bin")
	if r == true {
		fmt.Println("Suffix is bin.")
	} else {
		fmt.Println("Suffix is not bin.")
	}

	//获取子串位置
	fmt.Printf("src index=%d \n", strings.Index(path, "src"))         //src index=6
	fmt.Printf("src lastIndex=%d \n", strings.LastIndex(path, "src")) //src lastIndex=6

	//join
	str := strings.Join(ss, "+") //D:+Go+src+bin
	fmt.Println(str)

}

byte类型：实际为uint8类型，代表一个ASCII码字符。

run类型：实际为int32类型，代表一个UTF-8字符。一般需要处理中文、日文等其他复合字符时，使用rune类型。处理Unicode的文本时，使用rune类型相比byte类型相对更为方便。

示例：byte与rune

func main() {
	//[]byte操作
	str1 := "pig"
	byteStr1 := []byte(str1)                   //强制类型转换：string转[]byte
	byteStr1[0] = 'b'                          //设置[]byte首个元素
	fmt.Printf("str1=%s \n", string(byteStr1)) //str1=big  强制类型转换：[]byte转string

	//[]rune操作
	str2 := "大白兔"
	runeStr2 := []rune(str2)                   //强制类型转换,string转[]rune
	runeStr2[0] = '小'                          //设置[]rune首个元素
	fmt.Printf("str2=%s \n", string(runeStr2)) // str2=小白兔 强制转换类型：[]rune转string
}

强制类型转换:T(表达式)

注：T为要转换的类型，表达式可为变量、算式和函数返回值等。

func main() {
	//强制转换
	var f float64 = 3.14
	var i int64 = int64(f)

	fmt.Printf("f=%f, i=%d \n", f, i) //f=3.140000, i=3 
}