客服电话
APP下载
迪恩网络APP
随时随地掌握行业动态
官方微信
扫描二维码
关注迪恩网络微信公众号
类型布尔值，数值与字符串类型的实例的命名是预声明的。 数组，结构，指针，函数，接口，切片，映射和信道这些复合类型可由类型字面构造。 每个类型 type T1 string type T2 T1 type T3 []T1 type T4 T3 以上 string，T1 和 T2 的基本类型为 string。 []T1，T3 和 T4 的基本类型为 []T1 。 类型与值注意下面说的是类型相同
可赋值性
任何类型都可赋予空白标识符. 布尔类型 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 即为已提升的。 给定结构类型
字段声明可后跟一个可选的字符串字面 标注，成为所有相应字段声明中字段的属性。 标注可通过 反射接口 获得，否则就会被忽略。 // 一个对应于时间戳协议缓存的结构.
// 标注字符串定义了协议缓存的字段号.
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创建,但不是引用的.确保在并发过程中,各个并发的程序(返回值)能够和父环境通信 容量根据元素的数量设置信道中缓存的大小。若容量大于零，则信道是异步的： 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 int // 等价于 chan<- (chan int) chan<- <-chan int // 等价于 chan<- (<-chan int) <-chan <-chan int // 等价于 <-chan (<-chan int) chan (<-chan int) |
请发表评论