(go圣经系列)复合数据类型

(go圣经系列)复合数据类型

复合数据类型:数组、slice、map、结构体

聚合类型:数组、结构体 (大小都是固定的静态的数据结构)

数组:由同构的元素组成

结构体:由异构的元素组成

动态的数据结构:slice 和 map （长度可以动态的进行改变）

1.数组

var a [3]int					   //数组的定义
fmt.Println(a[0])
fmt.Println(a[len(a)-1])			//len()内置函数返回数组元素的长度
for i , v := range a {
    fmt.Printf("%d %d\n",i,v)
}
for _ , v := range a {
    fmt.Printf("%d\n",v)
}

// 提供顺序的初始化序列
var q [3]int = [3]int{1,2,3}
var r [3]int = [3]int{1,2,3}
fmt.Println(r[2])					// 0 

//数组的长度是根据初始化值的个数确定
q := [...]int{1,2,3}
fmt.Println("%T\n",1)				//[3]int

q := [3]int{1,2,3}
q = [4]int{1,2,3,4}					//error
//[3]int 和 [4]int是不同的数组类型 

//指定索引和对应的值列表给数组进行初始化 
type Currency int 
const (
	USD Currency = iota			//美元  
    EUR 					   // 欧元  
    GBP 					   //英镑 
    RMB						   //人民币 
)
symbol := [...]string{USD: "$",EUR: "&",RMB: "￥"}
fmt.Println(RMB,symbol[RMB])					// "3 ￥"

//数组的元素类型是可以互相比较的 那么数组类型也是可以互相比较的 
a := [2]int{1,2}
b := [...]int{1,2}
c := [2]int{1,3}
fmt.Println(a == b , a == c , b == c )	//"true false true"
d := [3]int{1,2}
fmt.Println(a == d)						//error 不同的类型

案例: 
import "crypto/sha256"
func main() {
    c1 := sha256.Sum256([]byte("x"))
    c2 := sha256.Sum256([]byte("X"))
    fmt.Printf("%x\n%x\n%t\n%T\n",c1,c2,c1==c2,c1)
}
func sha256.Sum256( a []byte)) [32]byte
//Sum256函数对一个任意的字节slice类型的数据生成一个信息的摘要
//摘要由256bit大小 因此对应[32]int数组类型 

说明:函数接收到的参数实际是对应变量的副本(值传递)，这个机制导致大数组在函数传递过程中是低效率的。对数组参数的修改都是修改的副本 并不能修改数组本身，这是go语言和其他语言有所不同的一个特点。这也是数组在go中没有被大量使用的一个原因 。

//给[32]byte数组清零:
func zero(ptr *[32]byte) {
    for i := range ptr {
        ptr[i] = 0 
    }
}
//可以显示的传入一个数组指针来对数组原始值进行修改 
[32]byte{}: 一个32字节的数组 数组的每个元素都是零值
//简写
func zero(ptr *[32]byte) {
    *ptr = [32]byte{}
}

练习4.1 
编写一个函数，计算两个SHA256哈希码中不同bit的数目。（参考2.6.2节的PopCount函数.
func count(a , b string) (num int){
    A := sha256.Sum256([]byte(a))
    B := sha256.Sum256([]byte(b))
    for i:=0 ;i <len(A);i++{
        for m:=1 ; m<=8; m++ {
            //一个字节有8bit 拿出一个byte循环8次进行比较 8
            if (A[i] >> uint(m)) != (B[i] >> uint(m)){
                num++ 
            }
        }
    }
    return num 
}
练习4.2 
编写一个程序，默认情况下打印标准输入的SHA256编码，并支持通过命令行flag定制，输出SHA384或SHA512哈希算法.
var hashMethod = flag.String("s","sha256","请输入哈希算法:")
func main() {
    flag.Parse()
    printHash(strings.ToUpper(*hashMethod),"x")
}

func printHash(flag string,str string){
    if flag == "SHA256"{
        fmt.Printf("%x\n",sha256.Sum256([]byte(str)))
        return 
    }
    if flag == "SHA512" {
        fmt.Printf("%x\n",sha512.Sum512([]byte(str)))
    }
    if flag == "SHA384" {
        fmt.Printf("%x\n",sha512.Sum384([]byte(str)))
    }
}

补充个flag包：

flag包
(1)flag.Type(flag名,默认值,帮助信息) *Type 
eg： 
name := flag.String("name","张三","姓名")
age := flag.Int("age",18,"年龄")
married := flag.Bool("married",false,"婚否")
delay := flag.Duration("d",0,"时间间隔")
name age married delay都为对应类型的指针 

(2)flag.TypeVar(Type指针，flag名,默认值,帮助信息) 
var name string
flag.StringVar(&name, "name", "张三", "姓名")

(3)flag.Parse() 以上两种方式需要调用Parse函数进行解析