1. bool类型
bool 类型表示一个布尔值，值为 true 或者 false。
var b1,b2 bool
b1=true
b2=false
2. 整型
精确的类型有8种：int8/uint8,int16/uint16,int32/uint32,int64/uint64
int型是有符号基本型整数，如果是32位系统，就是32位，同理，64位系统，就是64位的整型
3.Byte
uint8与byte可以说是一样的,官方的定义
uint8 the set of all unsigned 8-bit integers (0 to 255)
byte alias for uint8
Byte可以定义切片： []byte,也可以转换成String
4.字符串
字符串是用一对双引号""或反引号括起来定义，它的类型是 string ,默认不进行转义，可使用跨行格式。
var str string
str="world"
str=`hello world`
注意：
- 字符串默认值为"".
- 修改：go中字符串面值是不可变的。它不是字符数组，不能直接修改字符串中的字符。可以转为[]byte后修改，然后转换回string。
- 编码方式：string里面的字符采用utf-8编码，每个字符长度是不确定的，可能为1-4个字节存储。（英文是一个字节）
- 字符串可以进行切片操作,比如str[3:8],可以截取3，8之间的字符串值，返回一个子串。
Go中的字符串本质上是一个字节数组。在内存中，一个字符串实际上是一个双字结构，即一个指向实际数据的指针和记录字符串长度的整数
Go 语言中的字符串是不可变的，也就是说 str[index] 这样的表达式是不可以被放在等号左侧的。
因此，必须先将字符串转换成字节数组，然后再通过修改数组中的元素值来达到修改字符串的目的，最后将字节数组转换回字符串格式
5.struct
声明格式：
type typeName struct {
name type
}
struct有如下四种初始化方式：
var varName typeName
varName := new(typeName)
varName := typeName{初始化值}
varName := &typeName{初始化值}
1、3返回 typeName 类型变量；2、4返回 *typeName 类型变量；若无初始化值，则默认为零值
初始化值时可以分为两种:
1.有序: typeName{value1, value2, ...} 必须一一对应
2.无序: typeName{field1:value1, field2:value2, ...} 可初始化部分值
type Person struct {
name string
age int
}
p := Person{"James", 23} //有序
p := Person{age:23} //无序
struct的拷贝：
原理是使用反射，但我们可以直接用json,其实它里面也是用的reflection
type A struct {
A int
B string
C int
}
a := A{1, "a", 1}
aj, _ := json.Marshal(a)
b := new(A)
_ = json.Unmarshal(aj, b)
fmt.Printf("%+v", b)
6.nil
nil只能赋值给指针、channel、func、interface、map和slice类型的变量。即（通道，函数，接口，切片，映射五大引用类型+指针）如果将nil赋值给其他变量的时候将会引发panic，对于其它的变量，也不能判断其是否为nil
var str string;
if str==nil
7.Interface
一个接口包含了两个东西：1、一组方法的定义；2、一个类型（type）
An interface is two things: it is a set of methods, but it is also a type
为什么interface可以被赋值为任意的变量:
The interface{} type, the empty interface is the interface that has no methods.
Since there is no implements keyword, all types implement at least zero methods, and satisfying an interface is done automatically, all types satisfy the empty interface.
That means that if you write a function that takes an interface{} value as a parameter, you can supply that function with any value.
关于interface在方法中到底是什么类型？
func DoSomething(v interface{}) {
...
}
Here’s where it gets confusing:
inside of the DoSomething function, what is v's type?
We used to believe that “v is of any type”, but that is wrong.v is not of any type; it is of interface{} type.
所以我们说就是interface{}类型,我们来看看它里面是如何操作的：
When passing a value into the DoSomething function, the Go runtime will perform a type conversion, and convert the value to an interface{} value.Because all values have exactly one type at runtime, and v's one static type is interface{}.
我们再来探究下interface作为变量
An interface value is constructed of two words of data: 1.one word is used to point to a method table for the value’s underlying type;2. the other word is used to point to the actual data being held by that value.
8.Map
// 先声明map
var m1 map[string]string
// 再使用make函数创建一个非nil的map，nil map不能赋值
m1 = make(map[string]string)
// 最后给已声明的map赋值
m1["a"] = "aa"
m1["b"] = "bb"
// 直接创建
m2 := make(map[string]string)
// 然后赋值
m2["a"] = "aa"
m2["b"] = "bb"
// 初始化 + 赋值一体化
m3 := map[string]string{
"a": "aa",
"b": "bb",
}
// ==========================================
// 查找键值是否存在
if v, ok := m1["a"]; ok {
fmt.Println(v)
} else {
fmt.Println("Key Not Found")
}
// 遍历map
for k, v := range m1 {
fmt.Println(k, v)
}
将struct类型转换为map，这里使用到的还是反射原理和interface
type User struct {
Id int64
Username string
Password string
Logintime time.Time
}
func Struct2Map(obj interface{}) map[string]interface{} {
t := reflect.TypeOf(obj)
v := reflect.ValueOf(obj)
var data = make(map[string]interface{})
for i := 0; i < t.NumField(); i++ {
data[t.Field(i).Name] = v.Field(i).Interface()
}
return data
}
func main() {
user := User{5, "zhangsan", "pwd", time.Now()}
data := Struct2Map(user)
fmt.Println(data)
}