最近项目上碰到个小需求，输入是两个数组，一个旧数组一个新数组，要求获取新数组相对旧数组所有新增和删除的元素，例如：

输入：

arr_old: {"1", "2", "4", "5", "7", "9"}

arr_new: {"2", "3", "4", "6", "7"}

返回：

arr_added: {"3", "6"}

arr_deleted: {"1", "5", "9"}

go的标准库中没有类似的直接比较的方法，需要自己具体实现，最简单的方法当然是旧数组的每个元素去新数组，找不到的就是删除的，然后新数组的元素再挨个去旧数组找一遍，找不到就是新增的，但这个方法效率实在太低了。

这里我使用了一种基于集合运算的思想，即分别求两个数组的交集和并集，并集减去交集就是所有发生变化的元素（要么是新增的，要么是删除的），遍历这个集合中的元素去旧数组中查找，如果在旧数组中找到，那么就是删除掉的元素；反之，如果找不到，则一定能在新数组中找到（用不着真的再去遍历一次），那么就是新增的元素。

上代码，这里有个技巧，就是利用go中map键唯一性的特性，用数组的元素作为map的key，通过map来实现快速查找。

package main
import (
 "fmt"
)
func main() {
 //fmt.Println("Hello World!")
 src := []string{"1", "2", "4", "5", "7", "9"}
 dest := []string{"2", "3", "4", "6", "7"}
 added, removed := Arrcmp(src, dest)
 fmt.Printf("add: %v\nrem: %v\n", added, removed)
}
func Arrcmp(src []string, dest []string) ([]string, []string) {
 msrc := make(map[string]byte) //按源数组建索引
 mall := make(map[string]byte) //源+目所有元素建索引
 var set []string //交集
 //1.源数组建立map
 for _, v := range src {
 msrc[v] = 0
 mall[v] = 0
 }
 //2.目数组中，存不进去，即重复元素，所有存不进去的集合就是并集
 for _, v := range dest {
 l := len(mall)
 mall[v] = 1
 if l != len(mall) { //长度变化，即可以存
 l = len(mall)
 } else { //存不了，进并集
 set = append(set, v)
 }
 }
 //3.遍历交集，在并集中找，找到就从并集中删，删完后就是补集（即并-交=所有变化的元素）
 for _, v := range set {
 delete(mall, v)
 }
 //4.此时，mall是补集，所有元素去源中找，找到就是删除的，找不到的必定能在目数组中找到，即新加的
 var added, deleted []string
 for v, _ := range mall {
 _, exist := msrc[v]
 if exist {
 deleted = append(deleted, v)
 } else {
 added = append(added, v)
 }
 }
 return added, deleted
}

运行结果：

add: [6 3]

rem: [1 5 9]

欢迎大家交流效率更高的方法。

补充：go语言教程之浅谈数组和切片的异同

本期的分享我们来讲解一下关于go语言的数组和切片的概念、用法和区别。

在go语言的程序开发过程中，我们避免不了数组和切片。关于他们的用法和区别却使得有的小伙伴感觉困惑。所以小栈君这里也归纳和总结了关于数组和切片的干货帮助小伙伴进行理解。

数组的定义

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。

相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。

数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。

总体来讲的话数组就是同一种类型的固定长度的序列。

在go语言中数组的定义是很简单的。

如图所示，我们定义了一个长度为2的数组，在数组定义的过程中，系统已经对这个数组进行了初始化并分配了空间。所以我们如果想要进行赋值可以通过数组名加上下标的方式进行赋值。但是值得注意的一点是我们并不能进行数组的超长处理。这一点有别于java的数组定义，java的定长数组添加值后如果对于超出的值会有自动扩容功能。

但是在go语言中并没有方法来进行增删改查值，只有通过下标的方式，所以我们如果进行了越界处理编译都会进行报错。所以才入门的小伙伴们需要注意一下哦。数组的下标在数组的合法范围之外就会出发访问越界，会有panic出现。所以小栈君也是通过了一个实例给大家说明一下，因为编译可能会不通过，所以我们巧妙的避开编译器的编译进行数组的越界操作说明。

当然需要值得注意的一点是，数组的长度也是数组类型的一部分，因此var a [2]int 和 var b [3] int 是两个不同的类型。

知识点来了，在go语言中的数组是属于值类型传递，当我们传递一个数组到一个方法中，改变副本的值并不会修改到原本数组的值。所以得到的数组还是原来的样子。

因此如果我们要对数组进行值的修改的话，就只有进行指针操作啦~。

切片的概念

在go语言中数组中长度不可以更改，所以在实际的应用环境中并不是非常实用，所以Go语言衍生出了一种灵活性强和功能更强大的内置类型，即为切片。

与上面所讲的数组相比，切片的长度是不固定的，并且切片是可以进行扩容。切片对象非常小，是因为它是只有3个字段的数据结构：一个是指向底层数组的指针，一个是切片的长度，一个是切片的容量。这3个字段，就是Go语言操作底层数组的元数据，有了它们，我们就可以任意的操作切片了。

当然，切片作为数组的引用，所以切片属于是引用类型，各位小伙伴可千万要记住了哦。在切片的使用过程当中，我们可以通过遍历数组的方式进行对于切片的遍历，我们也可以内置方法len对数组或切片进行长度的计算。

当然我们也可以对切片的容量进行计算，之前有讲过Go语言有丰富的内置库提供给我们使用，所以我们也可以cap内置函数进行容量的计算。多个切片如果表示同一个数组的片段，它们可以共享数据;因此一个切片和相关数组的其他切片是共享存储的，相反，不同的数组总是代表不同的存储。数组实际上是切片的构建块。

上面的例子小栈君分别用数组和切片进行了测试，我们可以看到数组的容量一旦确定后就无法进行更改，当我们的切片进行初始化，初始的容量是2，此时切片的容量和长度都是2，但是我通过内置的append方法进行了切片的增加。此时的切片的容量和长度都是4。此时我们并不能确定切片内置扩容的机制，但是隐约猜测是倍增。

言归正传，为了测试一下切片的扩容机制，所以小栈君又进行了切片的增加，此时，细心的小伙伴应该发现，这次小栈君一次性增加了两个元素在一个append里面，因为这是append方法是一个可变长度的传值。这也是一个小知识点哦。

如果切片的底层数组，没有足够的容量时，就会新建一个底层数组，把原来数组的值复制到新底层数组里，再追加新值，这时候就不会影响原来的底层数组了。

append目前的算法是：容量小于1000个时，总是成倍的增长，一旦容量超过1000个，增长因子设为1.25，也就是说每次会增加25%的容量。

之后我们发现切片的容量和长度发生了变化，如果说上次容量的扩张是4是我们猜测的倍数扩容方式，那么这次我们就实锤了他的扩容机制就是倍增。而且在Go语言的容量和长度不一样，所以我们也可以得出结论，就是在 0 <= len(arry) <= cap(slice)。

在我们声明好切片后我们可以使用new或是make方法对切片进行初始化，当然小栈君也试着尝试证明切片如果没有进行初始化是会panic的。结果并没有出现。因为如果slice没有初始化，它仅仅相当于一个nil，长度和容量都为0，并不会panic。

小栈君也考虑到可能是因为没有内置增加方法或是没有报错仅仅只是因为我后面利用对Carry数组的切割进行赋值的缘故。所以不甘心又做了一次尝试，定义好相应的切片后直接使用append方法，结果如下：

我们同样可以通过上述的例子了解到切片的下标是左闭右开区间，因为我们carry数组的内容如上图所示， 我们最终得到的结果是IT干货栈，下标来讲的话是属于1。所以我们得到的结论和事实是一样的。对于切片我们也有很多用法，如下图所示：

下图是Python中对于切片的操作，并且Python中的数组更为灵活，在后面我为大家分享Python教程的时候会详细分享哦。

切片的初始化

对于切片的初始化我们可以make方法和new方法

new(T) 为每个新的类型T分配一片内存，初始化为 0 并且返回类型为*T的内存地址:这种方法 返回一个指向类型为 T，值为 0 的地址的指针，它适用于值类型如数组和结构体；它相当于 &T{}。

make(T) 返回一个类型为 T 的初始值，它只适用于3种内建的引用类型:切片、map 和 channel。

拷贝

因为在go语言的数组是属于值传递，之前的方法也证实了这一点，在方法传递值的时候系统会进行拷贝一份副本进行传递，如果需要改变的值的话就需要使用指针。但是在使用切片处理的时候，因为切片属于引用传递，所以go语言有内置的函数copy方法进行值的拷贝。

上述的一个例子可以综合说明几点问题了，最开始我们定义了一个切片并且容量是2，内容是1和2，我们同样定义了切片b但是并没有做初始化处理。直接使用copy操作。使用copy操作的时候，小栈君也复制了源码出来，第一个是我们的数据源，第二个参数传递我们的目标源。直接使用的话我们可以从结果看出并没有成功。

所以接下来小栈君又进行了初始化操作。这里举例的目的是提醒各位，在操作切片的时候没有初始化就相当于nil，最好是进行切片的初始化操作。在早期go语言的版本中，没有初始化切片会直接报错。接下来我又进行了再一次的复制操作并且打印出他们的地址和容量、长度。可以看出进行切片的拷贝是不会进行切片的扩容处理。而且他们分别指向了不同的地址说明拷贝成功。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。如有错误或未考虑完全的地方，望不吝赐教。