sync.Once用于保证某个动作只被执行一次，可用于单例模式中，比如初始化配置。我们知道init()函数也只会执行一次，不过它是在main()函数之前执行，如果想要在代码执行过程中只运行某个动作一次，可以使用sync.Once，下面来介绍一下它的使用方法。 先来看下面的代码： package main import ( "fmt" "sync" ) func main() { var num = 6 var once sync.Once add_one := func() { num = num + 1 } minus_one := func() { num = num - 1 } once.Do(add_one) fmt.Printf("The num: %d\n", num) once.Do(minus_one) fmt.Printf("The num: %d\n", num) } 执行结果： The num: 7 The num: 7 sync.Once类型提供了一个Do方法，Do方法只接受一个参数，且参数类型必须是func() ，也就是没有参数声明和结果声明的函数。 Do方法只会执行首次被调用时传入的那个函数，只执行一次，也不会执行其它函数。上面的例子中，即使传入的函数不同，也只会执行第一次传入的那个函数。如果有多个只执行一次的函数，需要为每一个函数分配一个sync.Once类型的值： func main() { var num = 6 var once1 sync.Once var once2 sync.Once add_one := func() { num = num + 1 } minus_one := func() { num = num - 1 } once1.Do(add_one) fmt.Printf("The num: %d\n", num) once2.Do(minus_one) fmt.Printf("The num: %d\n", num) } sync.Once类型是一个结构体类型，一个是名为done的uint32类型字段，还有一个互斥锁m。 type Once struct { done uint32 m Mutex } done字段的值只可能是0或者1，Do方法首次调用完成后，done的值就变为了1。done的值使用四个字节的uint32类型的原因是为了保证对它的操作是“原子操作”，通过调用atomic.LoadUint32函数获取它的值，如果为1，直接返回，不会执行函数。 如果为0，Do方法会立即锁定字段m，如果这里不加锁，多个goroutine 同时执行到Do方法时判断都为0，则都会执行函数，所以Once是并发安全的。 加锁之后，会再次检查done字段的值，如果满足条件，执行传入的函数，并用原子操作函数atomic.StoreUint32将done的值设置为1。 下面是Once的源码： func (o *Once) Do(f func()) { if atomic.LoadUint32(&o.done) == 0 { o.doSlow(f) } } func (o *Once) doSlow(f func()) { o.m.Lock() defer o.m.Unlock() if o.done == 0 { defer atomic.StoreUint32(&o.done, 1) f() } } 源码非常简洁，和GoF 设计模式中的单例模式非常相似。 到此这篇关于Go语言并发编程 sync.Once的文章就介绍到这了,更多相关Go语言语言 sync.Once内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

map 的两种目前在业界使用的最多的并发支持的模式分别是： 原生 map + 互斥锁或读写锁 mutex。 标准库 sync.Map（Go1.9及以后）。 有了选择，总是有选择困难症的，这两种到底怎么选，谁的性能更加的好？我有一个朋友说 标准库 sync.Map 性能菜的很，不要用。我到底听谁的... 今天煎鱼就带你揭秘 Go sync.map，我们先会了解清楚什么场景下，Go map 的多种类型怎么用，谁的性能最好！ 接着根据各 map 性能分析的结果，针对性的对 sync.map 进行源码解剖，了解 WHY。 一起愉快地开始吸鱼之路。 1、sync.Map 优势 在 Go 官方文档中明确指出 Map 类型的一些建议： 多个 goroutine 的并发使用是安全的，不需要额外的锁定或协调控制。 大多数代码应该使用原生的 map，而不是单独的锁定或协调控制，以获得更好的类型安全性和维护性。 同时 Map 类型，还针对以下场景进行了性能优化： 当一个给定的键的条目只被写入一次但被多次读取时。例如在仅会增长的缓存中，就会有这种业务场景。 当多个 goroutines 读取、写入和覆盖不相干的键集合的条目时。 这两种情况与 Go map 搭配单独的 Mutex 或 RWMutex 相比较，使用 Map 类型可以大大减少锁的争夺。 2、性能测试 听官方文档介绍了一堆好处后，他并没有讲到缺点，所说的性能优化后的优势又是否真实可信。我们一起来验证一下。 首先我们定义基本的数据结构： // 代表互斥锁 type FooMap struct { sync.Mutex data map[int]int } // 代表读写锁 type BarRwMap struct { sync.RWMutex data map[int]int } var fooMap *FooMap var barRwMap *BarRwMap var syncMap *sync.Map // 初始化基本数据结构 func init() { fooMap = &FooMap{data: make(map[int]int, 100)} barRwMap = &BarRwMap{data: make(map[int]int, 100)} syncMap = &sync.Map{} } 在配套方法上，常见的增删改查动作我们都编写了相应的方法。用于后续的压测（只展示部分代码）： func builtinRwMapStore(k, v int) { barRwMap.Lock() defer barRwMap.Unlock() barRwMap.data[k] = v } func builtinRwMapLookup(k int) int { barRwMap.RLock() defer barRwMap.RUnlock() if v, ok := barRwMap.data[k]; !ok { return -1 } else { return v } } func builtinRwMapDelete(k int) { barRwMap.Lock() defer barRwMap.Unlock() if _, ok := barRwMap.data[k]; !ok { return } else { delete(barRwMap.data, k) } } 其余的类型方法基本类似，考虑重复篇幅问题因此就不在此展示了。 压测方法基本代码如下： func BenchmarkBuiltinRwMapDeleteParalell(b *testing.B) { b.RunParallel(func(pb *testing.PB) { r := rand.New(rand.NewSource(time.Now().Unix())) for pb.Next() { k := r.Intn(100000000) builtinRwMapDelete(k) } }) } 这块主要就是增删改查的代码和压测方法的准备，压测代码直接复用的是大白大佬的 go19-examples/benchmark-for-map 项目。 也可以使用 Go 官方提供的 map\_bench\_test.go，有兴趣的小伙伴可以自己拉下来运行试一下。 2.1 压测结果 1）写入 名 含义 压测结果 BenchmarkBuiltinMapStoreParalell-4 map+mutex 写入元素 237.1 ns/op BenchmarkSyncMapStoreParalell-4 sync.map 写入元素 509.3 ns/op BenchmarkBuiltinRwMapStoreParalell-4 map+rwmutex 写入元素 207.8 ns/op 总体的排序（从慢到快）为：SyncMapStore < MapStore < RwMapStore。 2）查找 方法名 含义 压测结果 BenchmarkBuiltinMapLookupParalell-4 map+mutex 查找元素 166.7 ns/op BenchmarkBuiltinRwMapLookupParalell-4 map+rwmutex 查找元素 60.49 ns/op BenchmarkSyncMapLookupParalell-4 sync.map 查找元素 53.39 ns/op 在查找元素上，最慢的是原生 map+互斥锁，其次是原生 map+读写锁。最快的是 sync.map 类型。 总体的排序为：MapLookup < RwMapLookup < SyncMapLookup。 3）删除 方法名 含义 压测结果 BenchmarkBuiltinMapDeleteParalell-4 map+mutex 删除元素 168.3 ns/op BenchmarkBuiltinRwMapDeleteParalell-4 map+rwmutex 删除元素 188.5 ns/op BenchmarkSyncMapDeleteParalell-4 sync.map 删除元素 41.54 ns/op 在删除元素上，最慢的是原生 map+读写锁，其次是原生 map+互斥锁，最快的是 sync.map 类型。 总体的排序为：RwMapDelete < MapDelete < SyncMapDelete。 2.3 场景分析 根据上述的压测结果，我们可以得出 sync.Map 类型： 在读和删场景上的性能是最佳的，领先一倍有多。 在写入场景上的性能非常差，落后原生 map+锁整整有一倍之多。 因此在实际的业务场景中。假设是读多写少的场景，会更建议使用 sync.Map 类型。 但若是那种写多的场景，例如多 goroutine 批量的循环写入，那就建议另辟途径了，性能不忍直视（无性能要求另当别论）。 3、sync.Map 剖析 清楚如何测试，测试的结果后。我们需要进一步深挖，知其所以然。 为什么 sync.Map 类型的测试结果这么的 “偏科”，为什么读操作性能这么高，写操作性能低的可怕，他是怎么设计的？ 3.1 数据结构 sync.Map 类型的底层数据结构如下： type Map struct { mu Mutex read atomic.Value // readOnly dirty map[interface{}]*entry misses int } // Map.read 属性实际存储的是 readOnly。 type readOnly struct { m map[interface{}]*entry amended bool } mu：互斥锁，用于保护 read 和 dirty。 read：只读数据，支持并发读取（atomic.Value 类型）。如果涉及到更新操作，则只需要加锁来保证数据安全。read 实际存储的是 readOnly 结构体，内部也是一个原生 map，amended 属性用于标记 read 和 dirty 的数据是否一致。 dirty：读写数据，是一个原生 map，也就是非线程安全。操作 dirty 需要加锁来保证数据安全。 misses：统计有多少次读取 read 没有命中。每次 read 中读取失败后，misses 的计数值都会加 1。 在 read 和 dirty 中，都有涉及到的结构体： type entry struct { p unsafe.Pointer // *interface{} } 其包含一个指针 p, 用于指向用户存储的元素（key）所指向的 value 值。 在此建议你必须搞懂 read、dirty、entry，再往下看，食用效果会更佳，后续会围绕着这几个概念流转。 3.2 查找过程 划重点，Map 类型本质上是有两个 “map”。一个叫 read、一个叫 dirty，长的也差不多： sync.Map 的 2 个 map 当我们从 sync.Map 类型中读取数据时，其会先查看 read 中是否包含所需的元素： 若有，则通过 atomic 原子操作读取数据并返回。 若无，则会判断 read.readOnly 中的 amended 属性，他会告诉程序 dirty 是否包含 read.readOnly.m 中没有的数据；因此若存在，也就是 amended 为 true，将会进一步到 dirty 中查找数据。 sync.Map 的读操作性能如此之高的原因，就在于存在 read 这一巧妙的设计，其作为一个缓存层，提供了快路径（fast path）的查找。 同时其结合 amended 属性，配套解决了每次读取都涉及锁的问题，实现了读这一个使用场景的高性能。 3.3 写入过程 我们直接关注 sync.Map 类型的 Store 方法，该方法的作用是新增或更新一个元素。 源码如下： func (m *Map) Store(key, value interface{}) { read, _ := m.read.Load().(readOnly) if e, ok := read.m[key]; ok && e.tryStore(&value) { return } ... } 调用 Load 方法检查 m.read 中是否存在这个元素。若存在，且没有被标记为删除状态，则尝试存储。 若该元素不存在或已经被标记为删除状态，则继续走到下面流程： func (m *Map) Store(key, value interface{}) { ... m.mu.Lock() read, _ = m.read.Load().(readOnly) if e, ok := read.m[key]; ok { if e.unexpungeLocked() { m.dirty[key] = e } e.storeLocked(&value) } else if e, ok := m.dirty[key]; ok { e.storeLocked(&value) } else { if !read.amended { m.dirtyLocked() m.read.Store(readOnly{m: read.m, amended: true}) } m.dirty[key] = newEntry(value) } m.mu.Unlock() } 由于已经走到了 dirty 的流程，因此开头就直接调用了 Lock 方法上互斥锁，保证数据安全，也是凸显性能变差的第一幕。 其分为以下三个处理分支： 若发现 read 中存在该元素，但已经被标记为已删除（expunged），则说明 dirty 不等于 nil（dirty 中肯定不存在该元素）。其将会执行如下操作。 将元素状态从已删除（expunged）更改为 nil。 将元素插入 dirty 中。 若发现 read 中不存在该元素，但 dirty 中存在该元素，则直接写入更新 entry 的指向。 若发现 read 和 dirty 都不存在该元素，则从 read 中复制未被标记删除的数据，并向 dirty 中插入该元素，赋予元素值 entry 的指向。 我们理一理，写入过程的整体流程就是： 查 read，read 上没有，或者已标记删除状态。 上互斥锁（Mutex）。 操作 dirty，根据各种数据情况和状态进行处理。 回到最初的话题，为什么他写入性能差那么多。究其原因： 写入一定要会经过 read，无论如何都比别人多一层，后续还要查数据情况和状态，性能开销相较更大。 （第三个处理分支）当初始化或者 dirty 被提升后，会从 read 中复制全量的数据，若 read 中数据量大，则会影响性能。 可得知 sync.Map 类型不适合写多的场景，读多写少是比较好的。 若有大数据量的场景，则需要考虑 read 复制数据时的偶然性能抖动是否能够接受。 3.4 删除过程 这时候可能有小伙伴在想了。写入过程，理论上和删除不会差太远。怎么 sync.Map 类型的删除的性能似乎还行，这里面有什么猫腻？ 源码如下： func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool) { read, _ := m.read.Load().(readOnly) e, ok := read.m[key] ... if ok { return e.delete() } } 删除是标准的开场，依然先到 read 检查该元素是否存在。 若存在，则调用 delete 标记为 expunged（删除状态），非常高效。可以明确在 read 中的元素，被删除，性能是非常好的。 若不存在，也就是走到 dirty 流程中： func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool) { ... if !ok && read.amended { m.mu.Lock() read, _ = m.read.Load().(readOnly) e, ok = read.m[key] if !ok && read.amended { e, ok = m.dirty[key] delete(m.dirty, key) m.missLocked() } m.mu.Unlock() } ... return nil, false } 若 read 中不存在该元素，dirty 不为空，read 与 dirty 不一致（利用 amended 判别），则表明要操作 dirty，上互斥锁。 再重复进行双重检查，若 read 仍然不存在该元素。则调用 delete 方法从 dirty 中标记该元素的删除。 需要注意，出现频率较高的 delete 方法： func (e *entry) delete() (value interface{}, ok bool) { for { p := atomic.LoadPointer(&e.p) if p == nil || p == expunged { return nil, false } if atomic.CompareAndSwapPointer(&e.p, p, nil) { return *(*interface{})(p), true } } } 该方法都是将 entry.p 置为 nil，并且标记为 expunged（删除状态），而不是真真正正的删除。 注：不要误用 sync.Map，前段时间从字节大佬分享的案例来看，他们将一个连接作为 key 放了进去，于是和这个连接相关的，例如：buffer 的内存就永远无法释放了... 总结： 针对 sync.Map 的性能差异，进行了深入的源码剖析，了解到了其背后快、慢的原因，实现了知其然知其所以然。 经常看到并发读写 map 导致致命错误，实在是令人忧心。大家觉得如果本文不错，欢迎分享给更多的 Go 爱好者 ：） 到此这篇关于Go 并发读写 sync.map 详细的文章就介绍到这了,更多相关Go语言 并发读写 sync.map 内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

关于Go 是传值还是传引用？很多人都讨论起来 下面我们就带着问题一起探索答案吧 1、Go 官方的定义 本部分引用 Go 官方 FAQ 的 “When are function parameters passed by value?”，内容如下。 如同 C 系列的所有语言一样，Go 语言中的所有东西都是以值传递的。也就是说，一个函数总是得到一个被传递的东西的副本，就像有一个赋值语句将值赋给参数一样。 例如： 向一个函数传递一个 int 值，就会得到 int 的副本。而传递一个指针值就会得到指针的副本，但不会得到它所指向的数据。 map 和 slice 的行为类似于指针：它们是包含指向底层 map 或 slice 数据的指针的描述符。 复制一个 map 或 slice 值并不会复制它所指向的数据。 复制一个接口值会复制存储在接口值中的东西。 如果接口值持有一个结构，复制接口值就会复制该结构。如果接口值持有一个指针，复制接口值会复制该指针，但同样不会复制它所指向的数据。 划重点：Go 语言中一切都是值传递，没有引用传递。不要直接把其他概念硬套上来，会犯先入为主的错误的。 2、传值和传引用 2.1 传值 传值，也叫做值传递（pass by value）。其指的是在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 简单来讲，值传递，所传递的是该参数的副本，是复制了一份的，本质上不能认为是一个东西，指向的不是一个内存地址。 案例一如下： func main() { s := "脑子进煎鱼了" fmt.Printf("main 内存地址：%p\n", &s) hello(&s) } func hello(s *string) { fmt.Printf("hello 内存地址：%p\n", &s) } 输出结果： main 内存地址：0xc000116220 hello 内存地址：0xc000132020 我们可以看到在 main 函数中的变量 s 所指向的内存地址是 0xc000116220。在经过 hello 函数的参数传递后，其在内部所输出的内存地址是 0xc000132020，两者发生了改变。 据此我们可以得出结论，在 Go 语言确实都是值传递。那是不是在函数内修改值，就不会影响到 main 函数呢？ 案例二如下： func main() { s := "脑子进煎鱼了" fmt.Printf("main 内存地址：%p\n", &s) hello(&s) fmt.Println(s) } func hello(s *string) { fmt.Printf("hello 内存地址：%p\n", &s) *s = "煎鱼进脑子了" } 我们在 hello 函数中修改了变量 s 的值，那么最后在 main 函数中我们所输出的变量 s 的值是什么呢。是 “脑子进煎鱼了”，还是 "煎鱼进脑子了"？ 输出结果： main 内存地址：0xc000010240 hello 内存地址：0xc00000e030 煎鱼进脑子了 输出的结果是 “煎鱼进脑子了”。这时候大家可能又犯嘀咕了，煎鱼前面明明说的是 Go 语言只有值传递，也验证了两者的内存地址，都是不一样的，怎么他这下他的值就改变了，这是为什么？ 因为 “如果传过去的值是指向内存空间的地址，那么是可以对这块内存空间做修改的”。 也就是这两个内存地址，其实是指针的指针，其根源都指向着同一个指针，也就是指向着变量 s。因此我们进一步修改变量 s，得到输出 “煎鱼进脑子了” 的结果。 2.2 传引用 传引用，也叫做引用传递（pass by reference），指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。 在 Go 语言中，官方已经明确了没有传引用，也就是没有引用传递这一情况。 因此借用文字简单描述，像是例子中，即使你将参数传入，最终所输出的内存地址都是一样的。 3、争议最大的 map 和 slice 这时候又有小伙伴疑惑了，你看 Go 语言中的 map 和 slice 类型，能直接修改，难道不是同个内存地址，不是引用了？ 其实在 FAQ 中有一句提醒很重要：“map 和 slice 的行为类似于指针，它们是包含指向底层 map 或 slice 数据的指针的描述符”。 3.1 map 针对 map 类型，进一步展开来看看例子： func main() { m := make(map[string]string) m["脑子进煎鱼了"] = "这次一定！" fmt.Printf("main 内存地址：%p\n", &m) hello(m) fmt.Printf("%v", m) } func hello(p map[string]string) { fmt.Printf("hello 内存地址：%p\n", &p) p["脑子进煎鱼了"] = "记得点赞！" } 输出结果： main 内存地址：0xc00000e028 hello 内存地址：0xc00000e038 确实是值传递，那修改后的 map 的结果应该是什么。既然是值传递，那肯定就是 "这次一定！"，对吗？ 输出结果： map[脑子进煎鱼了:记得点赞！] 结果是修改成功，输出了 “记得点赞！”。这下就尴尬了，为什么是值传递，又还能做到类似引用的效果，能修改到源值呢？ 这里的小窍门是： func makemap(t *maptype, hint int, h *hmap) *hmap {} 这是创建 map 类型的底层 runtime 方法，注意其返回的是 *hmap 类型，是一个指针。也就是 Go 语言通过对 map 类型的相关方法进行封装，达到了用户需要关注指针传递的作用。 就是说当我们在调用 hello 方法时，其相当于是在传入一个指针参数 hello(*hmap)，与前面的值类型的案例二类似。 这类情况我们称其为 “引用类型”，但 “引用类型” 不等同于就是传引用，又或是引用传递了，还是有比较明确的区别的。 在 Go 语言中与 map 类型类似的还有 chan 类型： func makechan(t *chantype, size int) *hchan {} 一样的效果。 3.2 slice 针对 slice 类型，进一步展开来看看例子： func main() { s := []string{"烤鱼", "咸鱼", "摸鱼"} fmt.Printf("main 内存地址：%p\n", s) hello(s) fmt.Println(s) } func hello(s []string) { fmt.Printf("hello 内存地址：%p\n", s) s[0] = "煎鱼" } 输出结果： main 内存地址：0xc000098180 hello 内存地址：0xc000098180 [煎鱼 咸鱼 摸鱼] 从结果来看，两者的内存地址一样，也成功的变更到了变量 s 的值。这难道不是引用传递吗，煎鱼翻车了？ 关注两个细节： 没有用 & 来取地址。 可以直接用 %p 来打印。 之所以可以同时做到上面这两件事，是因为标准库 fmt 针对在这一块做了优化： func (p *pp) fmtPointer(value reflect.Value, verb rune) { var u uintptr switch value.Kind() { case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer: u = value.Pointer() default: p.badVerb(verb) return } 留意到代码 value.Pointer，标准库进行了特殊处理，直接对应的值的指针地址，当然就不需要取地址符了。 标准库 fmt 能够输出 slice 类型对应的值的原因也在此： func (v Value) Pointer() uintptr { ... case Slice: return (*SliceHeader)(v.ptr).Data } } type SliceHeader struct { Data uintptr Len int Cap int } 其在内部转换的 Data 属性，正正是 Go 语言中 slice 类型的运行时表现 SliceHeader。我们在调用 %p 输出时，是在输出 slice 的底层存储数组元素的地址。 下一个问题是：为什么 slice 类型可以直接修改源数据的值呢。 其实和输出的原理是一样的，在 Go 语言运行时，传递的也是相应 slice 类型的底层数组的指针，但需要注意，其使用的是指针的副本。严格意义是引用类型，依旧是值传递。 妙不妙？ 3、总结 在今天这篇文章中，我们针对 Go 语言的日经问题：“Go 语言到底是传值（值传递），还是传引用（引用传递）” 进行了基本的讲解和分析。 另外在业内中，最多人犯迷糊的就是 slice、map、chan 等类型，都会认为是 “引用传递”，从而认为 Go 语言的 xxx 就是引用传递，我们对此也进行了案例演示。 这实则是不大对的认知，因为：“如果传过去的值是指向内存空间的地址，是可以对这块内存空间做修改的”。 其确实复制了一个副本，但他也借由各手段（其实就是传指针），达到了能修改源数据的效果，是引用类型。 石锤，Go 语言只有值传递， 到此这篇关于关于Go 是传值还是传引用?的文章就介绍到这了,更多相关Go语言 是传值还是传引用内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言: 在 Go 语言中，有一个比较特殊的类型，经常会有刚接触 Go 的小伙伴问到，又或是不理解。 他就是 Go 里的空结构体（struct）的使用，常常会有看到有人使用： ch := make(chan struct{}) 还清一色的使用结构体，也不用其他类型。高度常见，也就不是一个偶发现象了，肯定是背后必然有什么原因。 1、为什么使用 说白了，就是希望节省空间。但，新问题又来了，为什么不能用其他的类型来做？ 这就涉及到在 Go 语言中 ”宽度“ 的概念，宽度描述了一个类型的实例所占用的存储空间的字节数。 宽度是一个类型的属性。在 Go 语言中的每个值都有一个类型，值的宽度由其类型定义，并且总是 8 bits 的倍数。 在 Go 语言中我们可以借助 unsafe.Sizeof 方法，来获取： // Sizeof takes an expression x of any type and returns the size in bytes // of a hypothetical variable v as if v was declared via var v = x. // The size does not include any memory possibly referenced by x. // For instance, if x is a slice, Sizeof returns the size of the slice // descriptor, not the size of the memory referenced by the slice. // The return value of Sizeof is a Go constant. func Sizeof(x ArbitraryType) uintptr 该方法能够得到值的宽度，自然而然也就能知道其类型对应的宽度是多少了。 我们对应看看 Go 语言中几种常见的类型宽度大小： func main() { var a int var b string var c bool var d [3]int32 var e []string var f map[string]bool fmt.Println( unsafe.Sizeof(a), unsafe.Sizeof(b), unsafe.Sizeof(c), unsafe.Sizeof(d), unsafe.Sizeof(e), unsafe.Sizeof(f), ) } 输出结果： 8 16 1 12 24 8 你可以发现我们列举的几种类型，只是单纯声明，我们也啥没干，依然占据一定的宽度。 如果我们的场景，只是占位符，那怎么办，系统里的开销就这么白白浪费了？ 2、空结构体的特殊性 空结构体在各类系统中频繁出现的原因之一，就是需要一个占位符。而恰恰好，Go 空结构体的宽度是特殊的。 如下： func main() { var s struct{} fmt.Println(unsafe.Sizeof(s)) } 输出结果： 0 空结构体的宽度是很直接了当的 0，即便是变形处理： type S struct { A struct{} B struct{} } func main() { var s S fmt.Println(unsafe.Sizeof(s)) } 其最终输出结果也是 0，完美切合人们对占位符的基本诉求，就是占着坑位，满足基本输入输出就好。 但这时候问题又出现了，为什么只有空结构会有这种特殊待遇，其他类型又不行？ 这是 Go 编译器在内存分配时做的优化项 // base address for all 0-byte allocations var zerobase uintptr func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer { ... if size == 0 { return unsafe.Pointer(&zerobase) } } 当发现 size 为 0 时，会直接返回变量 zerobase 的引用，该变量是所有 0 字节的基准地址，不占据任何宽度。 因此空结构体的广泛使用，是 Go 开发者们借助了这个小优化，达到了占位符的目的。 3、使用场景 了解清楚为什么空结构作为占位符使用的原因后，我们更进一步了解其真实的使用场景有哪些。 主要分为三块： 实现方法接收者。 实现集合类型。 实现空通道。 3.1 实现方法接收者 在业务场景下，我们需要将方法组合起来，代表其是一个 ”分组“ 的，便于后续拓展和维护。 但是如果我们使用： type T string func (s *T) Call() 又似乎有点不大友好，因为作为一个字符串类型，其本身会占据定的空间。 这种时候我们会采用空结构体的方式，这样也便于未来针对该类型进行公共字段等的增加。如下： type T struct{} func (s *T) Call() { fmt.Println("脑子进煎鱼了") } func main() { var s T s.Call() } 在该场景下，使用空结构体从多维度来考量是最合适的，易拓展，省空间，最结构化。 另外你会发现，其实你在日常开发中下意识就已经这么做了，你可以理解为设计模式和日常生活相结合的另类案例。 3.2 实现集合类型 在 Go 语言的标准库中并没有提供集合（Set）的相关实现，因此一般在代码中我们图方便，会直接用 map 来替代。 但有个问题，就是集合类型的使用，只需要用到 key（键），不需要 value（值）。 这就是空结构体大战身手的场景了： type Set map[string]struct{} func (s Set) Append(k string) { s[k] = struct{}{} } func (s Set) Remove(k string) { delete(s, k) } func (s Set) Exist(k string) bool { _, ok := s[k] return ok } func main() { set := Set{} set.Append("煎鱼") set.Append("咸鱼") set.Append("蒸鱼") set.Remove("煎鱼") fmt.Println(set.Exist("煎鱼")) } 空结构体作为占位符，不会额外增加不必要的内存开销，很方便的就是解决了。 3.3 实现空通道 在 Go channel 的使用场景中，常常会遇到通知型 channel，其不需要发送任何数据，只是用于协调 Goroutine 的运行，用于流转各类状态或是控制并发情况。 如下： func main() { ch := make(chan struct{}) go func() { time.Sleep(1 * time.Second) close(ch) }() fmt.Println("脑子好像进...") <-ch fmt.Println("煎鱼了！") } 输出结果： 脑子好像进... 煎鱼了！ 该程序会先输出 ”脑子好像进...“ 后，再睡眠一段时间再输出 "煎鱼了！"，达到间断控制  channel 的效果。 由于该 channel 使用的是空结构体，因此也不会带来额外的内存开销。 到此这篇关于关于Go 空结构体的 3 种使用场景的文章就介绍到这了,更多相关Go语言 空结构体的 3 种使用场景内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

最近开始实习，工作技术栈主要Python和Golang，目前的任务把Python模块重构为GO模块，然后出现了一个问题，就是要将一个结构体按结构体中各个字段进行排序，然后写入Redis,对于Pyhon来说for循环就能解决，但是对于Go语言来说，每一次排序都要写一个比较函数，写出来的代码太丑，非常长，代码结构是一致，只是比较字段不一样而已，个人无法接受啊，网上搜索也没搜索到合适解决方法，所以自己想了一个解决方法来优雅排序。 比较函数： func reflectCmp(i, j interface{}, fieldName string) bool { //按传入fieldName 排序 valI := reflect.ValueOf(i).FieldByName(fieldName).Interface() valJ := reflect.ValueOf(j).FieldByName(fieldName).Interface() switch s := valI.(type) { case string: return s < valJ.(string) case float64: return s < valJ.(float64) case int: return s < valJ.(int) default: fmt.Println("The type is unknown") } return true } 将自己要比较的类型加入switch中即可。 假设我们有一个结构体为 type person struct { Age int Name string } 那么如何来排序呢？ func main() { pSlice := []person{{20,"a"},{15,"be"},{32,"cc"},{2,"aa"}} var p person typeOfA := reflect.TypeOf(p) // 遍历结构体所有成员 for i := 0; i < typeOfA.NumField(); i++ { // 获取每个成员的结构体字段类型 fieldType := typeOfA.Field(i) sort.Slice(pSlice,func(i, j int) bool { return reflectCmp(pSlice[i],pSlice[j],fieldType.Name) }) fmt.Println(pSlice) } }  运行结果 利用反射，不管结构体有多少个字段，我们都能用一个for 排序即可优雅完成排序。 到此这篇关于Golang 利用反射对结构体优雅排序的文章就介绍到这了,更多相关Go语言反射结构体排序内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、for循环 Go 语言中没有 while 循环，只有一个 for 循环 for 变量初始化;条件;变量自增/自减 {循环体内容 } 1、基本使用 for i := 0; i < 10; i++ { fmt.Println(i) } 2、省略第一部分 i := 0 for ; i < 10; i++ { fmt.Println(i) } 3、省略第一和三部分（这是一个 while 循环） for 条件 { 循环体内容 } i := 0 for i < 10 { fmt.Println(i) i++ } 4、死循环 for { fmt.Println("死循环") } 5、开多协程演示 for i := 0; i < 2000; i++ { go test() } func test() { for { fmt.Println("死循环") } } 6、break 结束本次 for 循环，continue 结束本次循环，继续下一次循环 二、Switch语句 Switch 是一个条件语句，用于将表达式的值与可能匹配的选项列表进行比较，并根据匹配情况执行相应的代码块，它可以被认为是替代多个 if else 语句的常用方式 1、基本使用 num := 4 switch num { case 1: fmt.Println("1") case 2: fmt.Println("2") case 3: fmt.Println("3") case 4: fmt.Println("4") } // 输出 4 2、默认情况（都没有匹配上） num := 5 switch num { case 1: fmt.Println("1") case 2: fmt.Println("2") case 3: fmt.Println("3") case 4: fmt.Println("4") default: fmt.Println("都没有匹配上") } // 输出 都没有匹配上 3、多表达式判断 num := 44 switch num { case 11, 12, 13, 14: fmt.Println("1") case 21, 22: fmt.Println("2") case 31, 33: fmt.Println("3") case 40, 43, 44: fmt.Println("4") default: fmt.Println("都没有匹配上") } // 输出 4 4、无表达式的 Switch num := 44 switch { case num == 11, num == 12: fmt.Println(11, 12) case num == 40, num == 44: fmt.Println(40, 44) } // 输出 40 44 5、Fallthrough 穿透，只要看到 fallthrough，无条件执行下一个 case 或者 default num := 12 switch { case num == 11, num == 12: fmt.Println(11, 12) fallthrough case num == 40, num == 44: fmt.Println(40, 44) fallthrough default: fmt.Println("无匹配") } // 输出 11 12 40 44 无匹配 到此这篇关于Go语言之fo循环与条件判断的文章就介绍到这了,更多相关Go语言语言循环与条件判断内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、Goroutine Go 协程可以看做成一个轻量级的线程，Go 协程相比于线程的优势： Goroutine 的成本更低大小只有 2kb 左右，线程有几个兆。 Goroutine 会复用线程，比如说：我有 100 个协程，但是都是共用的的 3 个线程。 Goroutine 之间通信是通过 channel 通信的。（Go 推崇的是信道通信，而不推崇用共享变量通信） 1、启动一个 Goroutine func test() { fmt.Println("go go go") } func main() { fmt.Println("主线程开始") // go 关键字开启 Goroutine，一个 Goroutine只占2kb左右 go test() // 一个 go 就是一个协程，多个就是多个协程，也可以for循环起多个协程 go test() time.Sleep(1*time.Second) // Go 语言中主线程不会等待Goroutine执行完成，要等待它结束需要自己处理 fmt.Println("主线程结束") } // 输出： 主线程开始 go go go go go go 主线程结束 2、Go 语言的GMP模型 G：就是我们开起的 Goroutine 它们会被相对平均的放到 P 的队列中 M：M 可以当成操作系统真正的线程，但是实际上是用户态的线程（用户线程） 虽然 M 执行 G，但是实际上，M 只是映射到操作系统的线程上执行的 然后操作系统的调度器把真正的操作系统的线程调度到CPU上执行 P：Processor 1.5版本以后默认情况是 CPU 核数（可以当做CPU核数） P 会和 M 做交互，真正执行的是 M 在执行 G ，只不过 P 是在做调度 一旦某个 G 阻塞了，那么 P 就会把它调度成下一个 G，放到 M 里面去执行 用户线程操作系统线程： 在 Python 中，用户线程跟操作系统线程是 1:1 的对应关系 Go 语言中，用户线程和操作系统线程是 m：n 的关系 二、信道 信道（Channel）也就是 Go 协程之间的通信管道，一端发送一端接收。 func main() { // 1、定义 channel var c chan int // 2、管道的零值 //———>空值为 nil 说明是引用类型，当做参数传递时，不需要取地址，改的就是原来的，需要初始化在使用 fmt.Println(c) // 输出：<nil> // 3、管道初始化 c = make(chan int) go test(c) // c 是引用类型直接传 // 4、从信道中取值，信道默认不管放值还是取值，都是阻塞的 count := <-c // 阻塞 fmt.Println(count) /* 当程序执行 go test(c) 时就开了一个 Goroutine 然后继续执行到 count := <-c 从信道取值，这时就阻塞住了 它会等待 Goroutine 往信道中放值后才会取出值，才会继续执行 fmt.Println(count) */ } func test(c chan int) { fmt.Println("GO GO GO") time.Sleep(1 * time.Second) // 5、往信道中放一个值，信道默认不管放值还是取值，都是阻塞的 c <- 1 // 阻塞 } // 输出： <nil> GO GO GO 1 1、死锁 当 Goroutine 给一个信道放值的时候，按理会有其他 Goroutine 来接收数据，没有的话就会形成死锁。 func main() { c := make(chan int) c <- 1 } // 报错：应为没有其他 Goroutine 从 c 中取值 2、单向信道 显而易见就是只能读或者只能写的信道 方式一： func WriteOnly(c chan<- int) { c <- 1 } func main() { write := make(chan<- int) // 只写信道 go WriteOnly(write) fmt.Println(<-write) // 报错 ——>只写信道往外取就报错 } 方式二： func WriteOnly(c chan<- int) { c <- 1 // <-c // 报错 } func main() { write := make(chan int) // 定义一个可读可写信道 go WriteOnly(write) // 传到函数中就成了只写信道，在Goroutine中只负责写，不能往外读 fmt.Println(<-write) // 主协程读 } 3、for 循环信道 for 循环循环信道，如果不关闭，会报死锁，如果关闭了，放不进去，循环结束。 func producer(chnl chan int) { for i := 0; i < 10; i++ { chnl <- i // i 放入信道 } close(chnl) // 关闭信道 } func main() { ch := make(chan int) go producer(ch) // 循环获取信道内容 for value := range ch { fmt.Println(value) } } /* 当 for 循环 range ch 的时候信道没有值，会阻塞等待 go producer(ch) 开起的 Goroutine 中放入值 当 Goroutine 中放入一个值，就会阻塞，那么 range ch 就会取出一个值，然后再次阻塞等待 直到 Goroutine 放入值完毕关闭信道，for 循环 range ch 也就结束循环了 */ 4、缓冲信道 在默认情况下信道是阻塞的，缓冲信道也就是说我信道里面可以缓冲一些东西，可以不阻塞了。 只有在缓冲已满的情况，才会阻塞信道 只有在缓冲为空的时候，才会阻塞主缓冲信道接收数据 func main() { // 指定的数字就是缓冲大小 var c chan int = make(chan int, 3) // 无缓冲信道数字是0 c <- 1 c <- 2 c <- 3 c <- 4 // 缓冲满了，死锁 <-c <-c <-c <-c // 取空了，死锁 fmt.Println(len(c)) // 长度：目前放了多少 fmt.Println(cap(c)) // 容量：可以最多放多少 } 5、WaitGroup 等待所有 Goroutine 执行完成 func process1(i int, wg *sync.WaitGroup) { fmt.Println("started Goroutine ", i) time.Sleep(2 * time.Second) fmt.Printf("Goroutine %d ended\n", i) // 3、一旦有一个完成，减一 wg.Done() } func main() { var wg sync.WaitGroup // 没有初始化，值类型，当做参数传递，需要取地址 for i := 0; i < 10; i++ { wg.Add(1) // 1、启动一个 Goroutine，add 加 1 go process1(i, &wg) // 2、把wg传过去，因为要改它并且它是值类型需要取地址传过去 } wg.Wait() // 4、一直阻塞在这，直到调用了10个 Done，计数器减到零 } 6、Select Select 语句用于在多个发送 / 接收信道操作中进行选择。 例如：我要去爬百度，我发送了三个请求去，可能有一些网络原因，或者其他原因，不一定谁先回来，Select 选择就是谁先回来我先用谁。 场景一：对性能极致的要求，我就可以选择一个最快的线路执行我最快的功能，就可以用Select来做 场景二：我去拿这个数据的时候，不是一直等在这里，而是我可以干一点别的事情，使用死循环 Select 的时候加上 default 去做其他事情。 // 模拟去服务器去取值 func server(ch chan string) { time.Sleep(3 * time.Second) ch <- "from server" } func main() { output1 := make(chan string) output2 := make(chan string) // 开起两个协程执行 server go server(output1) go server(output2) select { case s1 := <-output1: // 阻塞，谁先回来就执行谁 fmt.Println(s1, "output1") case s2 := <-output2: // 阻塞，谁先回来就执行谁 fmt.Println(s2, "output2") } } 7、Mutex 使用锁的场景：多个 Goroutine 通过共享内存来实现数据通信，就会出现并发安全的问题，并发安全的问题就需要加锁。 临界区：当程序并发运行时修改共享资源的代码，也就同一块内存的变量的时候，这些修改的资源的代码就称为临界区。 如果在任意时刻只允许一个 Goroutine 访问临界区，那么就可以避免竞争条件，而使用 Mutex（锁） 可以实现 不加用锁的情况下： var x = 0 //全局，各个 Goroutine 都可以拿到并且操作 func increment(wg *sync.WaitGroup) { x = x + 1 wg.Done() } func main() { var w sync.WaitGroup for i := 0; i < 1000; i++ { w.Add(1) go increment(&w) } w.Wait() fmt.Println("最终的值：", x) } // 输出：理想情况下是1000，因为并发有安全的问题，所以数据乱了 最终的值： 978 加锁的情况： var x = 0 //全局，各个 Goroutine 都可以拿到并且操作 func increment(wg *sync.WaitGroup, m *sync.Mutex) { m.Lock() // 加锁 x = x + 1 // 同一时间只能有一个 Goroutine 执行 m.Unlock() // 解锁 wg.Done() } func main() { var w sync.WaitGroup var m sync.Mutex // 因为是个值类型，函数传递需要传地址 fmt.Println(m) // 输出：{0 0} ——>值类型 for i := 0; i < 1000; i++ { w.Add(1) go increment(&w, &m) } w.Wait() fmt.Println("最终的值：", x) } // 输出： 最终的值： 1000 使用信道来实现： var x = 0 func increment(wg *sync.WaitGroup, ch chan bool) { ch <- true // 缓冲信道放满了，就会阻塞。 x = x + 1 <-ch // 执行完了就取出 wg.Done() } func main() { var w sync.WaitGroup ch := make(chan bool, 1) // 定义了一个有缓存大小为1的信道 for i := 0; i < 1000; i++ { w.Add(1) go increment(&w, ch) } w.Wait() fmt.Println("最终的值：", x) } // 输出： 最终的值：1000 总结：不同 Goroutine 之间传递数据的方式：共享变量、信道。 如果是修改变量，倾向于用 Mutex 如果是 Goroutine 之间通信，倾向于用信道 三、异常处理 defer：延时执行，并且即便程序出现严重错误，也会执行 func main() { defer fmt.Println("我最后执行") defer fmt.Println("我倒数第三执行") fmt.Println("我先执行") var a []int fmt.Println(a[10]) // 报错 fmt.Println("后执行") // 不会执行了 } // 输出： 我先执行 我倒数第三执行 我最后执行 panic: runtime error: index out of range [10] with length 0 panic：主动抛出异常 recover：恢复程序，继续执行 func f1() { fmt.Println("f1 f1") } func f2() { defer func() { // 这个匿名函数永远会执行 //如果没有错误，执行 recover 会返回 nil，如果有错误执行 recover 会返回错误信息 if error := recover(); error != nil { // 表示出错了，打印一下错误信息，程序恢复了，继续执行 fmt.Println(error) } fmt.Println("我永远会执行，不管是否出错") }() fmt.Println("f2 f2") panic("主动抛出错误") } func f3() { fmt.Println("f3 f3") } func main() { //捕获异常，处理异常，让程序继续运行 f1() f2() f3() } Go 语言异常捕获与 Python 异常捕获对比 Python： try: 可能会错误的代码 except Exception as e： print(e) finally： 无论是否出错，都会执行的代码 Go ： defer func() { if error:=recover();error!=nil{ // 错误信息 error fmt.Println(error) } 相当于finally，无论是否出错，都会执行的代码 }() 可能会错误的代码 到此这篇关于Go语言之Goroutine与信道异常处理的文章就介绍到这了,更多相关Go语言语言Goroutine与信道异常处理内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、数组 数组是同一类型元素的集合，可以放多个值，但是类型一致，内存中连续存储 Go 语言中不允许混合不同类型的元素，而且数组的大小，在定义阶段就确定了，不能更改 1、数组的定义 // 定义一个大小为3的string类型和int8类型的数组，里面可以放3个字符串和3个数字 var names [3]string var ages [3]int8 fmt.Println(names, ages) // 输出：[ ] [0 0 0] 2、数组赋值 var ages [3]int8 ages[0] = 18 ages[2] = 22 fmt.Println(ages) fmt.Println(ages[1]) // 输出 [18 0 22] 0 3、定义并初始化 // 方式一： var ages [3]int = [3]int{1, 2, 3} fmt.Println(ages) // 输出：[1 2 3] // 方式二： var ages = [3]int{1, 2, 3} fmt.Println(ages) // 输出：[1 2 3] // 方式三：...后面放几个值，数组大小就是多少 var ages = [...]int{1, 2, 3, 4, 5, 6, 7, 8} fmt.Println(ages) // 输出：[1 2 3 4 5 6 7 8] // 方式四： ages := [...]int{1, 2, 3, 4, 8} fmt.Println(ages) // 输出：[1 2 3 4 8] 4、数组的大小是类型的一部分 var a [2]int = [2]int{1, 2} var b [2]int = [2]int{1, 3} b = a // 如果不是同一种类型，不允许相互赋值 fmt.Println(b) 5、数组是值类型 因为数组是值类型，Go 函数传参，都是 copy 传递，如果是值类型，函数内改了，不会影响原来的 var a = [2]int{1, 2} fmt.Println(a) // [1 2] test(a) // [99 2] fmt.Println(a) // [1 2] func test(a [2]int) { a[0] = 99 fmt.Println(a) } 6、数组长度 len() 数组长度在定义阶段已经固定 var a = [2]int{1, 2} fmt.Println(len(a)) // 输出：2 7、数组循环 // 普通循环 var a = [...]int{7, 6, 5, 4, 3, 2, 1} for i := 0; i < len(a); i++ { fmt.Println(a[i]) } // 通过 range 来循环（range不是一个内置函数，是一个关键字如：for，if，else） // 如果用一个变量接收，这个值是可迭代的索引 // 如果用两个变量接收，这两个变量一个是索引，一个是具体的值 var a = [...]int{7, 6, 5, 4, 3, 2, 1} for i, value := range a { fmt.Println(i) // 索引 fmt.Println(value) // 值 } // 不要索引只要值循环打印 for _, value := range a { fmt.Println(value) } 8、多维数组 var a [3][3]int // 定义 a[0][1] = 20 // 使用 fmt.Println(a) // 输出：[[0 20 0] [0 0 0] [0 0 0]] // 定义并赋初始值 var a [3][3]int = [3][3]int{{1}, {2, 3, 4}, {5, 6}} fmt.Println(a) // 输出：[[1 0 0] [2 3 4] [5 6 0]] // 循环多维数组 var a [3][3]int = [3][3]int{{1}, {2, 3, 4}, {5, 6}} for _, value := range a { for _, inValue := range value { fmt.Println(inValue) } } 9、数组定义并指定位置初始化 // 在索引为5和7的位置指定初始化值 var ages [10]int = [10]int{5: 55, 7: 77} fmt.Println(ages) // 输出：[0 0 0 0 0 55 0 77 0 0] 二、切片基础 切片是由数组建立的一种方案、灵活且功能强大的包装（Wrapper）。 它本身不拥有任何数据，只对现有数组的引用。 1、切片的定义 // 定义一个数组 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} // 基于数组，做一个切片 b := a[:] fmt.Println(b) // 输出：[9 8 7 6 5 4 3 2 1 0] fmt.Printf("%T", b) // 输出：[]int 中括号中不带东西，就是切片类型 fmt.Println(a) // 输出：[9 8 7 6 5 4 3 2 1 0] fmt.Printf("%T", a) // 输出：[10]int 2、使用切片 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} b := a[:] fmt.Println(b[0]) // 输出：9 fmt.Println(b[2]) // 输出：7 3、修改切片，会影响数组 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} b := a[:] b[0] = 99 // 修改切片 fmt.Println(b) // 输出：[99 8 7 6 5 4 3 2 1 0] // 数组会被修改 fmt.Println(a) // 输出：[99 8 7 6 5 4 3 2 1 0] 4、修改数组也会影响切片 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} b := a[:] a[1] = 99 // 修改数组 fmt.Println(a) // 输出：[9 99 7 6 5 4 3 2 1 0] // 切片也会被修改 fmt.Println(b) // 输出：[9 99 7 6 5 4 3 2 1 0] 5、切片只切数组的一部分 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} b := a[3:6] // 修改切片 b[0] = 66 fmt.Println(b) // 输出：[66 5 4] fmt.Println(a) // 输出：[9 8 7 66 5 4 3 2 1 0] // 修改数组 a[4] = 55 fmt.Println(b) // 输出：[66 55 4] fmt.Println(a) // 输出：[9 8 7 66 55 4 3 2 1 0] 6、当多个切片共用相同的底层数组时，每个切片所做的更改将反应在数组中 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} b := a[3:5] c := a[4:6] fmt.Println(a) // 输出：[9 8 7 6 5 4 3 2 1 0] fmt.Println(b) // 输出：[6 5] fmt.Println(c) // 输出：[5 4] b[1] = 555 fmt.Println(a) // 输出：[9 8 7 6 555 4 3 2 1 0] fmt.Println(b) // 输出：[6 555] fmt.Println(c) // 输出：[555 4] 7、切片的长度和容量 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} b := a[3:7] fmt.Println(b) // 输出：[6 5 4 3] fmt.Println(a) // 输出：[9 8 7 6 5 4 3 2 1 0] // 切片长度 fmt.Println(len(b)) // 输出：4 // 切片容量（我最多能存多少值，从切片的起始位置开始往后所有的，从索引为3开始） fmt.Println(cap(b)) // 输出：7 8、切片追加值 var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} b := a[6:8] b = append(b,11) b = append(b,22) fmt.Println(a) // 输出：[9 8 7 6 5 4 3 2 11 22] // 追加到临界点了在追加 b = append(b,33) b = append(b,44) fmt.Println(a) // 输出：[9 8 7 6 5 4 3 2 11 22] fmt.Println(b) // 输出：[3 2 11 22 33 44] // 数组长度不会在变了，他会在原来基础上翻倍，把我原来那个值copy到我新的数组上a和b已经没有关系了 b[0] = 33 fmt.Println(b) // 输出：[33 2 11 22 33 44] fmt.Println(a) // 输出：[9 8 7 6 5 4 3 2 11 22] 到此这篇关于详细介绍Go语言语言之数组与切片的文章就介绍到这了,更多相关Go语言之数组与切片内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、结构体 结构体是一系列属性的集合（类似于 Python 中的类） 1、结构体的定义与使用 // 定义 type Personstruct { Name string Age int Sex string } func main() { // 使用 var per Person per.Name="XiaoYang" fmt.Println(per) } 2、定义并赋初值 type Person struct { Name string Age int Sex string } func main() { var per1 Person = Person{Name: "XiaoYang"} // 按关键字传参，可以少传 var per2 Person = Person{"Bob", 20, "男"} // 按位置传参，全传 fmt.Println(per1) // 输出：{XiaoYang 0 } fmt.Println(per2) // 输出：{Bob 20 男} } 3、匿名结构体（只使用一次，没有名字） // 定义个匿名结构体并实例化之后赋值给了 hobby 变量 hobby := struct { HobbyId int HobbyName string }{HobbyId: 1, HobbyName: "篮球"} fmt.Println(hobby) // 输出：{1 篮球} fmt.Println(hobby.HobbyName) // 输出：篮球 4、结构体的零值 定义好的结构体没有被初始化时，该结构体的字段将默认赋值为零值 也就是我属性的零值，所以他是值类型，参数传递，copy 传递，在函数中修改不会影响原来的 type Person struct { Name string Age int Sex string } func main() { var per Person=Person{"Bob", 20, "男"} fmt.Println(per) // 输出：{Bob 20 男} test(per) // 输出：{Bob 20 男} fmt.Println(per) // 输出：{Bob 20 男} } func test(per Person) { per.Age=20 fmt.Println(per) } 5、结构体的指针 // & 放在变量前，表示取该变量的地址 // * 放在类型前，表示指向该类型的指针（变量定义，指定类型时才会用到） *[3]int 和 [3]*int // * 放在变量前，表示解引用（取出指针指向的具体的值） type Person struct { Name string Age int Sex string } func main() { var per1 *Person fmt.Println(per1) // 输出：<nil> 表示指针类型 // 定义并初始化 var per2 *Person = &Person{} fmt.Println(per2) // 输出：&{ 0 } // 把per2的名字改成XiaoYang (*per2).Name = "XiaoYang" // 也支持直接使用 per2.Name = "Bob" fmt.Println(per2) // 输出：&{Bob 0 } } 6、匿名字段（字段没有名字，只有类型） 可用于【变量提升 / 提升字段】类似于面向对象的继承 // 定义一个结构体，匿名字段类型就是字段名字，所有类型不能重复 type Person struct { string int Sex string } func main() { per := Person{"XiaoYang", 20, "男"} // 字段匿名，类型就是字段名 fmt.Println(per) // 输出：{XiaoYang 20 男} fmt.Println(per.string) // 输出：XiaoYang } 7、嵌套结构体（结构体中套结构体） type Person struct { Name string Age int Sex string Hobby Hobby // Person中嵌套Hobby结构体字段 } type Hobby struct { HobbyId int HobbyName string } func main() { per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}} fmt.Println(per) // 输出：{XiaoYang 20 男 {1 篮球}} fmt.Println(per.Name) // 输出：XiaoYang fmt.Println(per.Hobby.HobbyName) // 输出：篮球 } 8、字段提升 结构体中有匿名的结构体类型字段，则该匿名结构体里的字段就称为提升字段，可以从外部直接访问 type Person struct { Name string Age int Sex string Hobby // Person中嵌套Hobby匿名结构体字段 } type Hobby struct { HobbyId int HobbyName string } func main() { per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}} // 打印爱好的名字（Hobby是一个匿名字段，会字段提升） fmt.Println(per.HobbyName) // 输出：篮球 // per.hobby 类似于面向对象中的super() fmt.Println(per.Hobby.HobbyName) // 输出：篮球 } // ------------------------------------------------------------------------------------ // 当子类和父类中的字段名一样时，就像面向对象的继承，子类继承父类（结构体嵌套，匿名字段），子类可以直接调用父类中的属性或方法 type Person struct { Name string Age int Sex string Hobby // Person中嵌套Hobby匿名字段 } type Hobby struct { HobbyId int Name string } func main() { per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}} fmt.Println(per.Name) // 输出：XiaoYang ——>优先使用自己的 fmt.Println(per.Hobby.Name) // 输出：篮球 ——>指定打印Hobby的名字 } 9、结构体相等性 结构体是值类型。 如果它的每一个字段都是可比较的，则该结构体也是可以比较的。 如果两个结构体变量的对应字段相等，则两个变量也是相等的。 如果结构体包含不可比较的字段，则结构体变量也不可比较。 type Person struct { Name string Age int Sex string // 包含不可比较的字段 Test []int ——>这是引用类型不可比较 } func main() { // 值类型可以直接==比较，引用类型只能跟nil用==比较 per1 := Person{Name: "XiaoYang"} per2 := Person{Name: "XiaoYang"} per3 := Person{Name: "XiaoYang", Age: 20} fmt.Println(per1 == per2) // 输出：ture ——>包含不可比较类型都会直接报错 fmt.Println(per1 == per3) // 输出：false } 二、方法 方法就是一个特殊函数，在函数的基础上加了一些东西 在func这个关键字和方法名中间加入一个特殊的接收器类型，接收器可以是结构体类型，也可以是非结构体类型 1、方法的定义和使用 type Person struct { Name string Age int Sex string } // 定义一个方法：给Person结构体绑定一个方法，oneself（名字随便取）类似于Python类中的self func (oneself Person) printName() { // 在方法内使用oneself fmt.Println(oneself.Name) } func main() { // 使用，对象调用方法 per := Person{} per.Name = "XiaoYang" // 绑定给对象的方法 per.printName() // 输出：XiaoYang } 2、有了函数为啥还需要方法？ 方法功能都能实现，但是呢？它就能指定给某个对象了 。 type Person struct { Name string Age int Sex string } // 方法 func (oneself Person) printName() { fmt.Println(oneself.Name) } // 函数 func printName(oneself Person) { fmt.Println(oneself.Name) } func main() { per := Person{Name: "XiaoYang"} per.printName() // 方法的特殊之处，可以自动传递值 printName(per) // 函数需要手动传递值 } 3、指针接收器与值接收器 type Person struct { Name string Age int Sex string } // 值接收器修改名字 func (oneself Person) changeName(name string) { oneself.Name = name } // 指针接收器修改年龄 func (oneself *Person) changeAge(age int) { oneself.Age = age } func main() { per := Person{Name: "XiaoYang", Age: 20} fmt.Println(per) // 输出：{XiaoYang 20 } per.changeName("Bob")// 由于这个是值接收器，它是copy一份传递过去所以修改的是copy的不会改掉原来的 per.changeAge(18) // 指针接收器，它传递的是指针 fmt.Println(per) // 输出：{XiaoYang 18 } } /* 什么时候用指针接收器，什么时候使用值接收器： -想改原来的，就用指针 -不想改原来的，就用值 */ 5、匿名字段的方法（方法提升） type Person struct { Name string Age int Sex string Hobby // 匿名字段 } type Hobby struct { Id int Name string } // 打印Person的名字 func (oneself Person) printName() { fmt.Println(oneself.Name) } // 打印Hobby的名字 func (oneself Hobby) printHobbyName() { fmt.Println(oneself.Name) } // 打印Hobby的名字 func (oneself Hobby) printName() { fmt.Println(oneself.Name) } func main() { per := Person{Name: "XiaoYang", Hobby: Hobby{1, "篮球"}} per.printName() // 输出：XiaoYang per.printHobbyName() // 输出：篮球 // 如果方法重名了，优先使用结构体自己的 per.printName() // 输出：XiaoYang per.Hobby.printName() // 输出：篮球 } 6、在方法中使用值接收器 与 在函数中使用值参数 type Person struct { Name string Age int Sex string } // 在方法中使用值接收器 func (oneself Person) printName() { fmt.Println(oneself.Name) } // 在函数中使用值参数 func printName(oneself Person) { fmt.Println(oneself.Name) } func main() { per1 := &Person{Name: "XiaoYang"} // per1是个指针 per2 := Person{Name: "Bob"} printName(*per1) // 输出：XiaoYang per1.printName() // 输出：XiaoYang ———> 值收器:可以用值来调，也可以用指针来调 per2.printName() // 输出：Bob } 7、在方法中使用指针接收器 与 在函数中使用指针参数 type Person struct { Name string Age int Sex string } // 在方法中使用指针接收器 func (oneself *Person) printName() { fmt.Println(oneself.Name) } func (oneself *Person)changeName(name string) { oneself.Name=name } // 在函数中使用指针参数 func printName(oneself *Person) { fmt.Println(oneself.Name) } func main() { per1 := Person{Name: "XiaoYang"} per2 := &Person{Name: "Bob"} // per1是个指针 per1.printName() // 值可以调用 printName(&per1) per2.printName() // 指针可以调用 printName(per2) per1.changeName("Alen") // 可以修改 fmt.Println(per1) per2.changeName("YS") // 可以修改 fmt.Println(per2) } 总结：  -不管是值类型接收器还是指针类型接收器，都可以用值来调用，或者指针来调用。  -不管是值还是指针来调用，只要是值类型接收器，改的就是新的，只要是指针类型接收器，改的是原来的。 8、非结构体上绑定方法 不允许在基础数据类型上绑定方法（如：int、string ... ) 但是自己定义的类型可以绑定方法 type Myint int func (i *Myint) add() { (*i)++ } func main() { var a Myint = 10 fmt.Println(a) // 输出：10 a.add() a.add() a.add() fmt.Println(a) // 输出：13 } 到此这篇关于Go语言语言之结构体与方法的文章就介绍到这了,更多相关Go语言之结构体内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

接口对象的转型有两种方式： 1. 方式一：instance,ok:=接口对象.(实际类型) 　　如果该接口对象是对应的实际类型，那么instance就是转型之后对象，ok的值为true 　　配合if...else if...使用 2. 方式二： 　　接口对象.(type) 　　配合switch...case语句使用 示例： package main import ( "fmt" "math" ) type shape interface { perimeter() int area() int } type rectangle struct { a int // 长 b int // 宽 } func (r rectangle) perimeter() int { return (r.a + r.b) * 2 } func (r rectangle) area() int { return r.a * r.b } type circle struct { radios int } func (c circle) perimeter() int { return 2 * c.radios * int(math.Round(math.Pi)) } func (c circle) area() int { return int(math.Round(math.Pow(float64(c.radios), 2) * math.Pi)) } func getType(s shape) { if i, ok := s.(rectangle); ok { fmt.Printf("长方形的长：%d,长方形的宽是：%d\n", i.a, i.b) } else if i, ok := s.(circle); ok { fmt.Printf("圆形的半径是：%d\n", i.radios) } } func getType2(s shape) { switch i := s.(type) { case rectangle: fmt.Printf("长方形的长：%d,长方形的宽是：%d\n", i.a, i.b) case circle: fmt.Printf("圆形的半径是：%d\n", i.radios) } } func getResult(s shape) { fmt.Printf("图形的周长是：%d,图形的面积是：%d\n", s.perimeter(), s.area()) } func main() { r := rectangle{a: 10, b: 20} getType(r) getResult(r) c := circle{radios: 5} getType2(c) getResult(c) } 上面的例子使用的是方式一，如果要使用方式2，可以将getType()函数改为： func getType(s shape) { switch i := s.(type) { case rectangle: fmt.Printf("图形的长：%.2f，图形的宽：%.2f \n", i.a, i.b) case triangle: fmt.Printf("图形的第一个边：%.2f，图形的第二个边：%.2f，图形的第三个边：%.2f \n",i.a,i.b,i.c) case circular: fmt.Printf("图形的半径：%.2f \n",i.radius) } } PS：上面求三角形面积使用了海伦公式求三角形的面积，公式为： 三角形的面积=平方根[三角形周长的一半×（三角形周长的一半减去第一个边）×（三角形周长的一半减去第二个边)×（三角形周长的一半减去第三个边)] 到此这篇关于golang中接口对象的转型的文章就介绍到这了,更多相关Golang接口对象内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

接口就是一系列方法的集合（规范行为） 在面向对象的领域里，接口一般这样定义：接口定义一个对象的行为，规范子类对象的行为。 在 Go 语言中的接口是非侵入式接口（接口没了，不影响代码），侵入式接口（接口没了，子类报错） Go 也是鸭子类型，比如我现在有个鸭子类，内有 speak 方法和 run 方法，子类只要实现了 speak 和 run，我就认为子类是鸭子，我只要子类中有这两个方法你就是鸭子，有这两个方法你就是鸭子，他是从下往上推导只要有你这里面的东西，那就是算是继承了你这个接口 1、接口的用途 接口是一个类型 // Duck 定义一个鸭子接口 type Duck interface { speak() run() } // WhiteDuck 定义一个白鸭子结构体 type WhiteDuck struct { name string age int sex string } // BlackDuck 定义一个黑鸭子结构体 type BlackDuck struct { name string age int sex string } // 让白鸭子和黑鸭子绑定接口中的所有方法，就叫实现该接口 // 让白鸭子实现 Duck 接口 func (w WhiteDuck) speak() { fmt.Println("白鸭子嘎嘎叫，它的名字叫", w.name) } func (w WhiteDuck) run() { fmt.Println("白鸭子慢悠悠的走，它的名字叫", w.name) } // 让黑鸭子实现 Duck 接口 func (b BlackDuck) speak() { fmt.Println("黑鸭子呱呱叫，它的名字叫", b.name) } func (b BlackDuck) run() { fmt.Println("黑鸭子歪歪扭扭的走，它的名字叫", b.name) } func main() { var duck Duck duck = WhiteDuck{"小白", 15, "男"} // 把我的对象赋值给一个接口类型，就可以实现多态的效果 fmt.Println(duck) // duck 现在他是一个接口，它只能取方法，不能取出属性了。 duck.speak() duck.run() } // 输出： {小白 15 男} 白鸭子嘎嘎叫，它的名字叫 小白 白鸭子慢悠悠的走，它的名字叫 小白 2、类型断言 用于提取接口的底层值，就是把接口类型转成 struct ，属性，自有方法也有了。 func main() { var duck Duck = WhiteDuck{"小白", 15, "男"} // 断言是 WhiteDuck 类型 value, ok := duck.(WhiteDuck) // 断言成功，ok=true，value就是WhiteDuck结构体对象 fmt.Println(value) // 输出：{小白 15 男} fmt.Println(value.name) // 输出：小白 fmt.Println(ok) // 输出：true // 断言失败，ok1=false，value1是BlackDuck类型的空值，因为没有赋值 value1, ok1 := duck.(BlackDuck) fmt.Println(value1) // 输出：{ 0 } fmt.Println(ok1) // 输出：false } 3、类型选择 （通过 Type Switch ） 用于将接口的具体类型与很多 case 语句所指定的类型进行比较。 func main() { var duck Duck = WhiteDuck{"小白", 15, "男"} test(duck) } func test(duck Duck) { switch value := duck.(type) { case WhiteDuck: fmt.Println(value.name) fmt.Println("我是白鸭子") case BlackDuck: fmt.Println(value.name) fmt.Println("我是黑鸭子") default: fmt.Println(value) fmt.Println("我是鸭子这个类") } } 4、空接口 没有任何方法，所有数据类型都实现了空接口 type Empty interface {} // 空接口 func main() { var a int = 10 var b string = "XiaoYang" var c [3]int var e Empty // e是空接口类型,可以接受任意的数据类型 e = a e = b e = c // 这样的话需要把它类型选择回来 // 正常情况下我只能接收 Empty 类型的，但是 a b c 都不是 Empty 类型的 test(a) // 输出：我是int 10 test(b) // 输出：我是字符串 XiaoYang test(c) // 输出：我是数组 [0 0 0] } // 如果这不是一个空接口，比如是 Duck 那么只要实现了 Duck 接口的所有数据类型都可以传 func test(b Empty) { switch v:=b.(type) { case string: fmt.Println("我是字符串", v) case int: fmt.Println("我是int", v) case [3]int: fmt.Println("我是数组", v) } } 5、匿名空接口 没有名字的空接口，一般用在形参上 func main() { var duck Duck = WhiteDuck{"小白", 15, "男"} test(10) test("XiaoYang") test(duck) } // 这叫匿名空接口，所有数据类型都可以往里面传，如果想用原来的结构体还需要类型选择回来才能用 func test(b interface{}) { fmt.Println(b) } 6、实现多个接口 // Duck 定义一个鸭子接口 type Duck interface { speak() run() } type Animal interface { eat() sleep() } // WhiteDuck 定义一个白鸭子结构体 type WhiteDuck struct { name string age int sex string } // 让白鸭子即实现 Duck 接口也实现了 Animal 接口 func (w WhiteDuck) speak() { fmt.Println("白鸭子嘎嘎叫，它的名字叫", w.name) } func (w WhiteDuck) run() { fmt.Println("白鸭子慢悠悠的走，它的名字叫", w.name) } func (w WhiteDuck) eat() { fmt.Println("白鸭子吃饭，它的名字叫", w.name) } func (w WhiteDuck) sleep() { fmt.Println("白鸭子睡觉，它的名字叫", w.name) } func main() { var w WhiteDuck = WhiteDuck{} var a Animal var d Duck // 这样的话我的 w 即可以给 a ，也可以给 d // 但是一旦转到某个接口上，只能使用该接口的方法，自身属性和自身方法需要类型断言后才能使用 a = w // w 给了 a ，那么 a 就只能调用 Animal 接口的方法 a.sleep() a.eat() d = w // w 给了 d ，那么 a 就只能调用 Duck 接口的方法 d.run() d.speak() } 7、接口嵌套 type Duck interface { Animal // Duck 嵌套 Animal 接口 speak() run() } type Animal interface { eat() sleep() } type WhiteDuck struct { name string age int sex string } // 这样白鸭子即实现 Duck 接口也实现了 Animal 接口 func (w WhiteDuck) speak() { fmt.Println("白鸭子嘎嘎叫，它的名字叫", w.name) } func (w WhiteDuck) run() { fmt.Println("白鸭子慢悠悠的走，它的名字叫", w.name) } func (w WhiteDuck) eat() { fmt.Println("白鸭子嘎嘎叫，它的名字叫", w.name) } func (w WhiteDuck) sleep() { fmt.Println("白鸭子慢悠悠的走，它的名字叫", w.name) } func main() { var a Animal var d Duck var w WhiteDuck = WhiteDuck{} // w 即可以给 a，也可以给 d a = w // 但是 a 只能调用 Animal 中的两个方法 a.sleep() a.eat() d = w // d 却能调用 Duck 和 Animal 中的四个方法 d.sleep() d.eat() d.speak() d.run() } 8、接口零值 func main() { var a Animal // nil 就是说明它是一个引用类型 // 其内部表示就已经告诉了我们，它里面就存两个值，一个是它的类型，一个是指向具体值的指针 fmt.Println(a) // 输出：<nil> } 9、make和new的区别 type WhiteDuck struct { name string sex string age int } func main() { var per1 *WhiteDuck = new(WhiteDuck) // new 是返回指向这个类型的指针 // 或者是我取 WhiteDuck 的地址，赋值给 per2 var per2 = &WhiteDuck{} fmt.Println(per1) // 输出：&{ 0} fmt.Println(per2) // 输出：&{ 0} var per3 = make([]int, 3, 4) // make 是具体的创建引用类型 // new 是创建指向这个类型的指针 var per4 = new([]int) // 是一个指向切片类型的指针 fmt.Println(per3) // 输出：[0 0 0] fmt.Println(per4) // 输出：&[] } 总结 本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注M135模板网的更多内容！ ......查看全文

1. 什么叫可寻址? 可直接使用 & 操作符取地址的对象，就是可寻址的(Addressable)。比如下面这个例子 funcmain() { name := "iswbm" fmt.Println(&name) // output: 0xc000010200 } 程序运行不会报错，说明 name 这个变量是可寻址的。 但不能说 "iswbm" 这个字符串是可寻址的。 "iswbm" 是字符串，字符串都是不可变的，是不可寻址的，后面会介绍到。 在开始逐个介绍之前，先说一下结论 指针可以寻址：&Profile{} 变量可以寻址：name := Profile{} 字面量通通不能寻址：Profile{} 2. 哪些是可以寻址的? 变量：&x func main() { name := "iswbm" fmt.Println(&name) // output: 0xc000010200 } 指针：&*x type Profile struct { Name string } func main() { fmt.Println(unsafe.Pointer(&Profile{Name: "iswbm"})) // output: 0xc000108040 } 数组元素索引: &a[0] func main() { s := [...]int{1,2,3} fmt.Println(&s[0]) // output: xc0000b4010 } 切片 func main() { fmt.Println([]int{1, 2, 3}[1:]) } 切片元素索引：&s[1] func main() { s := make([]int , 2, 2) fmt.Println(&s[0]) // output: xc0000b4010 } 组合字面量: &struct{X type}{value} 所有的组合字面量都是不可寻址的，就像下面这样子 type Profile struct { Name string } func new() Profile { return Profile{Name: "iswbm"} } func main() { fmt.Println(&new()) // cannot take the address of new() } 注意上面写法与这个写法的区别，下面这个写法代表不同意思，其中的 & 并不是取地址的操作，而代表实例化一个结构体的指针。 type Profile struct { Name string } func main() { fmt.Println(&Profile{Name: "iswbm"}) // ok } 虽然组合字面量是不可寻址的，但却可以对组合字面量的字段属性进行寻址(直接访问) type Profile struct { Name string } func new() Profile { return Profile{Name: "iswbm"} } func main() { fmt.Println(new().Name) } 3. 哪些是不可以寻址的? 常量 import "fmt" const VERSION = "1.0" func main() { fmt.Println(&VERSION) } 字符串 func getStr() string { return "iswbm" } func main() { fmt.Println(&getStr()) // cannot take the address of getStr() } 函数或方法 func getStr() string { return "iswbm" } func main() { fmt.Println(&getStr) // cannot take the address of getStr } 基本类型字面量 字面量分：基本类型字面量 和 复合型字面量。 基本类型字面量，是一个值的文本表示，都是不应该也是不可以被寻址的。 func getInt() int { return 1024 } func main() { fmt.Println(&getInt()) // cannot take the address of getInt() } map 中的元素 字典比较特殊，可以从两个角度来反向推导，假设字典的元素是可寻址的，会出现 什么问题? 如果字典的元素不存在，则返回零值，而零值是不可变对象，如果能寻址问题就大了。 而如果字典的元素存在，考虑到 Go 中 map 实现中元素的地址是变化的，这意味着寻址的结果也是无意义的。 基于这两点，Map 中的元素不可寻址，符合常理。 func main() { p := map[string]string { "name": "iswbm", } fmt.Println(&p["name"]) // cannot take the address of p["name"] } 搞懂了这点，你应该能够理解下面这段代码为什么会报错啦~ package main import "fmt" type Person struct { Name string Email string } func main() { m := map[int]Person{ 1:Person{"Andy", "1137291867@qq.com"}, 2:Person{"Tiny", "qishuai231@gmail.com"}, 3:Person{"Jack", "qs_edu2009@163.com"}, } //编译错误：cannot assign to struct field m[1].Name in map m[1].Name = "Scrapup" 数组字面量 数组字面量是不可寻址的，当你对数组字面量进行切片操作，其实就是寻找内部元素的地址，下面这段代码是会报错的 func main() { fmt.Println([3]int{1, 2, 3}[1:]) // invalid operation [3]int literal[1:] (slice of unaddressable value) } 到此这篇关于一文理解Go 中的可寻址和不可寻址的文章就介绍到这了,更多相关Go 中可寻址和不可寻址内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言： 随着编程语言的发展，Go 还很年轻。它于 2009 年 11 月 10 日首次发布。其创建者Robert Griesemer Rob Pike 和 Ken Thompson在 Google 工作，在那里大规模扩展的挑战激励他们将 Go 设计为一种快速有效的编程解决方案，用于具有大型代码库、管理由多个开发人员，具有严格的性能要求，并跨越多个网络和处理核心。 Go 的创始人在创建他们的新语言时也借此机会学习了其他编程语言的优点、缺点和漏洞。结果是一种干净、清晰和实用的语言，具有相对较少的命令和功能集。 1. Go 总是在构建中包含二进制文件 Go 运行时提供内存分配、垃圾收集、并发支持和网络等服务。它被编译到每个 Go 二进制文件中。这与许多其他语言不同，其中许多语言使用需要与程序一起安装才能正常工作的虚拟机。 将运行时直接包含在二进制文件中使得分发和运行 Go 程序变得非常容易，并避免了运行时和程序之间的不兼容问题。Python、Ruby 和 JavaScript 等语言的虚拟机也没有针对垃圾收集和内存分配进行优化，这解释了 Go 相对于其他类似语言的优越速度。例如，Go 将尽可能多的存储在堆栈中，其中数据按顺序排列以便比堆更快地访问。稍后会详细介绍。 关于 Go 的静态二进制文件的最后一件事是，因为不需要运行外部依赖项，所以它们启动得非常快。如果您使用Google App Engine 之类的服务，这是一种在 Google Cloud 上运行的平台即服务，它可以将您的应用程序缩减到零实例以节省云成本，这将非常有用。当收到新请求时，App Engine 可以在眨眼间启动 Go 程序的一个实例。在 Python 或 Node 中的相同体验通常会导致 3-5 秒（或更长时间）的等待，因为所需的虚拟环境也会与新实例一起启动。 2. Go 没有针对程序依赖的集中托管服务 为了访问已发布的 Go 程序，开发人员不依赖集中托管的服务，例如Java 的Maven Central或JavaScript的NPM注册表。相反，项目通过其源代码存储库（最常见的是 Github）共享。在go install命令行允许以这种方式下载库。 为什么我喜欢这个功能？我一直认为像 Maven Central、PIP 和 NPM 这样的集中托管的依赖服务有点令人生畏的黑盒子，也许可以抽象出下载和安装依赖项的麻烦，但不可避免地会在依赖项错误时引发可怕的心跳停止发生。 此外，将的的模块提供给其他人就像将其放入版本控制系统一样简单，这是分发程序的一种非常简单的方式。 3. Go 是按值调用的 在 Go 中，当你提供一个原始值（数字、布尔值或字符串）或一个结构体（类对象的粗略等价物）作为函数的参数时，Go 总是会复制变量的值。 在 Java、Python 和 JavaScript 等许多其他语言中，原语是按值传递的，但对象（类实例）是按引用传递的，这意味着接收函数实际上接收的是指向原始对象的指针，而不是其副本。在接收函数中对对象所做的任何更改都会反映在原始对象中。 在 Go 中，结构体和原语默认按值传递，可以选择传递指针，通过使用星号运算符： // 按值传递 func MakeNewFoo(f Foo ) (Foo, error) { f.Field1 = "New val" f.Field2 = f.Field2 + 1 return f, nil } 上述函数接收 Foo 的副本并返回一个新的 Foo 对象。 // 通过引用传递 func MutateFoo(f *Foo ) error { f.Field1 = "New val" f.Field2 = 2 return nil } 上面的函数接收一个指向 Foo 的指针并改变原始对象。 按值调用与按引用调用的这种明显区别使您的意图显而易见，并降低了调用函数无意中改变传入对象的可能性（当它不应该发生时（许多初学者开发人员很难做到这一点）握紧）。 正如麻省理工总结的：“可变性使得理解你的程序在做什么变得更加困难，并且更难以执行契约” 此外，按值调用显着减少了垃圾收集器的工作，这意味着应用程序更快、内存效率更高。这篇文章得出的结论是，指针追踪（从堆中检索指针值）比从连续堆栈中检索值慢 10 到 20 倍。要记住的一个很好的经验法则是：从内存中读取的最快方法是顺序读取，这意味着将随机存储在 RAM 中的指针数量减少到最少。 4. 'defer' 关键字 在NodeJS 中，在我开始使用knex.js之前，我会通过创建一个数据库池来手动管理我的代码中的数据库连接，然后在每个函数中从池中打开一个新连接，一旦所需的数据库 CRUD 功能已完成。 这有点像维护噩梦，因为如果我没有在每个函数结束时释放连接，未释放的数据库连接的数量会慢慢增长，直到池中没有更多可用连接，然后中断应用程序。 现实情况是，程序经常需要释放、清理和拆除资源、文件、连接等，因此 Go 引入了defer关键字作为管理这些的有效方式。 任何以defer开头的语句都会延迟对它的调用，直到周围的函数退出。这意味着您可以将清理/拆卸代码放在函数的顶部（很明显），知道一旦函数完成它就会如此。 func main() { if len(os.Args) < 2 { log.Fatal("no file specified") } f, err := os.Open(os.Args[1]) if err != nil { log.Fatal(err) } defer f.Close() data := make([]byte, 2048) for { count, err := f.Read(data) os.Stdout.Write(data[:count]) if err != nil { if err != io.EOF { log.Fatal(err) } break } } } 在上面的例子中，文件关闭方法被推迟了。我喜欢这种在函数顶部声明你的内务处理意图的模式，然后忘记它，知道一旦函数退出它就会完成它的工作。 5. Go 采用了函数式编程的最佳特性 函数式编程是一种高效且富有创造性的范式，幸运的是 Go 采用了函数式编程的最佳特性。在Go中： 函数是值，这意味着它们可以作为值添加到映射中，作为参数传递给其他函数，设置为变量，并从函数返回（称为“高阶函数”，在 Go 中经常使用装饰器创建中间件图案）。 可以创建和自动调用匿名函数。 在其他函数内声明的函数允许闭包（在函数内声明的函数能够访问和修改在外部函数中声明的变量）。在惯用的 Go 中，闭包被广泛使用来限制函数的范围，并设置函数然后在其逻辑中使用的状态。 func StartTimer (name string) func(){ t := time.Now() log.Println(name, "started") return func() { d := time.Now().Sub(t) log.Println(name, "took", d) } } func RunTimer() { stop := StartTimer("My timer") defer stop() time.Sleep(1 * time.Second) } 上面是一个闭包的例子。'StartTimer' 函数返回一个新函数，它通过闭包可以访问在其出生范围内设置的 't' 值。然后，此函数可以将当前时间与“t”的值进行比较，从而创建一个有用的计时器。感谢Mat Ryer的这个例子。 6. Go 有隐式接口 任何阅读过有关SOLID编码和设计模式的文献的人都可能听说过“优先组合胜过继承”的口头禅。简而言之，这表明您应该将业务逻辑分解为不同的接口，而不是依赖于来自父类的属性和逻辑的分层继承。 另一个流行的方法是“为接口编程，而不是实现”： API 应该只发布其预期行为的契约（其方法签名），而不是有关如何实现该行为的详细信息。 这两者都表明接口在现代编程中的重要性。 因此，Go 支持接口也就不足为奇了。事实上，接口是 Go 中唯一的抽象类型。 然而，与其他语言不同，Go 中的接口不是显式实现的，而是隐式实现的。具体类型不声明它实现了接口。相反，如果为该具体类型设置的方法集包含底层接口的所有方法集，则Go 认为该对象实现了 interface。 这种隐式接口实现（正式称为结构类型）允许 Go 强制执行类型安全和解耦，保持动态语言中表现出的大部分灵活性。 相比之下，显式接口将客户端和实现绑定在一起，例如，在 Java 中替换依赖项比在 Go 中困难得多。 // 这是一个接口声明（称为Logic） type Logic interface { Process (data string) string } type LogicProvider struct {} // 这是 LogicProvider 上名为“Process”的方法 struct func (lp LogicProvider) Process (data string) string { // 业务逻辑 } // 这是具有 Logic 接口作为属性的客户端结构 type Client struct { L Logic } func(c Client) Program() { // 从某处获取数据 cLProcess(data) } func main() { c := Client { L: LogicProvider{}, } c.Program() } LogicProvider 中没有任何声明表示它符合Logic接口。这意味着客户端将来可以轻松替换其逻辑提供程序，只要该逻辑提供程序包含底层接口 ( Logic ) 的所有方法集。 7.错误处理 Go 中的错误处理方式与其他语言大不相同。简而言之，Go 通过返回一个 error 类型的值作为函数的最后一个返回值来处理错误。 当函数按预期执行时，错误参数返回nil，否则返回错误值。调用函数然后检查错误返回值，并处理错误，或抛出自己的错误。 // 函数返回一个整数和一个错误 func calculateRemainder(numerator int, denominator int) ( int, error ) { // if denominator == 0 { return 9, errors.New("denominator is 0" } // 没有错误返回 return numerator / denominator, nil } Go 以这种方式运行是有原因的：它迫使编码人员考虑异常并正确处理它们。传统的 try-catch 异常还会在代码中添加至少一个新的代码路径，并以难以遵循的方式缩进代码。Go 更喜欢将“快乐路径”视为非缩进代码，在“快乐路径”完成之前识别并返回任何错误。 8.并发 可以说是 Go 最著名的特性，并发允许处理在机器或服务器上的可用内核数量上并行运行。当单独的进程不相互依赖（不需要顺序运行）并且时间性能至关重要时，并发性最有意义。这通常是 I/O 要求的情况，其中读取或写入磁盘或网络的速度比除最复杂的内存中进程之外的所有进程慢几个数量级。 函数调用前的“ go ”关键字将同时运行该函数。 func process(val int) int { // 用 val 做一些事情 } // 对于 'in' 中的每个值，同时运行 process 函数， // 并将 process 的结果读取到 'out' func runConcurrently(in <-chan int, out chan<- int){ go func() { for val := range in { result := process(val) out <- result } } } Go 中的并发是一项深入且相当高级的功能，但在有意义的地方，它提供了一种有效的方法来确保程序的最佳性能。 9. Go 标准库 Go 有一个“包含电池”的理念，现代编程语言的许多要求都被纳入标准库，这使程序员的生活变得更加简单。 如前所述，Go 是一种相对年轻的语言，这意味着标准库中可以满足现代应用程序的许多问题/要求。 一方面，Go 为网络（特别是 HTTP/2）和文件管理提供了世界一流的支持。它还提供原生 JSON 编码和解码。因此，设置服务器来处理 HTTP 请求并返回响应（JSON 或其他）非常简单，这解释了 Go 在基于 REST 的 HTTP Web 服务开发中的流行。 正如Mat Ryer还指出的那样，标准库是开源的，是学习 Go 最佳实践的绝佳方式。 到此这篇关于Go 有别于其他语言的九个特性 的文章就介绍到这了,更多相关Go 有别于其他语言的特性 内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

在并发编程中，多个Goroutine访问同一块内存资源时可能会出现竞态条件，我们需要在临界区中使用适当的同步操作来以避免竞态条件。Go 语言中提供了很多同步工具，本文将介绍互斥锁Mutex和读写锁RWMutex的使用方法。 一、互斥锁Mutex 1、Mutex介绍 Go 语言的同步工具主要由 sync 包提供，互斥锁 (Mutex) 与读写锁 (RWMutex) 就是sync 包中的方法。 互斥锁可以用来保护一个临界区，保证同一时刻只有一个 goroutine 处于该临界区内。主要包括锁定（Lock方法）和解锁（Unlock方法）两个操作，首先对进入临界区的goroutine进行锁定，离开时进行解锁。 使用互斥锁 (Mutex)时要注意以下几点： 不要重复锁定互斥锁，否则会阻塞，也可能会导致死锁（deadlock）； 要对互斥锁进行解锁，这也是为了避免重复锁定； 不要对未锁定或者已解锁的互斥锁解锁； 不要在多个函数之间直接传递互斥锁，sync.Mutex类型属于值类型，将它传给一个函数时，会产生一个副本，在函数中对锁的操作不会影响原锁 总之，一个互斥锁只用来保护一个临界区，加锁后记得解锁，对于每一个锁定操作，都要有且只有一个对应的解锁操作，也就是加锁和解锁要成对出现，最保险的做法时使用 defer语句 解锁。 2、Mutex使用实例 下面的代码模拟取钱和存钱操作： package main import ( "flag" "fmt" "sync" ) var ( mutex sync.Mutex balance int protecting uint // 是否加锁 sign = make(chan struct{}, 10) //通道，用于等待所有goroutine ) // 存钱 func deposit(value int) { defer func() { sign <- struct{}{} }() if protecting == 1 { mutex.Lock() defer mutex.Unlock() } fmt.Printf("余额: %d\n", balance) balance += value fmt.Printf("存 %d 后的余额: %d\n", value, balance) fmt.Println() } // 取钱 func withdraw(value int) { defer func() { sign <- struct{}{} }() if protecting == 1 { mutex.Lock() defer mutex.Unlock() } fmt.Printf("余额: %d\n", balance) balance -= value fmt.Printf("取 %d 后的余额: %d\n", value, balance) fmt.Println() } func main() { for i:=0; i < 5; i++ { go withdraw(500) // 取500 go deposit(500) // 存500 } for i := 0; i < 10; i++ { <-sign } fmt.Printf("当前余额: %d\n", balance) } func init() { balance = 1000 // 初始账户余额为1000 flag.UintVar(&protecting, "protecting", 0, "是否加锁，0表示不加锁，1表示加锁") } 上面的代码中，使用了通道来让主 goroutine 等待其他 goroutine 运行结束，每个子goroutine在运行结束之前向通道发送一个元素，主 goroutine 在最后从这个通道接收元素，接收次数与子goroutine个数相同。接收完后就会退出主goroutine。 代码使用协程实现多次（5次）对一个账户进行存钱和取钱的操作，先来看不加锁的情况： 余额: 1000 存 500 后的余额: 1500 余额: 1000 取 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1000 取 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1000 取 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 1000 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 1000 存 500 后的余额: 1000 当前余额: 1000 可以看到出现了混乱，比如第二次1000的余额取500后还是1000，这种对同一资源的竞争出现了竞态条件(Race Condition)。 下面来看加锁的执行结果： 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1500 取 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 当前余额: 1000 加锁后就正常了。 下面介绍更细化的互斥锁：读/写互斥锁RWMutex。 二、读写锁RWMutex 1、RWMutex介绍 读/写互斥锁RWMutex包含了读锁和写锁，分别对共享资源的“读操作”和“写操作”进行保护。sync.RWMutex类型中的Lock方法和Unlock方法分别用于对写锁进行锁定和解锁，而它的RLock方法和RUnlock方法则分别用于对读锁进行锁定和解锁。 有了互斥锁Mutex，为什么还需要读写锁呢？因为在很多并发操作中，并发读取占比很大，写操作相对较少，读写锁可以并发读取，这样可以提供服务性能。读写锁具有以下特征： 读写锁 读锁 写锁 读锁 Yes No 写锁 No No 也就是说， 如果某个共享资源受到读锁和写锁保护时，其它goroutine不能进行写操作。换句话说就是读写操作和写写操作不能并行执行，也就是读写互斥； 受读锁保护时，可以同时进行多个读操作。 在使用读写锁时，还需要注意： 不要对未锁定的读写锁解锁； 对读锁不能使用写锁解锁 对写锁不能使用读锁解锁 2、RWMutex使用实例 改写前面的取钱和存钱操作，添加查询余额的方法： package main import ( "fmt" "sync" ) // account 代表计数器。 type account struct { num uint // 操作次数 balance int // 余额 rwMu *sync.RWMutex // 读写锁 } var sign = make(chan struct{}, 15) //通道，用于等待所有goroutine // 查看余额：使用读锁 func (c *account) check() { defer func() { sign <- struct{}{} }() c.rwMu.RLock() defer c.rwMu.RUnlock() fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance) } // 存钱：写锁 func (c *account) deposit(value int) { defer func() { sign <- struct{}{} }() c.rwMu.Lock() defer c.rwMu.Unlock() fmt.Printf("余额: %d\n", c.balance) c.num += 1 c.balance += value fmt.Printf("存 %d 后的余额: %d\n", value, c.balance) fmt.Println() } // 取钱：写锁 func (c *account) withdraw(value int) { defer func() { sign <- struct{}{} }() c.rwMu.Lock() defer c.rwMu.Unlock() fmt.Printf("余额: %d\n", c.balance) c.num += 1 c.balance -= value fmt.Printf("取 %d 后的余额: %d\n", value, c.balance) fmt.Println() } func main() { c := account{0, 1000, new(sync.RWMutex)} for i:=0; i < 5; i++ { go c.withdraw(500) // 取500 go c.deposit(500) // 存500 go c.check() } for i := 0; i < 15; i++ { <-sign } fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance) } 执行结果： 余额: 1000 取 500 后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1500 取 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 10 次操作后的余额: 1000 读写锁和互斥锁的不同之处在于读写锁把对共享资源的读操作和写操作分开了，可以实现更复杂的访问控制。 总结： 读写锁也是一种互斥锁，它是互斥锁的扩展。在使用时需要注意： 加锁后一定要解锁 不要重复加锁或者解锁 不解锁未锁定的锁 不要传递互斥锁 到此这篇关于Go语言并发编程之互斥锁Mutex和读写锁RWMutex的文章就介绍到这了,更多相关Go语言 Mutex RWMutex内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

下面对是一个 select 死锁的问题 package main import "sync" func main() {var wg sync.WaitGroup foo := make(chan int) bar := make(chan int) wg.Add(1) go func() { defer wg.Done() select { case foo <- <-bar: default: println("default") } }() wg.Wait() } 按常规理解，go func 中的 select 应该执行 default 分支，程序正常运行。但结果却不是，而是死锁。可以通过该链接测试：https://play.studygolang.com/p/kF4pOjYXbXf。 原因文章也解释了，Go 语言规范中有这么一句： For all the cases in the statement, the channel operands of receive operations and the channel and right-hand-side expressions of send statements are evaluated exactly once, in source order, upon entering the “select” statement. The result is a set of channels to receive from or send to, and the corresponding values to send. Any side effects in that evaluation will occur irrespective of which (if any) communication operation is selected to proceed. Expressions on the left-hand side of a RecvStmt with a short variable declaration or assignment are not yet evaluated. 不知道大家看懂没有？于是，最后来了一个例子验证你是否理解了：为什么每次都是输出一半数据，然后死锁？（同样，这里可以运行查看结果：https://play.studygolang.com/p/zoJtTzI7K5T） package main import ( "fmt" "time" ) func talk(msg string, sleep int) <-chan string { ch := make(chan string) go func() { for i := 0; i < 5; i++ { ch <- fmt.Sprintf("%s %d", msg, i) time.Sleep(time.Duration(sleep) * time.Millisecond) } }() return ch } func fanIn(input1, input2 <-chan string) <-chan string { ch := make(chan string) go func() { for { select { case ch <- <-input1: case ch <- <-input2: } } }() return ch } func main() { ch := fanIn(talk("A", 10), talk("B", 1000)) for i := 0; i < 10; i++ { fmt.Printf("%q\n", <-ch) } } 有没有这种感觉： 这是 StackOverflow 上的一个问题：https://stackoverflow.com/questions/51167940/chained-channel-operations-in-a-single-select-case。 关键点和文章开头例子一样，在于 select case 中两个 channel 串起来，即 fanIn 函数中： select { case ch <- <-input1: case ch <- <-input2: } 如果改为这样就一切正常： select { case t := <-input1: ch <- t case t := <-input2: ch <- t } 结合这个更复杂的例子分析 Go 语言规范中的那句话。 对于 select 语句，在进入该语句时，会按源码的顺序对每一个 case 子句进行求值：这个求值只针对发送或接收操作的额外表达式。 比如： // ch 是一个 chan int； // getVal() 返回 int // input 是 chan int // getch() 返回 chan int select { case ch <- getVal(): case ch <- <-input: case getch() <- 1: case <- getch(): } 在没有选择某个具体 case 执行前，例子中的 getVal() 、 <-input 和 getch() 会执行。这里有一个验证的例子：https://play.studygolang.com/p/DkpCq3aQ1TE。 package main import ( "fmt" ) func main() { ch := make(chan int) go func() { select { case ch <- getVal(1): fmt.Println("in first case") case ch <- getVal(2): fmt.Println("in second case") default: fmt.Println("default") } }() fmt.Println("The val:", <-ch) } func getVal(i int) int { fmt.Println("getVal, i=", i) return i } 无论 select 最终选择了哪个 case， getVal() 都会按照源码顺序执行： getVal(1) 和 getVal(2) ，也就是它们必然先输出： getVal, i= 1 getVal, i= 2 你可以仔细琢磨一下。 现在回到 StackOverflow 上的那个问题。 每次进入以下 select 语句时： select { case ch <- <-input1: case ch <- <-input2: } <-input1 和 <-input2 都会执行，相应的值是：A x 和 B x（其中 x 是 0-5）。但每次 select 只会选择其中一个 case 执行，所以 <-input1 和 <-input2 的结果，必然有一个被丢弃了，也就是不会被写入 ch 中。因此，一共只会输出 5 次，另外 5 次结果丢掉了。（你会发现，输出的 5 次结果中，x 比如是 0 1 2 3 4） 而 main 中循环 10 次，只获得 5 次结果，所以输出 5 次后，报死锁。 虽然这是一个小细节，但实际开发中还是有可能出现的。比如文章提到的例子写法： // ch 是一个 chan int； // getVal() 返回 int // input 是 chan int // getch() 返回 chan int select { case ch <- getVal(): case ch <- <-input: case getch() <- 1: case <- getch(): } 因此在使用 select 时，一定要注意这种可能的问题。 不要以为这个问题不会遇到，其实很常见。最多的就是 time.After 导致内存泄露问题，网上有很多文章解释原因，如何避免，其实最根本原因就是因为 select 这个机制导致的。 比如如下代码，有内存泄露（传递给 time.After 的时间参数越大，泄露会越厉害），你能解释原因吗？ package main import ( "time" ) func main() { ch := make(chan int, 10) go func() { var i = 1 for { i++ ch <- i } }() for { select { case x := <- ch: println(x) case <- time.After(30 * time.Second): println(time.Now().Unix()) } } } 到此这篇关于Go select 死锁的一个细节的文章就介绍到这了,更多相关Go select 死锁内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文