Go语言基础语法（一）

本文介绍一些Go语言的基础语法。

成都创新互联公司专注于尚义网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供尚义营销型网站建设，尚义网站制作、尚义网页设计、尚义网站官网定制、小程序定制开发服务，打造尚义网络公司原创品牌,更为您提供尚义网站排名全网营销落地服务。

先来看一个简单的go语言代码：

go语言的注释方法：

代码执行结果：

下面来进一步介绍go的基础语法。

go语言中格式化输出可以使用 fmt 和 log 这两个标准库，

常用方法：

示例代码：

执行结果：

更多格式化方法可以访问中的fmt包。

log包实现了简单的日志服务，也提供了一些格式化输出的方法。

执行结果：

下面来介绍一下go的数据类型

下表列出了go语言的数据类型：

int、float、bool、string、数组和struct属于值类型，这些类型的变量直接指向存在内存中的值；slice、map、chan、pointer等是引用类型，存储的是一个地址，这个地址存储最终的值。

常量是在程序编译时就确定下来的值，程序运行时无法改变。

执行结果：

执行结果：

Go 语言的运算符主要包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符以及指针相关运算符。

算术运算符：

关系运算符：

逻辑运算符：

位运算符：

赋值运算符：

指针相关运算符：

下面介绍一下go语言中的if语句和switch语句。另外还有一种控制语句叫select语句，通常与通道联用，这里不做介绍。

if语法格式如下：

if ... else ：

else if：

示例代码：

语法格式：

另外，添加 fallthrough 会强制执行后面的 case 语句，不管下一条case语句是否为true。

示例代码：

执行结果：

下面介绍几种循环语句：

执行结果：

执行结果：

也可以通过标记退出循环：

--THE END--

为什么要使用 Go 语言？Go 语言的优势在哪里

1. 保留但大幅度简化指针

Go语言保留着C中值和指针的区别，但是对于指针繁琐用法进行了大量的简化，引入引用的概念。所以在Go语言中，你几乎不用担心会因为直接操作内寸而引起各式各样的错误。

2. 多参数返回

还记得在C里面为了回馈多个参数，不得不开辟几段指针传到目标函数中让其操作么？在Go里面这是完全不必要的。而且多参数的支持让Go无需使用繁琐的exceptions体系，一个函数可以返回期待的返回值加上error，调用函数后立刻处理错误信息，清晰明了。

3. Array，slice，map等内置基本数据结构

如果你习惯了Python中简洁的list和dict操作，在Go语言中，你不会感到孤单。一切都是那么熟悉，而且更加高效。如果你是C++程序员，你会发现你又找到了STL的vector 和 map这对朋友。

4. Interface

Go语言最让人赞叹不易的特性，就是interface的设计。任何数据结构，只要实现了interface所定义的函数，自动就implement了这个interface，没有像Java那样冗长的class申明，提供了灵活太多的设计度和OO抽象度，让你的代码也非常干净。千万不要以为你习惯了Java那种一条一条加implements的方式，感觉还行，等接口的设计越来越复杂的时候，无数Bug正在后面等着你。

同时，正因为如此，Go语言的interface可以用来表示任何generic的东西，比如一个空的interface，可以是string可以是int，可以是任何数据类型，因为这些数据类型都不需要实现任何函数，自然就满足空interface的定义了。加上Go语言的type assertion，可以提供一般动态语言才有的duck typing特性， 而仍然能在compile中捕捉明显的错误。

5. OO

Go语言本质上不是面向对象语言，它还是过程化的。但是，在Go语言中， 你可以很轻易的做大部分你在别的OO语言中能做的事，用更简单清晰的逻辑。是的，在这里，不需要class，仍然可以继承，仍然可以多态，但是速度却快得多。因为本质上，OO在Go语言中，就是普通的struct操作。

6. Goroutine

这个几乎算是Go语言的招牌特性之一了，我也不想多提。如果你完全不了解Goroutine，那么你只需要知道，这玩意是超级轻量级的类似线程的东西，但通过它，你不需要复杂的线程操作锁操作，不需要care调度，就能玩转基本的并行程序。在Go语言里，触发一个routine和erlang spawn一样简单。基本上要掌握Go语言，以Goroutine和channel为核心的内存模型是必须要懂的。不过请放心，真的非常简单。

7. 更多现代的特性

和C比较，Go语言完全就是一门现代化语言，原生支持的Unicode, garbage collection, Closures(是的，和functional programming language类似), function是first class object，等等等等。

看到这里，你可能会发现，我用了很多轻易，简单，快速之类的形容词来形容Go语言的特点。我想说的是，一点都不夸张，连Go语言的入门学习到提高，都比别的语言门槛低太多太多。在大部分人都有C的背景的时代，对于Go语言，从入门到能够上手做项目，最多不过半个月。Go语言给人的感觉就是太直接了，什么都直接，读源代码直接，写自己的代码也直接。

go语言数组，切片和字典的区别和联系

、数组　

与其他大多数语言类似，Go语言的数组也是一个元素类型相同的定长的序列。

（1）数组的创建。

数组有3种创建方式：[length]Type　、[N]Type{value1, value2, ... , valueN}、[...]Type{value1, value2, ... , valueN}　如下：

复制代码代码如下:

func test5() {

var iarray1 [5]int32

var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5}

iarray3 := [5]int32{1, 2, 3, 4, 5}

iarray4 := [5]int32{6, 7, 8, 9, 10}

iarray5 := [...]int32{11, 12, 13, 14, 15}

iarray6 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}}

fmt.Println(iarray1)

fmt.Println(iarray2)

fmt.Println(iarray3)

fmt.Println(iarray4)

fmt.Println(iarray5)

fmt.Println(iarray6)

}

结果：

[0 0 0 0 0]

[1 2 3 4 5]

[1 2 3 4 5]

[6 7 8 9 10]

[11 12 13 14 15]

[[1 0 0 0] [1 2 0 0] [1 2 3 0] [0 0 0 0]]

我们看数组 iarray1，只声明，并未赋值，Go语言帮我们自动赋值为0。再看 iarray2 和 iarray3 ，我们可以看到，Go语言的声明，可以表明类型，也可以不表明类型，var iarray3 = [5]int32{1, 2, 3, 4, 5} 也是完全没问题的。

（2）数组的容量和长度是一样的。cap() 函数和 len() 函数均输出数组的容量（即长度）。如：

复制代码代码如下:

func test6() {

iarray4 := [5]int32{6, 7, 8, 9, 10}

fmt.Println(len(iarray4))

fmt.Println(cap(iarray4))

}

输出都是5。

（3）使用：

复制代码代码如下:

func test7() {

iarray7 := [5]string{"aaa", `bb`, "可以啦", "叫我说什么好", "()"}

fmt.Println(iarray7)

for i := range iarray7 {

fmt.Println(iarray7[i])

}

}

二、切片

Go语言中，切片是长度可变、容量固定的相同的元素序列。Go语言的切片本质是一个数组。容量固定是因为数组的长度是固定的，切片的容量即隐藏数组的长度。长度可变指的是在数组长度的范围内可变。

（1）切片的创建。

切片的创建有4种方式：

1）make ( []Type ,length, capacity )

2) make ( []Type, length)

3) []Type{}

4) []Type{value1 , value2 , ... , valueN }

从3)、4)可见，创建切片跟创建数组唯一的区别在于 Type 前的“ [] ”中是否有数字，为空，则代表切片，否则则代表数组。因为切片是长度可变的。如下是创建切片的示例：

复制代码代码如下:

func test8() {

slice1 := make([]int32, 5, 8)

slice2 := make([]int32, 9)

slice3 := []int32{}

slice4 := []int32{1, 2, 3, 4, 5}

fmt.Println(slice1)

fmt.Println(slice2)

fmt.Println(slice3)

fmt.Println(slice4)

}

输出为：

[0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[]

[1 2 3 4 5]

如上，创造了4个切片，3个空切片，一个有值的切片。

（2）切片与隐藏数组：

一个切片是一个隐藏数组的引用，并且对于该切片的切片也引用同一个数组。如下示例，创建了一个切片slice0，并根据这个切片创建了2个切片 slice1 和 slice2：

复制代码代码如下:

func test9() {

slice0 := []string{"a", "b", "c", "d", "e"}

slice1 := slice0[2 : len(slice0)-1]

slice2 := slice0[:3]

fmt.Println(slice0, slice1, slice2)

slice2[2] = "8"

fmt.Println(slice0, slice1, slice2)

}

输出为：

[a b c d e] [c d] [a b c]

[a b 8 d e] [8 d] [a b 8]

可见，切片slice0 、 slice1 和 slice2是同一个底层数组的引用，所以slice2改变了，其他两个都会变。

（3）遍历、修改切片：

复制代码代码如下:

func test10() {

slice0 := []string{"a", "b", "c", "d", "e"}

fmt.Println("\n~~~~~~元素遍历~~~~~~")

for _, ele := range slice0 {

fmt.Print(ele, " ")

ele = "7"

}

fmt.Println("\n~~~~~~索引遍历~~~~~~")

for index := range slice0 {

fmt.Print(slice0[index], " ")

}

fmt.Println("\n~~~~~~元素索引共同使用~~~~~~")

for index, ele := range slice0 {

fmt.Print(ele, slice0[index], " ")

}

fmt.Println("\n~~~~~~修改~~~~~~")

for index := range slice0 {

slice0[index] = "9"

}

fmt.Println(slice0)

}

如上，前三种循环使用了不同的for range循环，当for后面，range前面有2个元素时，第一个元素代表索引，第二个元素代表元素值，使用 “_” 则表示忽略，因为go语言中，未使用的值会导致编译错误。

只有一个元素时，该元素代表索引。

只有用索引才能修改元素。如在第一个遍历中，赋值ele为7，结果没有作用。因为在元素遍历中，ele是值传递，ele是该切片元素的副本，修改它不会影响原本值，而在第四个遍历——索引遍历中，修改的是该切片元素引用的值，所以可以修改。

结果为：

~~~~~~元素遍历~~~~~~

a b c d e

~~~~~~索引遍历~~~~~~

a b c d e

~~~~~~元素索引共同使用~~~~~~

aa bb cc dd ee

~~~~~~修改~~~~~~

[9 9 9 9 9]

（4）、追加、复制切片：

复制代码代码如下:

func test11() {

slice := []int32{}

fmt.Printf("slice的长度为：%d,slice为：%v\n", len(slice), slice)

slice = append(slice, 12, 11, 10, 9)

fmt.Printf("追加后，slice的长度为：%d,slice为：%v\n", len(slice), slice)

slicecp := make([]int32, (len(slice)))

fmt.Printf("slicecp的长度为：%d,slicecp为：%v\n", len(slicecp), slicecp)

copy(slicecp, slice)

fmt.Printf("复制赋值后，slicecp的长度为：%d,slicecp为：%v\n", len(slicecp), slicecp)

}

追加、复制切片，用的是内置函数append和copy，copy函数返回的是最后所复制的元素的数量。

（5）、内置函数append

内置函数append可以向一个切片后追加一个或多个同类型的其他值。如果追加的元素数量超过了原切片容量，那么最后返回的是一个全新数组中的全新切片。如果没有超过，那么最后返回的是原数组中的全新切片。无论如何，append对原切片无任何影响。如下示例：

复制代码代码如下:

func test12() {

slice := []int32{1, 2, 3, 4, 5, 6}

slice2 := slice[:2]

_ = append(slice2, 50, 60, 70, 80, 90)

fmt.Printf("slice为：%v\n", slice)

fmt.Printf("操作的切片：%v\n", slice2)

_ = append(slice2, 50, 60)

fmt.Printf("slice为：%v\n", slice)

fmt.Printf("操作的切片：%v\n", slice2)

}

如上，append方法用了2次，结果返回的结果完全不同，原因是第二次append方法追加的元素数量没有超过 slice 的容量。而无论怎样，原切片slice2都无影响。结果：

slice为：[1 2 3 4 5 6]

操作的切片：[1 2]

slice为：[1 2 50 60 5 6]

操作的切片：[1 2]

如何在 Go 语言中用 Beats 开发 Logstash 插件

配置环境

在OSX系统上很容易安装GO的可执行文件:

brew install go

虽然Java或Ruby (或者任何我知道的语言) 可以在本地文件系统的任何地方使用命令,，但是Go项目必须使用单一专用的地址,，并且在$GOPATH环境变量下可用。

第 1 段（可获 1.54 积分）

R e; 7个月前 

创建项目对于Logstash插件，Beats项目可以从模板创建。官方文档的说明十分简单。鉴于Go对文件系统上的位置的严格要求，只需按照以下说明生成一个新的即可使用的Go项目。默认模板代码将在控制台中重复发送带增量计数器的事件：./redditbeat -e -d "*"

2016/12/13 22:55:56.013362 beat.go:267: INFO

Home path: [/Users/i303869/projects/private/go/src/github.com/nfrankel/redditbeat]

Config path: [/Users/i303869/projects/private/go/src/github.com/nfrankel/redditbeat]

Data path: [/Users/i303869/projects/private/go/src/github.com/nfrankel/redditbeat/data]

Logs path: [/Users/i303869/projects/private/go/src/github.com/nfrankel/redditbeat/logs]

2016/12/13 22:55:56.013390 beat.go:177: INFO Setup Beat: redditbeat; Version: 6.0.0-alpha1

2016/12/13 22:55:56.013402 processor.go:43: DBG  Processors: 

2016/12/13 22:55:56.013413 beat.go:183: DBG  Initializing output plugins

2016/12/13 22:55:56.013417 logp.go:219: INFO Metrics logging every 30s

2016/12/13 22:55:56.013518 output.go:167: INFO Loading template enabled. Reading template file:

/Users/i303869/projects/private/go/src/github.com/nfrankel/redditbeat/redditbeat.template.json

2016/12/13 22:55:56.013888 output.go:178: INFO Loading template enabled for Elasticsearch 2.x. Reading template file:

/Users/i303869/projects/private/go/src/github.com/nfrankel/redditbeat/redditbeat.template-es2x.json

2016/12/13 22:55:56.014229 client.go:120: INFO Elasticsearch url: 

2016/12/13 22:55:56.014272 outputs.go:106: INFO Activated elasticsearch as output plugin.

2016/12/13 22:55:56.014279 publish.go:234: DBG  Create output worker

2016/12/13 22:55:56.014312 publish.go:276: DBG  No output is defined to store the topology.

The server fields might not be filled.

2016/12/13 22:55:56.014326 publish.go:291: INFO Publisher name: LSNM33795267A

2016/12/13 22:55:56.014386 async.go:63: INFO Flush Interval set to: 1s

2016/12/13 22:55:56.014391 async.go:64: INFO Max Bulk Size set to: 50

2016/12/13 22:55:56.014395 async.go:72: DBG  create bulk processing worker (interval=1s, bulk size=50)

2016/12/13 22:55:56.014449 beat.go:207: INFO redditbeat start running.

2016/12/13 22:55:56.014459 redditbeat.go:38: INFO redditbeat is running! Hit CTRL-C to stop it.

2016/12/13 22:55:57.370781 client.go:184: DBG  Publish: {

"@timestamp": "2016-12-13T22:54:47.252Z",

"beat": {

"hostname": "LSNM33795267A",

"name": "LSNM33795267A",

"version": "6.0.0-alpha1"

},

"counter": 1,

"type": "redditbeat"

}

第 2 段（可获 0.73 积分）

R e; 7个月前 

关于命令行参数：-e记录到标准err，而-d“*”启用所有调试选择器。有关参数的完整列表，请键入./redditbeat --help。编码Go代码位于.go文件中（令人惊讶...）在$ GOPATH / src文件夹的项目子文件夹中。配置类型第一个有趣的文件是config / config.go，它定义了一个结构来声明Beat的可能参数。至于前面的Logstash插件，让我们添加一个subreddit参数，并设置它的默认值：type Config struct {

Period time.Duration `config:"period"`

Subreddit string `config:"subreddit"`

}

var DefaultConfig = Config {

Period: 15 * time.Second,

Subreddit: "elastic",

}

第 3 段（可获 0.89 积分）

R e; 7个月前 

Beater TypeBeat本身的代码在beater / redditbean.go中找到。默认模板为Beat和三个函数创建一个struct：Beat构造函数—用来读取配置: func New(b *beat.Beat, cfg *common.Config) (beat.Beater, error) { ... } 

Run 函数- 需要覆盖Beat的主要功能: func (bt *Redditbeat) Run(b *beat.Beat) error { ... } 

Stop 函数管理优雅关闭: func (bt *Redditbeat) Stop() { ... } 

Note 1:在Go中没有明确的接口实现。实现了 interface 中的所有方法，即创建一个隐式继承关系. 出于写文档的目的，这是 Beater 接口:type Beater interface {

Run(b *Beat) error

Stop()

}

第 4 段（可获 0.93 积分）

R e; 7个月前 

因此，由于Beat结构实现了Run和Stop，它是一个Beater。Note 2: 在Go中没有类的概念，所以方法不能在一个具体类型上声明。但是，它存在扩展函数的概念：可以添加行为到一个类型（在单个包中）的函数。它需要声明receiver 类型：这是在fun关键字和函数名之间完成的 - 这里是指Redditbeat类型（或者更准确地说，是一个指向Redditbeat类型的指针，但是这里有一个隐式转换）。构造函数和Stop函数可以保持不变，无论什么特性都应该在Run函数中。在这种情况下，功能是调用Reddit REST API并为每个Reddit帖子发送一条消息。

第 5 段（可获 1.59 积分）

R e; 7个月前 

最终代码如下所示：func (bt *Redditbeat) Run(b *beat.Beat) error {

bt.client = b.Publisher.Connect()

ticker := time.NewTicker(bt.config.Period)

reddit := "" + bt.config.Subreddit + "/.json"

client := http.Client {}

for {

select {

case -bt.done:

return nil

case -ticker.C:

}

req, reqErr := http.NewRequest("GET", reddit, nil)

req.Header.Add("User-Agent", "Some existing header to bypass 429 HTTP")

if (reqErr != nil) {

panic(reqErr)

}

resp, getErr := client.Do(req)

if (getErr != nil) {

panic(getErr)

}

body, readErr := ioutil.ReadAll(resp.Body)

defer resp.Body.Close()

if (readErr != nil) {

panic(readErr)

}

trimmedBody := body[len(prefix):len(body) - len(suffix)]

messages := strings.Split(string(trimmedBody), separator)

for i := 0; i  len(messages); i ++ {

event := common.MapStr{

"@timestamp": common.Time(time.Now()),

"type":       b.Name,

"message":    "{" + messages[i] + "}",

}

bt.client.PublishEvent(event)

}

}

}

第 6 段（可获 0.09 积分）

R e; 7个月前 

这里是对最重要的几部分的解释：line 4: 通过连接字符串创建Reddit REST URL，包括配置Subreddit参数。记住，它的默认值已在config.go文件中定义。line 5: 引用httpClient类型line 12: 创建新的HTTP请求。注意Go允许多个返回值。line 13: 如果没有设置标准请求头，Reddit的API将返回429状态码。line 14: Go标准错误不通过异常处理，而是随着常规返回值返回。根据Golang wiki：指示调用者的错误条件，应通过返回错误值来完成line 15: panic() 函数类似于在Java中抛出异常, 被处理时推到栈顶。 有关详细信息，请查看相关文档。line 17: 执行HTTP请求。line 21: 将响应主体读入字节数组。line 22: 关闭主体流。注意defer关键字：defer语句延迟函数的执行，直到环绕的函数返回。line 26: 创建整个响应主体字节数组的切片 - 对数组的一部分的引用。实质上，它删除了前缀和后缀以保持相关的JSON值。之后将字节数组解析成JSON。line 27: 分割切片以单独获取每个JSON片段。line 29: 将消息创建为简单的字典结构。line 34: 发送。

第 7 段（可获 3.11 积分）

R e; 7个月前 

配置, 构建, 运行默认配置参数可以在项目根目录下的redditbeat.yml文件中找到。请注意，redditbeat.full.yml中列出了其他常见的Beat参数，以及相关注释。关于Beats的一个有趣的事情是，他们的消息可以直接发送到Elasticsearch或Logstash进行进一步处理。这在上述配置文件中配置。redditbeat:

period: 10s

output.elasticsearch:

hosts: ["localhost:9200"]

output.logstash:

hosts: ["localhost:5044"]

enabled: true

第 8 段（可获 0.78 积分）

R e; 7个月前 

此配置片段将每10秒循环运行Run方法，并将消息发送到在localhost上运行的Logstash实例在端口5044上。这可以在运行Beat时被覆盖（见下文）。注意：为了使Logstash接受来自Beats的消息，必须安装Logstash Beat插件，并且必须为Beats配置Logstash的input：input {

beats {

port = 5044

}

}

要构建项目，请在项目的根目录中键入make。它将创建一个可以运行的可执行文件。./redditbeat -e -E redditbeat.subreddit=java

-E参数可以覆盖在的redditbeat.yml配置文件中找到的参数（见上文）。在这里，它设置subreddit读为“java”，而不是默认的“elastic”。

第 9 段（可获 1.3 积分）

R e; 7个月前 

输出如下所示:2016/12/17 14:51:19.748329 client.go:184: DBG  Publish: {

"@timestamp": "2016-12-17T14:51:19.748Z",

"beat": {

"hostname": "LSNM33795267A",

"name": "LSNM33795267A",

"version": "6.0.0-alpha1"

},

"message": "{

\"kind\": \"t3\", \"data\": {

\"contest_mode\": false, \"banned_by\": null, 

\"domain\": \"blogs.oracle.com\", \"subreddit\": \"java\", \"selftext_html\": null, 

\"selftext\": \"\", \"likes\": null, \"suggested_sort\": null, \"user_reports\": [], 

\"secure_media\": null, \"saved\": false, \"id\": \"5ipzgq\", \"gilded\": 0, 

\"secure_media_embed\": {}, \"clicked\": false, \"report_reasons\": null, 

\"author\": \"pushthestack\", \"media\": null, \"name\": \"t3_5ipzgq\", \"score\": 11, 

\"approved_by\": null, \"over_18\": false, \"removal_reason\": null, \"hidden\": false, 

\"thumbnail\": \"\", \"subreddit_id\": \"t5_2qhd7\", \"edited\": false, 

\"link_flair_css_class\": null, \"author_flair_css_class\": null, \"downs\": 0, 

\"mod_reports\": [], \"archived\": false, \"media_embed\": {}, \"is_self\": false, 

\"hide_score\": false, \"spoiler\": false, 

\"permalink\": \"/r/java/comments/5ipzgq/jdk_9_will_no_longer_bundle_javadb/\", 

\"locked\": false, \"stickied\": false, \"created\": 1481943248.0, 

\"url\": \"\", 

\"author_flair_text\": null, \"quarantine\": false, 

\"title\": \"JDK 9 will no longer bundle JavaDB\", \"created_utc\": 1481914448.0, 

\"link_flair_text\": null, \"distinguished\": null, \"num_comments\": 4, 

\"visited\": false, \"num_reports\": null, \"ups\": 11

}

}",

"type": "redditbeat"

}

Go语言设计与实现（上）

基本设计思路：

类型转换、类型断言、动态派发。iface，eface。

反射对象具有的方法：

编译优化：

内部实现：

实现 Context 接口有以下几个类型（空实现就忽略了）：

互斥锁的控制逻辑：

设计思路：

（以上为写被读阻塞，下面是读被写阻塞）

总结，读写锁的设计还是非常巧妙的：

设计思路：

WaitGroup 有三个暴露的函数:

部件：

设计思路：

结构：

Once 只暴露了一个方法：

实现：

三个关键点：

细节：

让多协程任务的开始执行时间可控（按顺序或归一）。（Context 是控制结束时间）

设计思路： 通过一个锁和内置的 notifyList 队列实现，Wait() 会生成票据，并将等待协程信息加入链表中，等待控制协程中发送信号通知一个（Signal()）或所有（Boardcast()）等待者（内部实现是通过票据通知的）来控制协程解除阻塞。

暴露四个函数：

实现细节：

部件：

包： golang.org/x/sync/errgroup

作用：开启 func() error 函数签名的协程，在同 Group 下协程并发执行过程并收集首次 err 错误。通过 Context 的传入，还可以控制在首次 err 出现时就终止组内各协程。

设计思路：

结构：

暴露的方法：

实现细节：

注意问题：

包： "golang.org/x/sync/semaphore"

作用：排队借资源（如钱，有借有还）的一种场景。此包相当于对底层信号量的一种暴露。

设计思路：有一定数量的资源 Weight，每一个 waiter 携带一个 channel 和要借的数量 n。通过队列排队执行借贷。

结构：

暴露方法：

细节：

部件：

细节：

包： "golang.org/x/sync/singleflight"

作用：防击穿。瞬时的相同请求只调用一次，response 被所有相同请求共享。

设计思路：按请求的 key 分组（一个 *call 是一个组，用 map 映射存储组），每个组只进行一次访问，组内每个协程会获得对应结果的一个拷贝。

结构：

逻辑：

细节：

部件：

如有错误，请批评指正。

Python开发者在转到Go语言之前需要了解什么？

转载请参见文章末尾处的要求。【感谢张佳伟（@ghosert）的热心翻译。如果其他朋友也有不错的原创或译文，可以尝试推荐给伯乐在线。】这是一篇（长）博文， 介绍了我们在 Repustate 迁移大量 Python/Cython 代码到 Go 语言的经验。如果你想了解整个故事，背景和所有的事情，请继续往下读。如果你只是想了解 Python 开发者在一头扎进 Go 语言前需要了解什么，请点击一下链接：从Python迁移到Go的建议(Tips Tricks) 背景在Repustate，我们完成过的最棒的技术成就之一是实现了阿拉伯语的情感分析。阿拉伯语是一块难啃的硬骨头，因为它的词形变化相当复杂。比起譬如英语，阿拉伯语的分词（将一个句子切分呈几个独立的单词）也更困难，因为阿拉伯语的单词本身还可能会包含空白字符（例如：“阿列夫”在一个单词里的位置）。这也谈不上是泄密，Repustate 使用支持向量机（SVM）来获取一个句子背后最有可能的含义，并在其中加上情感元素。 总体上来说，我们使用了 22 种模型（22 个 SVM） 并且在一篇文档中，每一个单词我们都会加以分析。因此如果你有一篇 500 字的文档，那么基于 SVM，会进行十万次的比较。 PythonRepustate 几乎完全就是一个 Python 商店。我们使用 Django 来实现 API 和网站。因此（目前）为了保持代码一致，同时使用 Python 来实现阿拉伯语情感引擎是合情合理的。只是做原型和实现的话，Python 是很好的选择。它的表达能力很强悍，第三方类库等等也很好。如果你就是为了Web服务，Python 很完美。但是当你进行低级别的计算，大量依赖于哈希表（Python 里的字典类型）做比较的时候，一切都变慢了。我们每秒能处理大约两到三个阿拉伯文档，但是这太慢了。比较下来，我们的英语情感引擎每秒能处理大约五百份文档。 瓶颈因此我们开启了 Python 分析器，开始调查是什么地方用了那么长时间。还记得我前面说过我们有 22 个 SVM 并且每个单词都需要经过处理吗？好吧，这些都是线性处理的，非并行处理。所以我们的第一反应是把线性处理改成 map/reduce 那样的操作。简单来说：Python 不太适合用作 map/reduce。当你需要并发的时候，Python 算上好用。在 2013 Python 大会上（译者：PyCon 2013），Guido 谈到了 Tulip，他的这个新项目正在弥补 Python 这方面的不足，不过得过段一段时间才能推出，但是如果已经有了更好用的东西，我们为什么还要等呢？ 选Go 语言，还是回家算了？我在Mozilla的朋友告诉我，Mozilla 内部正在将他们大量的基础日志架构切换到 Go 语言上，部分原因是因为强大的 [goroutines]。Go 语言是 Google 的人设计的，并且在设计之初就把支持并发作为第一要务，而不是像 Python 的各种解决方案那样是事后才加上去的。因此我们开始着手把 Python 换成 Go 语言。虽然Go 代码还不算正式上线的产品，但是结果非常令人鼓舞。我们现在能做到每秒处理一千份文档，使用更少的内存，还不用调试你在 Python 里遇到：丑陋的多进程/gevent/“为什么 Control-C 杀不了进程”这些问题。 为什么我们喜欢 Go 语言任何人，对编程语言是如何工作（解释型 vs 编译型， 动态语言 vs 静态语言）有一点理解的话，会说，“切，当然 Go 语言会更快”。是的，我们也可以用 Java 把所有的东西重写一遍，也能看到类似更快的改善，但那不是 Go 语言胜出的原因。你用 Go 写的代码好像就是对的。我搞不清楚到底是怎么回事，但是一旦代码被编译了（编译速度很快），你就会觉得这代码能工作（不只是跑起来不会错，而且甚至逻辑上也是对的）。我知道，这听上去不太靠谱，但是确实如此。这和 Python 在冗余（或非冗余）方面非常类似，它把函数作为第一目标，因此函数编程会很容易想明白。而且当然，go 线程和通道让你的生活更容易，你可以得到静态类型带来的性能大提升，还能更精细的控制内存分配，而你却不必为此在语言表达力上付出太多的代价。 希望能早点知道的事情（Tips Tricks）除去所有这些赞美之词以后，有时你真的需要在处理 Go 代码的时候，相对于 Python，改变一下思维方式。因此这是我在迁移代码时记录的笔记清单 —— 只是在我把 Python 代码转换到 Go 时从我脑子里随机冒出来的点子：没有内建的集合类型（必须使用map，并检查是否存在）因为没有集合，必须自己写交集，并集之类的方法没有tuples 类型，必须写你自己的结构，或者使用 slices （即数组）没有类似 \__getattr__() 的方法，你必须总是检查存在性，而不是设置默认值，例如，在 Python 里，你可以这样写 value = dict.get(“a_key”, “default_value”)必须总是检查错误（或者显式的忽略错误）不能有变量/包没被使用，因此简单的测试也需要有时注掉一些代码在[] byte 和 string 之间转换。 regexp 使用 [] byte （不可变）。这是对的，但是老把一些变量转换来转换去很烦人Python 更宽松。你可以使用超出范围的索引在字符串里取一个片段，而且不会出错。你还可以用负数取出片段，但是 Go 不行你不能混合数据结构类型。也许这样也不太干净，但是有时在 Python 里，我会使用值是混合了字符串和列表的字典。但是 Go 不行，你不得不清理干净你的数据结构或者使用自定义的结构不能解包一个 tuple 或者 list 到几个不同的变量（例如：x, y, z = [1, 2, 3]）驼峰式命名风格（如果你没有首字大写方法名/结构名，他们不会被暴露给其它的包）。我更喜欢 Python 的小写字母加下划线命名风格。必须显式检查是否有错误 != nil, 不像在 Python 里，许多类型可以像 bool 那样检查 （0, “”, None 都可以被解释成 “非” 集合）文档在一些模块上太散乱了，例如（crypto/md5），但是 IRC 上的 go-nuts 很好用，提供了巨大的帮助。从数字到字符串的转换（int64 - string） 和 []byte - string （只要使用 string([]byte)）不太一样。需要使用 strconv。阅读Go 代码比起 Python 那样写起来如伪代码的语言更像一门编程语言， Go 有更多的非字母数字字符，并且使用 || 和 ， 而不是 “or”和“and”写一个文件的话，有 File.Write([]byte) 和 File.WriteString(string)， 这点和 Python 开发者的 Python 之道：“解决问题就一种方法 ”相违背。修改字符串很困难，必须经常重排 fmt.Sprintf没有构造函数，因此惯用法是创建 NewType() 方法来返回你要的结构Else （或者 else if）必须正确格式化，else 得和 if 配对的大括号在同一行。奇怪。赋值运算符取决于在函数内还是函数外，例如，= 和 :=如果我只想要“键”或者只想要 “值”，譬如： dict.keys() 或者 dict.values()，或者一个 tuples 的列表，例如：dict.items()，在 Go 语言里没有等价的东西，你只能自己枚举 map 来构造你的列表类型我有时使用一种习惯用法：构造一个值是函数的字典类型，我想通过给定的键值调用这些函数，你在 Go 里可以做到，但是所有的函数必须接受，返回相同的东西，例如：相同的方法签名如果你使用 JSON 并且 你的 JSON 是一个复合类型，恭喜你。 你必须构造自定义的结构匹配 JSON 块里的格式，然后把原始 JSON 解析到你自定义结构的实例中去。比起 Python 世界里 object = json.loads(json_blob) 要做更多的工作 是不是值得？值得，一百万倍的值得。速度的提升太多了，以致很难舍弃。同时，我认为， Go 是目前趋势所在，因此在招新员工的时候，我认为把 Go 当作 Repustate 技术积累的重要一环会很有帮助。]

网站标题：go语言实现字典 go语言文档
网站路径：http://scgulin.cn/article/doodcci.html