一、概述

在golang中会涉及变量(var声明)、常量(const)、枚举(golang从语法上没有enum的定义，可以使用iota来实现)、基本类型、引用类型(slice、map、channel)、类型转换、自定义类型、未命名类型等内容，不过很多是和大家熟知的Java、C#中概念差不多，只是具体存在一些差异，不过需要记住一点golang是静态类型语言，其对应的变量总有固定的数据类型，其类型也决定变量内存的长度和储存格式，也意味着只能更改其变量值而不能变更其类型。

数据类型

二、具体实例

package main

import (
    "reflect"
    "unsafe"
)

func main() {
    type data int
    var d data = 10

    // var x int = d // 该操作是不会进行隐式转换的
    var x int = int(d)
    println(x)

    //println(d == x) // 该操作是不被允许的

    // 具有相同元素类型和长度的数组 即认为是同一类型
    aa := [10]int{}
    bb := [10]int{}
    println(aa == bb)

    // 具有相同基类型的指针 即认为是同一类型
    aaa := unsafe.Pointer(uintptr(1))
    bbb := unsafe.Pointer(uintptr(1))
    println(aaa == bbb)

    // 具有相同元素类型的切片 可认为是相同的切片； 比较需要使用reflect.DeepEqual来完成
    aslice := make([]int, 0, 10)
    bslice := make([]int, 0, 10)
    // bslice := make([]int, 1, 10) // 当给定slice的length不相同时 也不会认为两个slice是相同的；不同的容量值却不影响
    println(reflect.DeepEqual(aslice,bslice))

    // 具有相同的键值类型的map 即认为是相同的map； 比较需要使用reflect.DeepEqual来完成：故使用别名和新建类型都不影响最终的结果
    amap := make(map[string]int)
    bmap := make(map[string]int)
    println(reflect.DeepEqual(amap, bmap))

    type MyInt = int // 使用golang的别名：
    cmap := make(map[string]int)
    println(reflect.DeepEqual(amap, cmap))

    type MyInt1 int // 使用golang自定义类型
    dmap := make(map[string]int)
    println(reflect.DeepEqual(amap, dmap))

    // 具有相同数据类型及操作方向的channel 即认为是相同类型
    //cc := make(chan int)
    var achan (<-chan int)
    var bchan (<-chan int)
    println(reflect.DeepEqual(achan, bchan))

    var cchan (chan <-int)
    //var dchan (chan <-int)
    var dchan (chan <-MyInt)
    //println((cchan == dchan))
    println(reflect.DeepEqual(cchan, dchan))

    // 属于相同类型的channel必须满足数据类型和操作方向：下面的两个双向channel是不相同的
    echan := make(chan int)
    fchan := make(chan int)
    println(reflect.DeepEqual(echan, fchan))

    // 具有相同字段名及类型、标签、字段顺序的struct可认为是相同的
    astruct := struct {
        name string
        age int
    }{}
    bstruct := struct {
        name string
        age int
    }{}
    //println(astruct == bstruct)
    println(reflect.DeepEqual(astruct, bstruct))

    // 具有相同签名(参数和返回值列表，不含参数名)的函数可认为是相同的
    var afunc func(i int) int
    var bfunc func(i int) int
    println(reflect.DeepEqual(afunc, bfunc))

    var cfunc func(i MyInt) int
    var dfunc func(a int) int
    println(reflect.DeepEqual(cfunc, dfunc))

    // 具有相同方法集(方法名及签名，不含顺序)的interface可认为是相同的
    var ainter interface{
        helloWorld(name string) string
        test1()
    }
    var binter interface{
        test1()
        helloWorld(name string) string
    }
    println(reflect.DeepEqual(ainter, binter))
}
//
// 即使不同的自定义类型指定的基础类型具有相同底层数据结构，也不能认为基础类型之间存在任何关系，两者属于不同的类型
// 自定义类型之间并不会继承基础类型的信息
// *** 对应的自定义类型不能被视为别名Alices ； 不能隐式转换； 不能直接用于比较表达式
// reflect.DeepEqual是基于底层数据类型来进行比较的
//