有符号整形数类型:
int8,长度:1字节, 取值范围:(-128 ~ 127)
int16,长度:2字节,取值范围:(-32768 ~ 32767）
int32,长度:4字节,取值范围:(-2,147,483,648 ~ 2,147,483,647）
int64.长度:8字节,取值范围:(-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807)
无符号整形数类型:
uint8,长度:1字节, 取值范围:(0 ~ 255)
uint16,长度:2字节,取值范围:(0 ~ 65535)
uint32,长度:4字节,取值范围:(0 ~ 4,294,967,295)
uint64.长度:8字节,取值范围:(0 ~ 18,446,744,073,709,551,615)
浮点型。float32 精确到小数点后 7 位，float64 精确到小数点后 15 位。由于精确度的缘故，你在使用 == 或者 != 来比较浮点数时应当非常小心。
浮点型（IEEE-754 标准）:
float32:（+- 1e-45 -> +- 3.4 * 1e38）32位浮点类型
float64:（+- 5 1e-324 -> 107 1e308）64位浮点类型
浮点型中指数部分由"E"或"e"以及带正负号的10进制整数表示。例:3.9E-2表示浮点数0.039。3.9E+1表示浮点数39。 有时候浮点数类型值也可以被简化。比如39.0可以被简化为39。0.039可以被简化为.039。在Golang中浮点数的相关部分只能由10进制表示法表示
复数类型:
complex64: 由两个float32类型的值分别表示复数的实数部分和虚数部分
complex128: 由两个float64类型的值表示复数的实数部分和虚数部分
复数类型的值一般由浮点数表示的实数部分、加号"+"、浮点数表示的虚数部分以及小写字母"i"组成，例如：
var x complex128 = complex(1,2) //1+2i
对于一个复数 c = complex(x, y) ，可以通过Go语言内置函数 real(z) 获得该复数的实 部，也就是 x ，通过 imag© 获得该复数的虚部，也就是 y
在Go语言中，布尔值的类型为 bool，值是 true 或 false,布尔可以做3种逻辑运算，&&（逻辑且），||（逻辑或），！（逻辑非）,布尔类型的值不支持其他类型的转换.
布尔值可以和&&(AND)和||(OR)操作符结合,并且可能会有短路行为:如果运算符左边值已经可以确定整个布尔表达式的值,那么运算符右边的值将不在被求值,
字符串是不可变的字节序列，它可以包含任意数据，包括0值字节，但是主要还是为了人可读的文本。内置的 len()函数返回字符串的字节数
数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。由于数组的长度是固定的，因而在使用的时候我们用的最多的是slice（切片），它是可以增长和收缩动态序列，slice功能也更灵活，但是要理解slice工作原理的话需要先理解数组
申明数组
var variable_name [SIZE] variable_type
var balance [10] float32
初始化数组
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
通过字面量在声明数组的同时快速初始化数组
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
果数组长度不确定，可以使用 … 代替数组的长度，编译器会根据元素个数自行推断数组的长度
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果设置了数组的长度，我们还可以通过指定下标来初始化元素
// 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}
Slice(切片)代表变长的序列,序列中每个元素都有相同的类型。一个slice类型一般写作[]T,其中T代表slice中元素的类型;slice的语法和数组很像,只是没有固定长度而已
arrVar := [4]int{1, 2, 3, 4}
s1 := arrVar[1:3] //s := arr[startIndex:endIndex] 将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片
s2 := arrVar[1:] //s := arr[startIndex:] 默认 endIndex 时将表示一直到arr的最后一个元素
s3 := arrVar[:2] //s := arr[:endIndex] 默认 startIndex 时将表示从 arr 的第一个元素开始
fmt.Println(s1) //输出结果[2 3]
fmt.Println(s2) //输出结果[2 3 4]
fmt.Println(s3) //输出结果[1 2]
func main() {
var numbers = make([]int, 3, 5)
printSlice(numbers)
}
func printSlice(x []int) {
fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
//输出结果 len=3 cap=5 slice=[0 0 0]
和数组不同的是, slice之间不能比较,因此我们不能使用==操作符来判断两个slice是否含有全部相等元素。不过标准库提供了高度优化的bytes.Equal函数来判断两个字节型slice是否相等([]byte),但是对于其他类型的slice,我们必须自己展开每个元素进行比较:
func equal(x, y []string) bool {
if len(x) != len(y) {
return false
}
for i := range x {
if x[i] != y[i] {
return false
}
}
return true
}
Map是一个无序的key/value对集合，其中所有的key都不是相同，然后根据key找到对应的value进行检索、更新或者删除。
Map声明
var m map[string] string
创建
// 创建一个空的 Map
m1 := make(map[string]int)
// 创建一个初始容量为 10 的 Map
m2 := make(map[string]int, 10)
m := map[string]int{
"keke": 001,
"jame": 002,
}
//等价于
m := make(map[string]int)
m["keke"] = 001
m["jame"] = 002
案例
package main
import "fmt"
func main() {
//初始化map
m := map[string]string{
"name": "lisi",
"age": "15",
"address": "wuhan",
}
//根据key获取元素
v1 := m["name"]
fmt.Println("根据key获取元素：" + v1)
//修改键值对
m["age"] = "17"
v2 := m["age"]
fmt.Println("修改键值对：" + v2)
//获取 Map 的长度
len := len(m)
fmt.Println("获取 Map 的长度:", len)
//添加键值对
fmt.Println("添加键值对============")
m["sex"] = "男"
//遍历 Map：
for key := range m {
fmt.Println(key, "-", m[key])
}
//判断元素是否存在
//ok := m["name"]
name, ok := m["address"]
if ok {
fmt.Println("地址是", name)
} else {
fmt.Println("地址不存在")
}
fmt.Println(ok)
//删除元素
delete(m, "sex")
fmt.Println("删除之后=============")
for key := range m {
fmt.Println(key, "-", m[key])
}
}
执行结果：
根据key获取元素：lisi
修改键值对：17
获取 Map 的长度: 3
添加键值对============
name - lisi
age - 17
address - wuhan
sex - 男
地址是 wuhan
true
删除之后=============
address - wuhan
name - lisi
age - 17
Go提供的结构体就是把使用各种数据类型定义的不同变量组合起来的高级数据类型
type User struct {
name string
age int
address string
weight float32
}
案例
package main
import "fmt"
func main() {
user := User{name: "zhangsan", age: 18, address: "wuhan", weight: 100.57}
user1 := User{"lisi", 28, "beijing", 99.86}
fmt.Println(user)
fmt.Println(user1)
}
type User struct {
name string
age int
address string
weight float32
}
输出结果：
{zhangsan 18 wuhan 100.57}
{lisi 28 beijing 99.86}
如果要访问结构体成员，需要使用点号 . 操作符，格式为：
结构体.成员名
案例
package main
import "fmt"
func main() {
user := User{name: "zhangsan", age: 18, address: "wuhan", weight: 100.57}
fmt.Println("张三用户", user)
//赋值
var user1 User
user1.name = "lisi"
user1.age = 28
user1.weight = 88.88
fmt.Println("李四用户", user1)
//获取值
address := user.address
fmt.Println("用户张三家的地址为", address)
}
type User struct {
name string
age int
address string
weight float32
}
输出结果
张三用户 {zhangsan 18 wuhan 100.57}
李四用户 {lisi 28 88.88}
用户张三家的地址为 wuhan
案例
package main
import "fmt"
func main() {
user := User{name: "zhangsan", age: 18, address: "wuhan", weight: 100.57}
printUser(user)
}
func printUser(user User) {
fmt.Printf("user name : %s\n", user.name)
fmt.Printf("user age : %d\n", user.age)
fmt.Printf("user address : %s\n", user.address)
fmt.Printf("user weight : %v\n", user.weight)
}
type User struct {
name string
age int
address string
weight float32
}
输出结果
user name : zhangsan
user age : 18
user address : wuhan
user weight : 100.57
你可以定义指向结构体的指针类似于其他指针变量，格式如下：
var struct_pointer *Books
struct_pointer = &Book1
使用结构体指针访问结构体成员，使用 “.” 操作符：
结构体名称.属性
案例
package main
import "fmt"
func main() {
var r = new(Rectangle)
r.width = 100
r.length = 200
fmt.Println("Width:", r.width, "Length:", r.length, "Area:", r.area())
fmt.Println("Width:", r.width, "Length:", r.length, "Area:", r.double_area())
}
func (r Rectangle) area() float64 {
return r.width * r.length
}
func (r *Rectangle) double_area() float64 {
r.width *= 2
r.length *= 2
return r.width * r.length
}
type Rectangle struct {
width float64
length float64
}
输出结果
Width: 100 Length: 200 Area: 20000
Width: 200 Length: 400 Area: 80000
其实使不使用指针，取决于你是否试图在函数内部改变传递进来的参数的值
package main
import "fmt"
func main() {
var w Wheel
w.Circle.Center.X = 8
w.Circle.Center.Y = 8
w.Circle.Radius = 5
w.Spokes = 20
fmt.Println(w)
}
type Point struct {
X, Y int
}
type Circle struct {
Center Point
Radius int
}
type Wheel struct {
Circle Circle
Spokes int
}
输出结果
{{{8 8} 5} 20}
Go语言有一个特性让我们只声明一个成员对应的数据类型而不指名成员的名字;这类成员就叫匿名成员。匿名成员的数据类型必须是命名的类型或指向一个命名的类型的指针。下面的代码中,Circle和Wheel各自都有一个匿名成员。我们可以说Point类型被嵌入到了Circle结构体,同时Circle类型被嵌入到了Wheel结构体
package main
import "fmt"
func main() {
var w Wheel
w.X = 8 // w.Circle.Point.X = 8
w.Y = 8 // w.Circle.Point.Y = 8
w.Radius = 5 // w.Circle.Radius = 5
w.Spokes = 20
fmt.Println(w)
}
type Point struct {
X, Y int
}
type Circle struct {
Point // 匿名字段，struct
Radius int
}
type Wheel struct {
Circle // 匿名字段，struct
Spokes int
}
输出结果
{{{8 8} 5} 20}