在“range” 语句中生成的数据的值其实是集合元素的拷贝。它们不是原有元素的引用。
这就意味着更新这些值将不会修改原来的数据。
我们来直接看段示例：
|
1
2
3
4
5
6
7
8
9
|
package main
import "fmt"
func main() {
data := []int{1, 2, 3}
for _, v := range data {
v *= 10 //原始元素未更改
}
fmt.Println("data:", data) //输出 data: [1 2 3]
}
|
如果我们需要更新原有集合中的数据，使用索引操作符来获得数据即可：
|
1
2
3
4
5
6
7
8
9
|
package main
import "fmt"
func main() {
data := []int{1, 2, 3}
for i, _ := range data {
data[i] *= 10
}
fmt.Println("data:", data) //输出 data: [10 20 30]
}
|
好，重点来了!重点来了!重点来了!重要的话说三遍，大部分博友们可能会踩坑.
这里我提前总结下：
多个slice可以引用同一个数据。比如，当你从一个已有的slice创建一个新的slice时(比如通过索引截取)，这就会发生。
如果你的应用功能需要这种行为，那么你将需要留意下slice的"坑"。
在某些情况下，在一个slice中添加新的数据，在原有数组无法保持更多新的数据时，将导致分配一个新的数组。
而其他的slice还指向老的数组（或者是老的数据）。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package main
import "fmt"
func main() {
s1 := []int{1, 2, 3}
fmt.Println(len(s1), cap(s1), s1) //输出 3 3 [1 2 3]
s2 := s1[1:] //索引从第二个元素截取开始
fmt.Println(len(s2), cap(s2), s2) //输出 2 2 [2 3]
for i := range s2 {
s2[i] += 20
}
//仍然引用同一数组
fmt.Println(s1) //s1 在s2修改了后面2个元素，所以s1也是更新了。输出 [1 22 23]
fmt.Println(s2) //输出 [22 23]
s2 = append(s2, 4) // 注意s2的容量是2，追加新元素后将导致分配一个新的数组 [22 23 4]
for i := range s2 {
s2[i] += 10
}
//s1 仍然是更新后的历史老数据
fmt.Println(s1) //输出 [1 22 23]
fmt.Println(s2) //输出 [32 33 14]
}
|
所以，大家在使用中特别注意。容量不足，追加新元素不影响历史数据。因为重新分配了变量了。
另外，继续聊下高级一点滴技巧：
使用指针接收方法的值
只要值是可取址的，那在这个值上调用指针接收方法是没问题的。
然而并不是所有的变量是可取址的。Map的元素就不是。通过interface引用的变量也不是。我们接着看下面一段代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package main
import "fmt"
type user struct {
name string
}
func (p *user) print() {
fmt.Println("排名:", p.name)
}
type printer interface {
print()
}
func main() {
u := user{"乔峰"}
u.print() // 输出 排名: 乔峰
var in printer = user{"鸠摩智"} //error
in.print()
m := map[string]user{"one": user{"风清扬"}}
m["one"].print() //error
}
|
输出：
|
1
2
3
4
|
cannot use user literal (type user) as type printer in assignment:
user does not implement printer (print method has pointer receiver)
cannot call pointer method on m["one"]
cannot take the address of m["one"]
|
大致意思是：不能在赋值中使用数据文本（类型数据）作为类型指针，user未执行指针调用（指针方法具有指针接收器)，
无法对m[“one”]调用指针方法，不能取m的地址[“one”]。
上面我们看到有一个struct值的map，我们无法更新单个的struct值。比如错误的代码：
|
1
2
3
4
5
6
7
8
|
package main
type user struct {
name string
}
func main() {
m := map[string]user{"one": {"乔峰"}}
m["one"].name = "风清扬" //输出 cannot assign to struct field m["one"].name in map
}
|
错误意思是：在map中，无法分配给结构字段m["one"].name。这个操作无效是因为map元素是无法取址的。
上面我们提到:slice元素是可以取地址滴：
|
1
2
3
4
5
6
7
8
9
10
11
|
package main
import "fmt"
type user struct {
name string
}
func main() {
one := user{"乔峰"}
u := []user{one}
u[0].name = "风清扬" //ok
fmt.Println(u) //输出: [{风清扬}]
}
|
当然我们还有更好的解决办法：
第一个有效的方法是使用一个临时变量：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package main
import "fmt"
type user struct {
name string
}
func main() {
m := map[string]user{"one": {"乔峰"}}
u := m["one"] //使用临时变量
u.name = "风清扬"
m["one"] = u
fmt.Printf("%v\n", m) //输出: map[one:{风清扬}]
}
|
另一个有效的方法是使用指针的map：
|
1
2
3
4
5
6
7
8
9
10
|
package main
import "fmt"
type user struct {
name string
}
func main() {
m := map[string]*user{"one": {"乔峰"}}
m["one"].name = "风清扬" //ok
fmt.Println(m["one"]) //输出: &{风清扬}
}
|
说到这里，顺便再提一下。继续看下面一段代码：
|
1
2
3
4
5
6
7
8
9
10
|
package main
import "fmt"
type user struct {
name string
}
func main() {
m := map[string]*user{"one": {"乔峰"}}
m["two"].name = "鸠摩智" //新增自定义键名值
fmt.Println(m["two"]) //error
}
|
输出：
panic: runtime error: invalid memory address or nil pointer dereference
无效的内存地址或取消引用空指针？原因在于Go无法动态给结构体添加字段，我们可以间接使用make(map[string]interface{})实现。
好吧，就说这么多了，有不足之处欢迎广大博友留言指正。。。。。。。
补充：golang 中map 和slice 索引速度比较
主文件
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package main
var max = 100
var Slice = make([]int, max+10)
var Map = make(map[int]int)
func init() {
for i := 0; i < max; i++ {
Slice[i] = i
Map[i] = i
}
}
// 查找算法可以优化，本文对于常用无序查找做比较
func SearchSlice(i int) int {
for _, v := range Slice {
if v == i {
return v
}
}
return -1
}
func SearchMap(i int) int {
return Map[i]
}
|
测试文件
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package main
import "testing"
func BenchmarkSearchMap(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = SearchMap(i % max)
}
}
func BenchmarkSearchSlice(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = SearchSlice(i % max)
}
}
func BenchmarkSlice(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = Slice[i%max]
}
}
|
测试结果
max = 100
|
1
2
3
|
BenchmarkSearchMap-16 94148293 12.7 ns/op 0 B/op 0 allocs/op
BenchmarkSearchSlice-16 49473447 23.6 ns/op 0 B/op 0 allocs/op
BenchmarkSlice-16 187461336 6.46 ns/op 0 B/op 0 allocs/op
|
max = 10000
|
1
2
3
|
BenchmarkSearchMap-16 43147364 27.6 ns/op 0 B/op 0 allocs/op
BenchmarkSearchSlice-16 968623 1159 ns/op 0 B/op 0 allocs/op
BenchmarkSlice-16 187649472 6.42 ns/op 0 B/op 0 allocs/op
|
Max = 1000000
|
1
2
3
|
BenchmarkSearchMap-16 15015690 90.1 ns/op 0 B/op 0 allocs/op
BenchmarkSearchSlice-16 441436 104242 ns/op 0 B/op 0 allocs/op
BenchmarkSlice-16 182620702 6.58 ns/op 0 B/op 0 allocs/op
|
在一些特定优化条件下，可以尝试用slice，效果会比map好，比如把10 6级的查找优化成3级102查找, 对于一些结构体，可以根据某些特征分类或预先根据特征值排序。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://www.cnblogs.com/phpper/p/12060512.html