Go数据类型

整型
　　整型分为以下两个大类： 按长度分为：int8(byte)、int16、int32、int64,对应的无符号整型：uint8、uint16、uint32、uint64

特殊整型

package main
import (
	"fmt"
	"unsafe"
)
func main() {
	//定义有符号8位整型
	var i int8 = 127
	var i2 = 255
	fmt.Println(i)
	//打印变量类型
	fmt.Printf("i 数值类型%T\n", i)
	//打印变量大小
	fmt.Printf("i2 数值占用字节数%d", unsafe.Sizeof(i2))
}
结果
127
i 数值类型int8
i2 数值占用字节数8

注意：

　　在使用int和uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。
注意事项:
　　获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或map的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和uint。

 

数字字面量语法
　　以二进制、八进制或十六进制浮点数的格式定义数字

func main() {
//十进制
	var a int = 10
	fmt.Printf("%d \n",a)
	fmt.Printf("%b \n",a)	//%b二进制

	var b int = 077
	fmt.Printf("%o \n",b)	//%o八进制(0开头)

	var c int = 0xff
	fmt.Printf("%x \n",c)	//%x十六进制(以0x开头)
	fmt.Printf("%X \n",c)
}
结果
10 
1010 
77 
ff 
FF

#进制转换
package main
import "fmt"
func main() {
	//十进制
	var v1 = 101
	fmt.Printf("%d\n",v1)
	//十进制转而进制
	fmt.Printf("%b\n",v1)
	//十进制转八进制
	fmt.Printf("%o\n",v1)
	//十进制转十六进制
	fmt.Printf("%x\n",v1)
	//八进制
	v2 := 077
	fmt.Printf("%d\n",v2)
	//十六进制
	v3 := 0x12345
	fmt.Printf("%d\n",v3)
}
结果
101
1100101
145
65
63
74565

浮点型

Go语言支持两种浮点型数：float32和float64。
　　float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。
　　float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。
　　打印浮点数时，可以使用fmt包配合动词%f,float32为单精度,可能有损失,float64为双精度,精度比float32高,默认float64的类型。

package main
import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("%f\n", math.Pi)
	fmt.Printf("%.2f\n", math.Pi)

}
结果
3.141593
3.14

复数略过..............

 

布尔值

　　以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。
注意：
　　布尔类型变量的默认值为false。
　　Go 语言中不允许将整型强制转换为布尔型.
　　布尔型无法参与数值运算，也无法与其他类型进行转换。

package main
import "fmt"
func main() {
	b1 := true
	var b2 bool
	fmt.Printf("%T\n", b1)
	fmt.Printf("%T value: %v\n", b2, b2)
}
结果
bool
bool value: false

字符串

单引号的是字符
双引号是字符串
Go中字符串都是utf-8编码,一个汉字占3字节

package main
import "fmt"
func main() {
	v1 := "hello"
	v2 := "beijing"
	fmt.Println(v1, v2)
}
结果
hello beijing

字符占位符

%v	相应值的默认格式
%+v	打印结构体时，会添加字段名
%#v	相应值的Go语法表示
%T	相应值的类型的Go语法表示
%%	字面上的百分号，并非值的占位符


package main
import "fmt"
func main() {
	var	Name string = "zhangsan"
	fmt.Printf("%v\n", Name)
	fmt.Printf("%+v\n", Name)
	fmt.Printf("%#v\n", Name)
	fmt.Printf("%T\n", Name)
}
结果
zhangsan
zhangsan
"zhangsan"
string

字符串转义

package main
import "fmt"
func main()  {
    fmt.Println("姓名\t年龄\t籍贯\t住址\njrey\t18\t北京\t河南")
}


package main
import "fmt"
func main()  {
    fmt.Println("tomcat\tbob")
    fmt.Println("tomcat\nbob")
    fmt.Println("tomcat\\bob")
    fmt.Println("tomcat \"bob\"")
    //从当前行开头输出,覆盖掉开头的字符
    fmt.Println("tomcat\rbob")
}
结果
tomcat	bob
tomcat
bob
tomcat\bob
tomcat "bob"
tomcat
bob


#字符串使用及拼接
package main
import "fmt"
func main() {
	var a = 1
	var b = 2
	// 当左右两边是数值,做数值运算
	fmt.Println(a + b)
	// 当左右两边都是字符串,做字符串拼接
	v1,v2 := "hello","ShangHai"
	fmt.Println(v1 + v2)
}
结果
3
helloShangHai

package main
import (
	"fmt"
	"strconv"
	"strings"
)
var s1 = "hello"
var s2 = "zhangsan-lisi-wangwu"
func main() {
	//统计字符串长度
	fmt.Println(len(s1))
	//字符串切割
	s3 := strings.Split(s2, "-")
	fmt.Println(s3)
	//字符串拼接
	fmt.Println(strings.Join(s3, ""))
	//字符串转换
	s4 := strconv.Itoa(123) + "hehe"
	fmt.Println(s4)
	s5, err := strconv.Atoi("12000")
	fmt.Println(s5)
	fmt.Println(err)
}
结果
5
[zhangsan lisi wangwu]
zhangsanlisiwangwu
123hehe
12000
<nil>


package main
import (
	"fmt"
	"strings"
)
func main() {
	s1 := `D:\Adobe\Esl`
	s2 := `aaa`
	//统计长度
	fmt.Println(len(s1))
	//字符串拼接
	fmt.Println(s1 + s2)
	//字符串赋值
	s3 := fmt.Sprintf("%s%s", s1, s2)
	fmt.Println(s3)
	//字符串切割
	ret := strings.Split(s3, "\\")
	fmt.Println(ret)
	//包含
	fmt.Println(strings.Contains(s3, "Adobe"))
	//前缀
	fmt.Println(strings.HasPrefix(s3, "D"))
	//后缀
	fmt.Println(strings.HasSuffix(s3, "aaa"))
	//打印字母的索引位置
	fmt.Println(strings.Index(s3, "a"))
	//打印最后一个匹配的字母索引位置
	fmt.Println(strings.LastIndex(s3, "a"))
	//拼接
	fmt.Println(strings.Join(ret, "+"))
}
结果
12
D:\Adobe\Eslaaa
D:\Adobe\Eslaaa
[D: Adobe Eslaaa]
true
true
true
12
14
D:+Adobe+Eslaaa

byte和rune类型

　　组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（'）包裹起
Go语言的字符有以下两种：
　　uint8类型，或者叫byte型，代表了ASCII码的一个字符。
　　rune类型，代表一个UTF-8字符。
当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
　　Go使用了特殊的rune类型来处理Unicode，让基于Unicode的文本处理更为方便，也可以使用byte型进行默认字符串处理，性能和扩展性都有照顾
　　字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的字符串是由byte字节组成，所以字符串的长度是byte字节的长度。rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。
修改字符串
　　要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

package main
import "fmt"
func main() {
	//字符常量
	var c1 byte = 'a'
	var c2 byte = '0'
	//打印的是accis码对应的码值
	fmt.Println(c1, c2)
	//打印对应的值
	fmt.Printf("c1=%c c2=%c", c1, c2)
}
结果
97 48
c1=a c2=0


package main
import "fmt"
func main() {
	s1 := "白萝卜"
	s2 := []rune(s1)
	s2[0] = '红'
	fmt.Println(string(s2))
	c1 := "红"
	c2 := '红'
	fmt.Printf("c1:%T c2:%T\n", c1, c2)
}
结果
红萝卜
c1:string c2:int32

类型转换
T(表达式)
T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等

package main
import "fmt"
func main() {
	n := 10
	var f float64
	f = float64(n)
	fmt.Println(f)
	fmt.Printf("%T\n", f)
}
结果
10
float64

编写代码分别定义一个整型、浮点型、布尔型、字符串型变量，使用fmt.Printf()搭配%T分别打印出上述变量的值和类型。

package main
import "fmt"
func main() {
	s1 := 10
	s2 := 2.13
	s3 := true
	s4 := "aaaaa"
	fmt.Printf("%T %v\n",s1,s1)
	fmt.Printf("%T %v\n",s2,s2)
	fmt.Printf("%T %v\n",s3,s3)
	fmt.Printf("%T %v\n",s4,s4)
}