Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。
创新互联建站专注于玉泉网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供玉泉营销型网站建设，玉泉网站制作、玉泉网页设计、玉泉网站官网定制、小程序开发服务，打造玉泉网络公司原创品牌,更为您提供玉泉网站排名全网营销落地服务。
自定义类型
在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型， Go语言中可以使用type关键字来定义自定义类型。
自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。例如：
通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性。
类型别名
类型别名是Go1.9版本添加的新功能。
类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像一个孩子小时候有小名、乳名，上学后用学名，英语老师又会给他起英文名，但这些名字都指的是他本人。
type TypeAlias = Type
我们之前见过的rune和byte就是类型别名，他们的定义如下：
类型定义和类型别名的区别
类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。
结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。
Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了，Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。 也就是我们可以通过struct来定义自己的类型了。
Go语言中通过struct来实现面向对象。
结构体的定义
使用type和struct关键字来定义结构体，具体代码格式如下：
其中：
举个例子，我们定义一个Person（人）结构体，代码如下：
同样类型的字段也可以写在一行，
这样我们就拥有了一个person的自定义类型，它有name、city、age三个字段，分别表示姓名、城市和年龄。这样我们使用这个person结构体就能够很方便的在程序中表示和存储人信息了。
语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的。比如一个人有名字、年龄和居住城市等，本质上是一种聚合型的数据类型
结构体实例化
只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。
基本实例化
举个例子：
我们通过.来访问结构体的字段（成员变量）,例如p1.name和p1.age等。
匿名结构体
在定义一些临时数据结构等场景下还可以使用匿名结构体。
创建指针类型结构体
我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。 格式如下：
从打印的结果中我们可以看出p2是一个结构体指针。
需要注意的是在Go语言中支持对结构体指针直接使用.来访问结构体的成员。
取结构体的地址实例化
使用对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。
p3.name = "七米"其实在底层是(*p3).name = "七米"，这是Go语言帮我们实现的语法糖。
结构体初始化
没有初始化的结构体，其成员变量都是对应其类型的零值。
使用键值对初始化
使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值。
也可以对结构体指针进行键值对初始化，例如：
当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值。
使用值的列表初始化
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
使用这种格式初始化时，需要注意：
结构体内存布局
结构体占用一块连续的内存。
输出：
【进阶知识点】关于Go语言中的内存对齐推荐阅读:在 Go 中恰到好处的内存对齐
面试题
请问下面代码的执行结果是什么？
构造函数
Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。
调用构造函数
方法和接收者
Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。
方法的定义格式如下：
其中，
举个例子：
方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。
指针类型的接收者
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self。 例如我们为Person添加一个SetAge方法，来修改实例变量的年龄。
调用该方法：
值类型的接收者
当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。
什么时候应该使用指针类型接收者
任意类型添加方法
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。
注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。
结构体的匿名字段
匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。
嵌套结构体
一个结构体中可以嵌套包含另一个结构体或结构体指针。
嵌套匿名结构体
当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。
嵌套结构体的字段名冲突
嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体的字段。
结构体的“继承”
Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。
结构体字段的可见性
结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。
结构体与JSON序列化
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。
结构体标签（Tag）
Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。 Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：
`key1:"value1" key2:"value2"`
结构体标签由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。键值对之间使用一个空格分隔。 注意事项： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。
例如我们为Student结构体的每个字段定义json序列化时使用的Tag：
加密的原因：保证数据安全
加密必备要素：1、明文/密文 2、秘钥 3、算法
秘钥：在密码学中是一个定长的字符串、需要根据加密算法确定其长度
加密算法解密算法一般互逆、也可能相同
常用的两种加密方式：
对称加密：秘钥：加密解密使用同一个密钥、数据的机密性双向保证、加密效率高、适合加密于大数据大文件、加密强度不高(相对于非对称加密)
非对称加密：秘钥：加密解密使用的不同秘钥、有两个密钥、需要使用密钥生成算法生成两个秘钥、数据的机密性只能单向加密、如果想解决这个问题、双向都需要各自有一对秘钥、加密效率低、加密强度高
公钥：可以公开出来的密钥、公钥加密私钥解密
私钥：需要自己妥善保管、不能公开、私钥加密公钥解密
安全程度高：多次加密
按位异或运算
凯撒密码：加密方式 通过将铭文所使用的字母表按照一定的字数平移来进行加密
mod：取余
加密三要素：明文/密文(字母)、秘钥(3)、算法(向右平移3/-3)
安全常识：不要使用自己研发的算法、不要钻牛角尖、没必要研究底层实现、了解怎么应用；低强度的密码比不进行任何加密更危险；任何密码都会被破解；密码只是信息安全的一部分
保证数据的机密性、完整性、认证、不可否认性
计算机操作对象不是文字、而是由0或1排列而成的比特序列、程序存储在磁盘是二进制的字符串、为比特序列、将现实的东西映射为比特序列的操作称为编码、加密又称之为编码、解密称之为解码、根据ASCII对照表找到对应的数字、转换成二进制
三种对称加密算法：DES\3DES\ AES
DES：已经被破解、除了用它来解密以前的明文、不再使用
密钥长度为56bit/8、为7byte、每隔7个bit会设置一个用于错误检查的比特、因此实际上是64bit
分组密码(以组为单位进行处理)：加密时是按照一个单位进行加密(8个字节/64bit为一组)、每一组结合秘钥通过加密算法得到密文、加密后的长度不变
3DES:三重DES为了增加DES的强度、将DES重复三次所得到的一种加密算法 密钥长度24byte、分成三份 加密--解密--加密 目的：为了兼容DES、秘钥1秘钥2相同==三个秘钥相同 ---加密一次 密钥1秘钥3相同--加密三次 三个密钥不相同最好、此时解密相当于加密、中间的一次解密是为了有三个密钥相同的情况
此时的解密操作与加密操作互逆，安全、效率低
数据先解密后加密可以么？可以、解密相当于加密、加密解密说的是算法
AES：(首选推荐)底层算法为Rijndael 分组长度为128bit、密钥长度为128bit到256bit范围内就可以 但是在AES中、密钥长度只有128bit\192bit\256bit 在go提供的接口中、只能是16字节(128bit)、其他语言中秘钥可以选择
目前为止最安全的、效率高
底层算法
分组密码的模式：
按位异或、对数据进行位运算、先将数据转换成二进制、按位异或操作符^、相同为真、不同为假、非0为假 按位异或一次为加密操作、按位异或两次为解密操作：a和b按位异或一次、结果再和b按位异或
ECB : 如果明文有规律、加密后的密文有规律不安全、go里不提供该接口、明文分组分成固定大小的块、如果最后一个分组不满足分组长度、则需要补位
CBC：密码链
问题：如何对字符串进行按位异或？解决了ECB的规律可查缺点、但是他不能并行处理、最后一个明文分组也需要填充 、初始化向量长度与分组长度相同
CFB:密文反馈模式
不需要填充最后一个分组、对密文进行加密
OFB：
不需要对最后一组进行填充
CTR计数器:
不需要对最后一组进行填充、不需要初始化向量
Go中的实现
官方文档中：
在创建aes或者是des接口时都是调用如下的方法、返回的block为一个接口
func NewCipher(key [] byte ) ( cipher . Block , error )
type Block interface {
// 返回加密字节块的大小
BlockSize() int
// 加密src的第一块数据并写入dst，src和dst可指向同一内存地址
Encrypt(dst, src []byte)
// 解密src的第一块数据并写入dst，src和dst可指向同一内存地址
Decrypt(dst, src []byte)
}
Block接口代表一个使用特定密钥的底层块加/解密器。它提供了加密和解密独立数据块的能力。
Block的Encrypt/Decrypt也能进行加密、但是只能加密第一组、因为aes的密钥长度为16、所以进行操作的第一组数据长度也是16
如果分组模式选择的是cbc
func NewCBCEncrypter(b Block, iv []byte) BlockMode 加密
func NewCBCDecrypter(b Block, iv []byte) BlockMode 解密
加密解密都调用同一个方法CryptBlocks()
并且cbc分组模式都会遇到明文最后一个分组的补充、所以会用到加密字节的大小
返回一个密码分组链接模式的、底层用b加密的BlockMode接口，初始向量iv的长度必须等于b的块尺寸。iv自己定义
返回的BlockMode同样也是一个接口类型
type BlockMode interface {
// 返回加密字节块的大小
BlockSize() int
// 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址
CryptBlocks(dst, src []byte)
}
BlockMode接口代表一个工作在块模式（如CBC、ECB等）的加/解密器
返回的BlockMode其实是一个cbc的指针类型中的b和iv
# 加密流程:
1. 创建一个底层使用des/3des/aes的密码接口 "crypto/des" func NewCipher(key []byte) (cipher.Block, error) # -- des func NewTripleDESCipher(key []byte) (cipher.Block, error) # -- 3des "crypto/aes" func NewCipher(key []byte) (cipher.Block, error) # == aes
2. 如果使用的是cbc/ecb分组模式需要对明文分组进行填充
3. 创建一个密码分组模式的接口对象 - cbc func NewCBCEncrypter(b Block, iv []byte) BlockMode # 加密 - cfb func NewCFBEncrypter(block Block, iv []byte) Stream # 加密 - ofb - ctr
4. 加密, 得到密文
流程：
填充明文：
先求出最后一组中的字节数、创建新切片、长度为新切片、值也为切片的长度、然后利用bytes.Reapet将长度换成字节切片、追加到原明文中
//明文补充
func padPlaintText(plaintText []byte,blockSize int)[]byte{
//1、求出需要填充的个数
padNum := blockSize-len(plaintText) % blockSize
//2、对填充的个数进行操作、与原明文进行合并
newPadding := []byte{byte(padNum)}
newPlain := bytes.Repeat(newPadding,padNum)
plaintText = append(plaintText,newPlain...)
return plaintText
}
去掉填充数据：
拿去切片中的最后一个字节、得到尾部填充的字节个数、截取返回
//解密后的明文曲调补充的地方
func createPlaintText(plaintText []byte,blockSize int)[]byte{
//1、得到最后一个字节、并将字节转换成数字、去掉明文中此数字大小的字节
padNum := int(plaintText[len(plaintText)-1])
newPadding := plaintText[:len(plaintText)-padNum]
return newPadding
}
des加密：
1、创建一个底层使用des的密码接口、参数为秘钥、返回一个接口
2、对明文进行填充
3、创建一个cbc模式的接口、需要创建iv初始化向量、返回一个blockmode对象
4、加密、调用blockmode中的cryptBlock函数进行加密、参数为目标参数和源参数
//des利用分组模式cbc进行加密
func EncryptoText(plaintText []byte,key []byte)[]byte{
//1、创建des对象
cipherBlock,err := des.NewCipher(key)
if err != nil {
panic(err)
}
//2、对明文进行填充
newText := padPlaintText(plaintText,cipherBlock.BlockSize())
//3、选择分组模式、其中向量的长度必须与分组长度相同
iv := make([]byte,cipherBlock.BlockSize())
blockMode := cipher.NewCBCEncrypter(cipherBlock,iv)
//4、加密
blockMode.CryptBlocks(newText,newText)
return newText
}
des解密：
1、创建一个底层使用des的密码接口、参数为秘钥、返回一个接口
2、创建一个cbc模式的接口、需要创建iv初始化向量，返回一个blockmode对象
3、加密、调用blockmode中的cryptBlock函数进行解密、参数为目标参数和源参数
4、调用去掉填充数据的方法
//des利用分组模式cbc进行解密
func DecryptoText(cipherText []byte, key []byte)[]byte{
//1、创建des对象
cipherBlock,err := des.NewCipher(key)
if err != nil {
panic(err)
}
//2、创建cbc分组模式接口
iv := []byte("12345678")
blockMode := cipher.NewCBCDecrypter(cipherBlock,iv)
//3、解密
blockMode.CryptBlocks(cipherText,cipherText)
//4、将解密后的数据进行去除填充的数据
newText := clearPlaintText(cipherText,cipherBlock.BlockSize())
return newText
}
Main函数调用
func main(){
//需要进行加密的明文
plaintText := []byte("CBC--密文没有规律、经常使用的加密方式，最后一个分组需要填充，需要初始化向量" +
"(一个数组、数组的长度与明文分组相等、数据来源:负责加密的人提供，加解密使用的初始化向量必须相同)")
//密钥Key的长度需要与分组长度相同、且加密解密的密钥相同
key := []byte("1234abcd")
//调用加密函数
cipherText := EncryptoText(plaintText,key)
newPlaintText := DecryptoText(cipherText,key)
fmt.Println(string(newPlaintText))
}
AES加密解密相同、所以只需要调用一次方法就可以加密、调用两次则解密
推荐是用分组模式：cbc、ctr
aes利用分组模式cbc进行加密
//对明文进行补充
func paddingPlaintText(plaintText []byte , blockSize int ) []byte {
//1、求出分组余数
padNum := blockSize - len(plaintText) % blockSize
//2、将余数转换为字节切片、然后利用bytes.Repeat得出有该余数的大小的字节切片
padByte := bytes.Repeat([]byte{byte(padNum)},padNum)
//3、将补充的字节切片添加到原明文中
plaintText = append(plaintText,padByte...)
return plaintText
}
//aes加密
func encryptionText(plaintText []byte, key []byte) []byte {
//1、创建aes对象
block,err := aes.NewCipher(key)
if err != nil {
panic(err)
}
//2、明文补充
newText := paddingPlaintText(plaintText,block.BlockSize())
//3、创建cbc对象
iv := []byte("12345678abcdefgh")
blockMode := cipher.NewCBCEncrypter(block,iv)
//4、加密
blockMode.CryptBlocks(newText,newText)
return newText
}
//解密后的去尾
func clearplaintText(plaintText []byte, blockSize int) []byte {
//1、得到最后一个字节、并转换成整型数据
padNum := int(plaintText[len(plaintText)-1])
//2、截取明文字节中去掉得到的整型数据之前的数据、此处出错、没有用len-padNum
newText := plaintText[:len(plaintText)-padNum]
return newText
}
//aes解密
func deCryptionText(crypherText []byte, key []byte ) []byte {
//1、创建aes对象
block, err := aes.NewCipher(key)
if err != nil {
panic(err)
}
//2、创建cbc对象
iv := []byte("12345678abcdefgh")
blockMode := cipher.NewCBCDecrypter(block,iv)
//3、解密
blockMode.CryptBlocks(crypherText,crypherText)
//4、去尾
newText := clearplaintText(crypherText,block.BlockSize())
return newText
}
func main(){
//需要进行加密的明文
plaintText := []byte("CBC--密文没有规律、经常使用的加密方式，最后一个分组需要填充，需要初始化向量")
//密钥Key的长度需要与分组长度相同、且加密解密的密钥相同
key := []byte("12345678abcdefgh")
//调用加密函数
cipherText := encryptionText(plaintText,key)
//调用解密函数
newPlaintText := deCryptionText(cipherText,key)
fmt.Println("解密后",string(newPlaintText))
}
//aes--ctr加密
func encryptionCtrText(plaintText []byte, key []byte) []byte {
//1、创建aes对象
block,err := aes.NewCipher(key)
if err != nil {
panic(err)
}
//2、创建ctr对象，虽然ctr模式不需要iv，但是go中使用ctr时还是需要iv
iv := []byte("12345678abcdefgh")
stream := cipher.NewCTR(block,iv)
stream.XORKeyStream(plaintText,plaintText)
return plaintText
}
func main() {
//aes--ctr加密解密、调用两次即为解密、因为加密解密函数相同stream.XORKeyStream
ctrcipherText := encryptionCtrText(plaintText, key)
ctrPlaintText := encryptionCtrText(ctrcipherText,key)
fmt.Println("aes解密后", string(ctrPlaintText))
}
英文单词：
明文：plaintext 密文：ciphertext 填充：padding/fill 去掉clear 加密Encryption 解密Decryption
单向散列函数(one-wayfunction)有一个输入和一个输出，其中输入称为消息(message)，输出称为散列值 (hashvalue)。单向散列函数可以根据消息的内容计算出散列值，而散列值就可以被用来检查消息的完整性。
这里的消息不一定是人类能够读懂的文字，也可以是图像文件或者声音文件。单向散列函数不需要知道消息实
际代表的含义。无论任何消息，单向散列函数都会将它作为单纯的比特序列来处理，即根据比特序列计算出散
列值。
散列值的长度和消息的长度无关。无论消息是1比特，还是100MB，甚至是IOOGB，单向散列函数都会计算出固 定长度的散列值。以SHA-I单向散列函数为例，它所计算出的散列值的长度永远是160比特(20字节)。
单向散列函数的相关术语有很多变体，不同参考资料中所使用的术语也不同，下面我们就介绍其中的儿个。 单向散列函数也称为 消息摘要函数(message digest function) 、 哈希函数 或者 杂凑函数 。 输入单向散列函数的消息也称为 原像 (pre-image) 。
单向散列函数输出的散列值也称为 消息摘要 (message digest)或者 指纹 (fingerprint)。 完整性 也称为一致性。
MD4是由Rivest于1990年设计的单向散列函数，能够产生128比特的散列值(RFC1186，修订版RFC1320)。不 过，随着Dobbertin提出寻找MD4散列碰撞的方法，因此现在它已经不安全了。
MD5是由Rwest于1991年设计的单项散列函数，能够产生128比特的散列值(RFC1321)。
MD5的强抗碰撞性已经被攻破，也就是说，现在已经能够产生具备相同散列值的两条不同的消息，因此它也已
经不安全了。
MD4和MD5中的MD是消息摘要(Message Digest)的缩写。
SHA-1是由NIST(NationalInstituteOfStandardsandTechnology，美国国家标准技术研究所)设计的一种能够产生 160比特的散列值的单向散列函数。1993年被作为美国联邦信息处理标准规格(FIPS PUB 180)发布的是 SHA,1995年发布的修订版FIPS PUB 180-1称为SHA-1。
SHA-1的消息长度存在上限，但这个值接近于2^64比特，是个非常巨大的数值，因此在实际应用中没有问题。
SHA-256、SHA-384和SHA-512都是由NIST设计的单向散列函数，它们的散列值长度分别为256比特、384比特和
512比特。这些单向散列函数合起来统称SHA-2，它们的消息长度也存在上限(SHA-256的上限接近于 2^64 比特，
SHA-384 和 SHA-512的上限接近于 2^128 比特)。这些单向散列函数是于2002年和 SHA-1 一起作为 FIPS PUB 180-2 发布的 SHA-1 的强抗碰撞性已于2005年被攻破, 也就是说，现在已经能够产生具备相同散列值的两条不同的消 息。不过，SHA-2还尚未被攻破。
切换到新语言始终是一大步，尤其是当您的团队成员只有一个时有该语言的先前经验。现在，Stream 的主要编程语言从 Python 切换到了 Go。这篇文章将解释stream决定放弃 Python 并转向 Go 的一些原因。
Go 非常快。性能类似于 Java 或 C++。对于用例，Go 通常比 Python 快 40 倍。
对于许多应用程序来说，编程语言只是应用程序和数据库之间的粘合剂。语言本身的性能通常并不重要。然而，Stream 是一个API 提供商，为 700 家公司和超过 5 亿最终用户提供提要和聊天平台。多年来，我们一直在优化 Cassandra、PostgreSQL、Redis 等，但最终，您会达到所使用语言的极限。Python 是一门很棒的语言，但对于序列化/反序列化、排名和聚合等用例，它的性能相当缓慢。我们经常遇到性能问题，Cassandra 需要 1 毫秒来检索数据，而 Python 会花费接下来的 10 毫秒将其转换为对象。
看看我如何开始 Go 教程中的一小段 Go 代码。（这是一个很棒的教程，也是学习 Go 的一个很好的起点。）
如果您是 Go 新手，那么在阅读那个小代码片段时不会有太多让您感到惊讶的事情。它展示了多个赋值、数据结构、指针、格式和一个内置的 HTTP 库。当我第一次开始编程时，我一直喜欢使用 Python 更高级的功能。Python 允许您在编写代码时获得相当的创意。例如，您可以：
这些功能玩起来很有趣，但是，正如大多数程序员会同意的那样，在阅读别人的作品时，它们通常会使代码更难理解。Go 迫使你坚持基础。这使得阅读任何人的代码并立即了解发生了什么变得非常容易。 注意：当然，它实际上有多“容易”取决于您的用例。如果你想创建一个基本的 CRUD API，我仍然推荐 Django + DRF或 Rails。
作为一门语言，Go 试图让事情变得简单。它没有引入许多新概念。重点是创建一种非常快速且易于使用的简单语言。它唯一具有创新性的领域是 goroutine 和通道。（100% 正确CSP的概念始于 1977 年，所以这项创新更多是对旧思想的一种新方法。）Goroutines 是 Go 的轻量级线程方法，通道是 goroutines 之间通信的首选方式。Goroutines 的创建非常便宜，并且只需要几 KB 的额外内存。因为 Goroutine 非常轻量，所以有可能同时运行数百甚至数千个。您可以使用通道在 goroutine 之间进行通信。Go 运行时处理所有复杂性。goroutines 和基于通道的并发方法使得使用所有可用的 CPU 内核和处理并发 IO 变得非常容易——所有这些都不会使开发复杂化。与 Python/Java 相比，在 goroutine 上运行函数需要最少的样板代码。您只需在函数调用前加上关键字“go”：
Go 的并发方法很容易使用。与 Node 相比，这是一种有趣的方法，开发人员必须密切关注异步代码的处理方式。Go 中并发的另一个重要方面是竞争检测器。这样可以很容易地确定异步代码中是否存在任何竞争条件。
我们目前用 Go 编写的最大的微服务编译需要 4 秒。与以编译速度慢而闻名的 Java 和 C++ 等语言相比，Go 的快速编译时间是一项重大的生产力胜利。我喜欢在程序编译的时候摸鱼，但在我还记得代码应该做什么的同时完成事情会更好。
首先，让我们从显而易见的开始：与 C++ 和 Java 等旧语言相比，Go 开发人员的数量并不多。根据StackOverflow的数据， 38% 的开发人员知道 Java， 19.3% 的人知道 C++，只有 4.6% 的人知道 Go。GitHub 数据显示了类似的趋势：Go 比 Erlang、Scala 和 Elixir 等语言使用更广泛，但不如 Java 和 C++ 流行。幸运的是，Go 是一种非常简单易学的语言。它提供了您需要的基本功能，仅此而已。它引入的新概念是“延迟”声明和内置的并发管理与“goroutines”和通道。（对于纯粹主义者来说：Go 并不是第一种实现这些概念的语言，只是第一种使它们流行起来的语言。）任何加入团队的 Python、Elixir、C++、Scala 或 Java 开发人员都可以在一个月内在 Go 上发挥作用，因为它的简单性。与许多其他语言相比，我们发现组建 Go 开发人员团队更容易。如果您在博尔德和阿姆斯特丹等竞争激烈的生态系统中招聘人员，这是一项重要的优势。
对于我们这样规模的团队（约 20 人）来说，生态系统很重要。如果您必须重新发明每一个小功能，您根本无法为您的客户创造价值。Go 对我们使用的工具有很好的支持。实体库已经可用于 Redis、RabbitMQ、PostgreSQL、模板解析、任务调度、表达式解析和 RocksDB。与 Rust 或 Elixir 等其他较新的语言相比，Go 的生态系统是一个重大胜利。它当然不如 Java、Python 或 Node 之类的语言好，但它很可靠，而且对于许多基本需求，你会发现已经有高质量的包可用。
Gofmt 是一个很棒的命令行实用程序，内置在 Go 编译器中，用于格式化代码。就功能而言，它与 Python 的 autopep8 非常相似。我们大多数人并不真正喜欢争论制表符与空格。格式的一致性很重要，但实际的格式标准并不那么重要。Gofmt 通过使用一种正式的方式来格式化您的代码来避免所有这些讨论。
Go 对协议缓冲区和 gRPC 具有一流的支持。这两个工具非常适合构建需要通过 RPC 通信的微服务。您只需要编写一个清单，在其中定义可以进行的 RPC 调用以及它们采用的参数。然后从这个清单中自动生成服务器和客户端代码。生成的代码既快速又具有非常小的网络占用空间并且易于使用。从同一个清单中，您甚至可以为许多不同的语言生成客户端代码，例如 C++、Java、Python 和 Ruby。因此，内部流量不再有模棱两可的 REST 端点，您每次都必须编写几乎相同的客户端和服务器代码。.
Go 没有像 Rails 用于 Ruby、Django 用于 Python 或 Laravel 用于 PHP 那样的单一主导框架。这是 Go 社区内激烈争论的话题，因为许多人主张你不应该一开始就使用框架。我完全同意这对于某些用例是正确的。但是，如果有人想构建一个简单的 CRUD API，他们将更容易使用 Django/DJRF、Rails Laravel 或Phoenix。对于 Stream 的用例，我们更喜欢不使用框架。然而，对于许多希望提供简单 CRUD API 的新项目来说，缺乏主导框架将是一个严重的劣势。
Go 通过简单地从函数返回错误并期望调用代码来处理错误（或将其返回到调用堆栈）来处理错误。虽然这种方法有效，但很容易失去问题的范围，以确保您可以向用户提供有意义的错误。错误包通过允许您向错误添加上下文和堆栈跟踪来解决此问题。另一个问题是很容易忘记处理错误。像 errcheck 和 megacheck 这样的静态分析工具可以方便地避免犯这些错误。虽然这些变通办法效果很好，但感觉不太对劲。您希望该语言支持正确的错误处理。
Go 的包管理绝不是完美的。默认情况下，它无法指定特定版本的依赖项，也无法创建可重现的构建。Python、Node 和 Ruby 都有更好的包管理系统。但是，使用正确的工具，Go 的包管理工作得很好。您可以使用Dep来管理您的依赖项，以允许指定和固定版本。除此之外，我们还贡献了一个名为的开源工具VirtualGo，它可以更轻松地处理用 Go 编写的多个项目。
我们进行的一个有趣的实验是在 Python 中使用我们的排名提要功能并在 Go 中重写它。看看这个排名方法的例子：
Python 和 Go 代码都需要执行以下操作来支持这种排名方法：
开发 Python 版本的排名代码大约花了 3 天时间。这包括编写代码、单元测试和文档。接下来，我们花了大约 2 周的时间优化代码。其中一项优化是将分数表达式 (simple_gauss(time)*popularity) 转换为抽象语法树. 我们还实现了缓存逻辑，可以在未来的特定时间预先计算分数。相比之下，开发此代码的 Go 版本大约需要 4 天时间。性能不需要任何进一步的优化。因此，虽然 Python 的最初开发速度更快，但基于 Go 的版本最终需要我们团队的工作量大大减少。另外一个好处是，Go 代码的执行速度比我们高度优化的 Python 代码快大约 40 倍。现在，这只是我们通过切换到 Go 体验到的性能提升的一个示例。
与 Python 相比，我们系统的其他一些组件在 Go 中构建所需的时间要多得多。作为一个总体趋势，我们看到 开发 Go 代码需要更多的努力。但是，我们花更少的时间 优化 代码以提高性能。
我们评估的另一种语言是Elixir.。Elixir 建立在 Erlang 虚拟机之上。这是一种迷人的语言，我们之所以考虑它，是因为我们的一名团队成员在 Erlang 方面拥有丰富的经验。对于我们的用例，我们注意到 Go 的原始性能要好得多。Go 和 Elixir 都可以很好地服务数千个并发请求。但是，如果您查看单个请求的性能，Go 对于我们的用例来说要快得多。我们选择 Go 而不是 Elixir 的另一个原因是生态系统。对于我们需要的组件，Go 有更成熟的库，而在许多情况下，Elixir 库还没有准备好用于生产环境。培训/寻找开发人员使用 Elixir 也更加困难。这些原因使天平向 Go 倾斜。Elixir 的 Phoenix 框架看起来很棒，绝对值得一看。
Go 是一种非常高性能的语言，对并发有很好的支持。它几乎与 C++ 和 Java 等语言一样快。虽然与 Python 或 Ruby 相比，使用 Go 构建东西确实需要更多时间，但您将节省大量用于优化代码的时间。我们在Stream有一个小型开发团队，为超过 5 亿最终用户提供动力和聊天。Go 结合了 强大的生态系统 、新开发人员的 轻松入门、快速的性能 、对并发的 可靠支持和高效的编程环境 ，使其成为一个不错的选择。Stream 仍然在我们的仪表板、站点和机器学习中利用 Python 来提供个性化的订阅源. 我们不会很快与 Python 说再见，但今后所有性能密集型代码都将使用 Go 编写。我们新的聊天 API也完全用 Go 编写。
当客户端在 发出POST请求时/albums，您希望将请求正文中描述的专辑添加到现有专辑数据中。
为此，您将编写以下内容：
1、编写代码
a.添加代码以将专辑数据添加到专辑列表。
在此代码中：
1）用于Context.BindJSON 将请求正文绑定到newAlbum。
2） album将从 JSON 初始化的结构附加到albums 切片。
3）向响应添加201状态代码，以及表示您添加的专辑的 JSON。
b.更改您的main函数，使其包含该router.POST函数，如下所示。
在此代码中：
1）将路径中的POST方法与 /albumspostAlbums函数相关联。
使用 Gin，您可以将处理程序与 HTTP 方法和路径组合相关联。这样，您可以根据客户端使用的方法将发送到单个路径的请求单独路由。
a.如果服务器从上一节开始仍在运行，请停止它。
b.从包含 main.go 的目录中的命令行，运行代码。
c.从不同的命令行窗口，用于curl向正在运行的 Web 服务发出请求。
该命令应显示添加专辑的标题和 JSON。
d.与上一节一样，使用curl检索完整的专辑列表，您可以使用它来确认添加了新专辑。
该命令应显示专辑列表。
当客户端向 发出请求时GET /albums/[id]，您希望返回 ID 与id路径参数匹配的专辑。
为此，您将：
a.在您在上一节中添加的函数下方postAlbums，粘贴以下代码以检索特定专辑。
此getAlbumByID函数将提取请求路径中的 ID，然后找到匹配的专辑。
在此代码中：
（1）Context.Param用于从 URL 中检索id路径参数。当您将此处理程序映射到路径时，您将在路径中包含参数的占位符。
（2）循环album切片中的结构，寻找其ID 字段值与id参数值匹配的结构。如果找到，则将该album结构序列化为 JSON，并将其作为带有200 OK HTTP 代码的响应返回。
如上所述，实际使用中的服务可能会使用数据库查询来执行此查找。
（3）如果找不到专辑，则返回 HTTP 404错误。
b.最后，更改您的main，使其包含对router.GET的新调用，路径现在为/albums/:id ，如以下示例所示。
在此代码中：
（1）将/albums/:id路径与getAlbumByID功能相关联。在 Gin 中，路径中项目前面的冒号表示该项目是路径参数。
a.如果服务器从上一节开始仍在运行，请停止它。
b.在包含 main.go 的目录中的命令行中，运行代码以启动服务器。
c.从不同的命令行窗口，用于curl向正在运行的 Web 服务发出请求。
该命令应显示您使用其 ID 的专辑的 JSON。如果找不到专辑，您将收到带有错误消息的 JSON。
恭喜！您刚刚使用 Go 和 Gin 编写了一个简单的 RESTful Web 服务。
本节包含您使用本教程构建的应用程序的代码。