Go编程语言规范2类型

类型

布尔值，数值与字符串类型的实例的命名是预声明的。 数组，结构，指针，函数，接口，切片，映射和信道这些复合类型可由类型字面构造。

每个类型 T 都有一个 基本类型：若 T 为预声明类型或类型字面， 其相应的基本类型为 T 本身。否则，T的基本类型为其 类型声明中所依据类型的基本类型。

 
   type T1 string
   type T2 T1
   type T3 []T1
   type T4 T3

以上 string，T1 和 T2 的基本类型为 string。 []T1，T3 和 T4 的基本类型为 []T1 。

类型与值

注意下面说的是类型相同

• 若两个数组类型其元素类型相同且长度相同，那么它们的类型相同。
• 若两个切片类型其元素类型相同，那么它们的类型相同。
• 若两个结构类型其字段序列相同，相应字段名相同，类型相同，标注相同，那么它们的类型相同。 两个匿名字段其名字被认为相同。出自不同包的小写字段名总不相同。
• 若两个指针类型其基础类型相同，那么它们的类型相同。
• 若两个函数类型其形参个数相同，返回值相同，相应形参类型相同，返回值类型相同， 两函数都可变或都不可变，那么它们的类型相同。形参和返回值名无需匹配。
• 若两个接口类型其方法集相同，名字相同，函数类型相同，那么它们的类型相同。 出自不同包的小写方法名总不相同。两接口类型是否相同与方法的次序无关。
• 若两个映射类型其键值类型相同，那么它们的类型相同。
• 若两个信道类型其值类型相同，方向相同，那么它们的类型相同。

可赋值性

• 当 x 的类型和 T 相同时。
• 当 x 的类型 V 和 T 有相同的 基本类型 且在 V 或 T 中至少有一个不是已命名类型时。
• 当 T 为接口类型且 x 实现了 T时。
• 当 x 为双向信道值、T 为信道类型、 x 的类型 V 和 T 的元素类型相同且在 V 或 T 中至少有一个不是已命名类型时。
• 当 x 为预声明标识符 nil 且 T 为指针、函数、切片、映射、通道或接口类型时。
• 当 x 为无类型化，可通过类型 T 的值来表示的 常量时。

任何类型都可赋予空白标识符.

布尔类型 bool

布尔类型 表示由预声明常量 true 和 false所代表的布尔值的集。 预声明的布尔类型为 bool。

数值类型 int等

uint8       所有无符号 8位整数集（0 到 255）
uint16      所有无符号16位整数集（0 到 65535）
uint32      所有无符号32位整数集（0 到 4294967295）
uint64      所有无符号64位整数集（0 到 18446744073709551615）

int8        所有带符号 8位整数集（-128 到 127）
int16       所有带符号16位整数集（-32768 到 32767）
int32       所有带符号32位整数集（-2147483648 到 2147483647）
int64       所有带符号64位整数集（-9223372036854775808 到 9223372036854775807）

float32     所有IEEE-754 32位浮点数集
float64     所有IEEE-754 64位浮点数集

complex64   所有带float32实部和虚部的复数集
complex128  所有带float64实部和虚部的复数集

byte        uint8的别名
rune        int32的别名

除 byte 为 uint8 的别名以及 rune 为 int32 的别名外，所有数值类型都是不同的。 当不同的数值类型混合在一个表达式或赋值操作中时，必须进行类型转换。 例如，int32 与 int 是不同的类型， 尽管它们在特定架构上可能有相同的大小。

大小取决于具体实现的预声明数值类型：

uint     32或64位
int      大小与uint相同
uintptr  大到足以存储指针值无解释位的无符号整数

字符串类型 string

字符串是不可变的： 一旦被创建，字符串的内容就不能更改。

字符串 s 的长度（即其字节大小）可使用内建函数 len 获取。若该字符串为常量，则其长度即为编译时常量。

字符串的字节可通过整数0 至 len(s)-1 访问。

获取这样一个元素的地址是非法的；若 s[i] 为字符串的第 i 个字节，&s[i] 就是无效的。

	x := "ssssssss"
	var str interface{} = x[0]
	b := str.(byte)   //断言是否是字节.如果是则b为该值,如果不是则恐慌
	fmt.Println(b)

数组类型

数组 a 的长度可使用内建函数 len获取， 其元素可通过整数下标 0 到 len(a)-1 寻址。 数组类型总是一维的，但可组合构成多维的类型。

[32]byte
[2*N] struct { x, y int32 }
[1000]*float64
[3][5]int
[2][2][2]float64  // 等价于[2]([2]([2]float64))

a := [3]int{1, 2, 3} // 声明了一个长度为3的int数组

b := [10]int{1, 2, 3} // 声明了一个长度为10的int数组，其中前三个元素初始化为1、2、3，其它默认为0

c := [...]int{4, 5, 6} // 可以省略长度而采用`...`的方式，Go会自动根据元素个数来计算长度

切片类型 slice

类似于数组，切片是可索引的且拥有一个长度。切片 s 的长度可通过内建函数 len获取；不同于数组的是，切片可在执行过程中被改变， 其元素可通过整数0 到 len(s)-1 寻址。 给定元素的切片下标可能小于它在其基本数组中的下标。

容量 是该扩展的量度： 它是切片的长度和切片往后数组的长度之和；长度达到其容量的切片可通过从原切片 ‘切下’一个新的来创建。 切片 a 的容量可使用内建函数 cap(a) 获取。

	var sli2 []int             
	sli2 = make([]int, 20, 30)
	sli2[5] = 10
	fmt.Println(sli2)

	sli := make([]int, 5, 10)
	sli[4] = 5
	fmt.Println(sli)

	sli3 := []int{5, 2}
	fmt.Println(sli3)

产生切片与分配数组后再对其进行切片相同，因此这两个例子的结果为相同的切片：

	make([]int, 50, 100)
	new([100]int)[0:50]

切片是引用的

结构类型

通过有类型而无显式字段名声明的字段为 匿名字段，亦称为 嵌入式 字段或该结构中此种类型的嵌入。 这种字段类型必须作为一个类型名 T 或一个非接口类型名的指针 *T来实现， 且 T 本身不能为指针类型。

	// 带类型为T1，*T2，P.T3和*P.T4的4个匿名字段的结构
struct {
	T1        // 字段名为T1
	*T2       // 字段名为T2
	P.T3      // 字段名为T3
	*P.T4     // 字段名为T4
	x, y int  // 字段名为x和y
}

以下为非法声明，因为字段名在结构类型中必须是唯一的：

struct {
	T     // 与匿名字段*T及*P.T相冲突
	*T    // 与匿名字段T及*P.T相冲突
	*P.T  // 与匿名字段T及*T相冲突
}

在结构 x 中，若 x.f 为表示字段或方法 f 的合法选择者，则匿名字段的字段或方法 f 即为已提升的。

给定结构类型 S 与名为 T 的类型，包含在结构方法集中的已提升方法如下：

• 若 S 包含一个匿名字段 T，则 S 与 *S 的方法集均包含带接收者 T 的已提升方法。*S 的方法集也包含带接收者 *T 的已提升方法。
• 若 S 包含匿名字段 *T，则 S 与 *S 的方法集均包含带接收者 T 或 *T 的已提升方法。

字段声明可后跟一个可选的字符串字面 标注，成为所有相应字段声明中字段的属性。 标注可通过 反射接口 获得，否则就会被忽略。

	// 一个对应于时间戳协议缓存的结构.
// 标注字符串定义了协议缓存的字段号.
struct {
	microsec  uint64 "field 1"
	serverIP6 uint64 "field 2"
	process   string "field 3"
}

指针类型

指针类型表示一个所有给定类型变量的指针的集，称为指针的 基础类型。 未初始化的指针的值为 nil。

	x:=3
	y:=&x //y这时变成了指针,传x的地址
	fmt.Println(y, *y)  //*y该地址的值  

注意:上面的*y中的*在表达式中代表该指针的值,在类型定义中,则代表某类型变量的指针

type strPoint *string

func main() {
	var strP strPoint
	i := "a"
	strP = &i
	fmt.Println(strP)
}

函数类型 func

在Go中函数也是一种变量，我们可以通过type来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型

type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])

type testInt func(int) bool // 声明了一个函数类型

func a(integer int) bool {
    if integer%2 == 0 {
        return false
    }
    return true
}

func b(integer int) bool {
    if integer%2 == 0 {
        return true
    }
    return false
}

func filter(slice []int, f testInt) []int { // 声明的函数类型在这个地方当做了一个参数,这里即可以传a,也可以传b
    var result []int
    for _, value := range slice {
        if f(value) {
            result = append(result, value)
        }
    }
    return result
}

函数当做值和类型在我们写一些通用接口的时候非常有用，通过上面例子我们看到testInt这个类型是一个函数类型，然后两个filter函数的参数和返回值与testInt类型是一样的，但是我们可以实现很多种的逻辑，这样使得我们的程序变得非常的灵活。

函数签名中的最后一个形参可能有一个带 ... 前缀的类型。 带这样形参的函数被称为 变参函数 它可接受零个或多个实参的函数。

func()
func(x int) int
func(a, _ int, z float32) bool
func(a, b int, z float32) (bool)
func(prefix string, values ...int)
func(a, b int, z float64, opt ...interface{}) (success bool)  //for _, n := range arg   来循环参数
func(int, int, float64) (float64, *[]int)
func(n int) func(p *T)

接口类型 interface

接口类型指定一个称为 接口 的 方法集。 接口类型变量可存储任何带方法集类型的值，该方法集为此接口的超集。 这种类型表示 实现此接口。未初始化的接口类型变量的值为 nil。

空interface(interface{})不包含任何的method，正因为如此，所有的类型都实现了空interface。空interface对于描述起不到任何的作用(因为它不包含任何的method），但是空interface在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。

// 定义a为空接口
var a interface{}
var i int = 5
s := "Hello world"
// a可以存储任意类型的数值
a = i
a = s

一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。是不是很有用啊！

映射类型 map

映射通过另一类型唯一的 键 集索引，该类型称为键类型。 未初始化的映射值为 nil。

比较操作符 == 和 != 必须由键类型的操作数完全定义； 因此键类型不能是函数，映射或切片。若该键类型为接口类型，这些比较运算符必须由动态键值定义； 失败将导致一个 运行时恐慌.

元素的数量称为长度。 对于映射 m，其长度可使用内建函数 len 获取并可在执行时更改。元素可在执行时使用赋值来添加并通过 下标表达式 来检索；它们也可通过内建函数 delete 删除。

	var numbers map[string] int
	numbers = make(map[string] int) //注意是=号
	numbers["ss"]=5

	m := make(map[string]string)
	m["Hello"] = "Bonjour"

	rating := map[string]float32{"C": 5, "Go": 4.5, "Python": 4.5, "C++": 2}
	fmt.Println(rating)

map也是一种引用类型，如果两个map同时指向一个底层，那么一个改变，另一个也相应的改变：

信道类型 chan

信道提供一种机制使两个并发执行的函数同步执行，并通过传递具体元素类型的值来通信。 未初始化的信道值为 nil。

信道虽然使用make创建,但不是引用的.确保在并发过程中,各个并发的程序(返回值)能够和父环境通信

容量根据元素的数量设置信道中缓存的大小。若容量大于零，则信道是异步的：
若缓存未满（发送）或非空（接收），则通信操作无阻塞成功，且元素在发送序列中被接收。

若容量为零或无，则只有当发送者和接收者都做好准备时通信才会成功。 nil 信道永远不会准备好通信。
信道可通过内建函数close关闭； 接收操作符的多值赋值形式可测试信道是否关闭。

ci := make(chan int)
cs := make(chan string)
cf := make(chan interface{})

channel通过操作符<-来接收和发送数据

ch <- v    // 发送v到channel ch.
v := <-ch  // 从ch中接收数据，并赋值给v

举个例子:

package main

import "fmt"

func sum(a []int, c chan int) {
    sum := 0
    for _, v := range a {
        sum += v
    }
    c <- sum  // send sum to c
}

func main() {
    a := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(a[:len(a)/2], c)
    go sum(a[len(a)/2:], c)
    x, y := <-c, <-c  // receive from c

    fmt.Println(x, y, x + y)
}

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得Goroutines同步变的更加的简单，而不需要显式的lock。所谓阻塞，也就是如果读取（value := <-ch）它将会被阻塞，直到有数据接收。其次，任何发送（ch<-5）将会被阻塞，直到数据被读出。无缓冲channel是在多个goroutine之间同步很棒的工具。

<-操作符指定信道的 方向，发送 或 接收。 若没有给定方向，那么该信道就是 双向的。 信道可通过类型转换 或 赋值被强制为只发送或只接收。

chan T          // 可以被用来发送和接收类型T的值
chan<- float64  // 只能被用来发送浮点数
<-chan int      // 只能被用来接收整数

<- 操作符结合最左边的 chan 可能的方式：

chan<- chan int    // 等价于 chan<- (chan int)
chan<- <-chan int  // 等价于 chan<- (<-chan int)
<-chan <-chan int  // 等价于 <-chan (<-chan int)
chan (<-chan int)