• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号
登陆 注册
描述文字

Go!

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

 如果是入门级的中文文档资料，已经非常丰富，在google code上面有专门的翻译小组，CSDN也有中文手册下载，相关中文书籍也有出版。这里有免费的https://github.com/astaxie/build-web-application-with-golang/blob/master/ebook/preface.md 
库和框架有，确实不多，毕竟出来没几年，但前景不可限量。

 

http://www.mikespook.com/learning-go/

------------------------------------------------------------------

http://www.oschina.net/translate/migrating-code-from-python-to-golang-what-you-need-to-know

这是一篇记录了我们把一大段 Python/Cython 代码迁移到 Go语言经历的（长）博客。如果你希望了解整个故事、背景等所有的内容，请接着读。如果只对 Python 开发者进入之前需要知道的东西感兴趣，跳到“我们早该知道的事情”一章。

我们在 Repustate 技术上最大的成果就是实现了阿拉伯语情感分析。阿拉伯语真是一个难啃的骨头，它的单词语法形态太复杂了。阿拉伯语的分词（tokenization，把一个句子分成独立的词语）相比诸如英语更难，因为阿拉伯语单词内部可能包含空格（例如，aleph内的位置）。这个不需要保密，那就是 Repustate 使用了支持向量机（SVM）来得到句子最可能的意思，然后在此基础上分析情感。我们总共用了 22 个模型（22 个支持向量机），文档中的每个单词都会被分析。也就是说，如果一篇文档包含 500 词的话，将会有一万次以上的支持向量机的比较操作。
daviddengcn
翻译于 1个月前

0人顶

 

顶 翻译的不错哦!

Python

Repustate几乎是彻底用 Python 实现的，因为我们使用了 Django 作为应用程序接口和网站架构。所以只能保持代码的统一，同时用 Python 实现整个阿拉伯语情感引擎。原型与实现的过程中，Python 还是很不错的。非常强的表达能力，强大的第三方库资源。如果你只是服务于网页的话，还是很完美的。但是，当你需要进行底层计算，需要在散列表（Python 中的字典）上进行大量的比较运算的时候，速度就慢下来了。我们每秒钟只能处理2到3篇阿拉伯语文档，这太慢了。对比我们的英语情感引擎，每秒钟能处理 500 篇文档。

瓶颈

于是，我们启动了 Python 分析器，研究哪部分执行得慢。还记得我说过我们会用 22 个支持向量机处理每一个单词吗？这些处理都是串行的，没有并行操作。好，我们第一个想法是把这个改成类似 map/reduce 的操作。长话短说：Python 中不适合使用 map/reduce。当你需要并发性的时候，Python 一点都不好用。2013 年的 PyCon 大会上，Guido 提到了 Tulip，他试图解决这个问题的新项目，但是还需要一段时间才能推出。如果已经有更好的选择，我们为什么还要等它呢。
daviddengcn
翻译于 1个月前

0人顶

 

顶 翻译的不错哦!

换 Go 语言还是回家种田

我在 Mozilla 的朋友告诉我，Mazilla 服务中日志架构的大部分代码已经切换成 Go 了，部分原因是 goroutine（Go 协程）的强大。Go 是 Google 的一群人设计的，它把并行性作为一级概念，而不像 Python 的不同解决方案做的事后补充。于是，我们开始着手把 Python 换成 Go。

尽管 Go 代码还没达到产品级别，其结果已经非常令人鼓舞了。我们达到了每秒 1000 文档的速度，使用了更少的内存，还不用去处理用 Python 时碰到的多进程/gevent/“为什么 Ctrl+C 杀掉了我的进程”代码等讨厌的问题。
daviddengcn
翻译于 1个月前

0人顶

 

顶 翻译的不错哦!

我们为什么爱上了Go

只要知道一点儿编程语言工作原理的人，（明白解释和编译以及动态与静态的区别），就会说：“老兄，Go 显然会更快”。没错，我们也可以把整个东西用 Java 来重写，并且得到类似的性能，但这不是 Go 胜出的原因。你用 Go 写出代码来就很容易是正确的。我也说不清楚怎么回事，但是一旦代码编译通过（编译速度还很快），你就感觉到它可以工作了（不只是运行不提示错误，而是逻辑上就是对的）。我知道这听起来很玄乎，但确实是事实。这就像 Python 解决冗余问题（或者说无冗余），它把函数作为一级对象，从而函数编程可以轻松的进行。go线程和通道（channel）让你的生活如此轻松。你还可以得到静态类型带来的性能提升，更精确的控制内存分配，却不会因此损失表达性。
daviddengcn
翻译于 1个月前

0人顶

 

顶 翻译的不错哦!

我们早该知道的事情

除去那些赞美之词，用 Go 的时候需要一种不同于用 Python 时的心态。下面是一些迁移时候的笔记，把 Python 转成 Go 时随机跃入我脑子的东西：

  • 没有内建的集合类型（需要使用 map 然后检查存在性）
  • 由于没有集合类型，需要自己实现交集、并集等方法
  • 没有元组（tuple），需要设计自己的结构（struct）或者使用slice（类似数组）
  • 没有类似 __getattr_() 的方法，需要你检查存在性而不能设置缺省值，例如 Python 中，你可以这么写：value = dict.get("a_key", "default_value")
  • 需要检查错误（或者至少显式的忽略它们）
  • 不能够有未使用的变量和包，需要时不时的注释掉一些代码
  • 在 []byte 和 string 之间切换，正则处理（regexp）使用 []byte（可改写的）。这是对的，但转换来转换去还是很麻烦
  • Python 语法更宽松。你可以用超出范围的索引取字符串的片段而不出错，也可以使用负数取片段。Go 就不行。
  • 无法使用混合类型的数据结构。这可能不一定合适，但是 Python 中有时候我会有一个取值可以是字符串和列表混合的字典。Go 里不行，你必须清理里的数据结构或者自定义结构*
  • 没法把元组或者列表分配成分开的变量（例如，x, y, x = [1, 2, 3]）
  • 驼峰式大小写习惯（首字母不大写的函数/结构不会暴露给其他包）。我更喜欢 Python 的小写加下划线的习惯。
  • 必须显式的检查错误是否为空，不像 Python 中很多类型都可以像布尔类型一样的用（0，空串，None 都可以作为布尔“假”）
  • 一些模块（如 crypo/md5）的文档不足，但是 IRC 上的 go-nuts 很厉害，有强大的支持
  • 数字转字符串（int64->string）与 []byte 转字符串（只要 string([]byte)）不同，前者需要调用 strconv
  • 读 Go 的代码绝对像是编程语言，而 Python 可以写成像是伪代码一样。Go 使用更多的非英文数字字符，使用 || 和 && 而不是 or 和 and。
  • 写文件会有 File.Write([]byte) 和 File.WriteString(string)，与 Python 开发者的一种办法解决问题的信条不一致。
  • 字符串插入不好用，必须经常使用 fmt.Sprintf
  • 没有构造函数，通常的习惯是写一个 NewType() 函数返回你要的结构
  • Else（或者 else if）得正确的格式化，else 得和与 if 配对的大括号在一行。奇怪。
  • 函数内外使用不同的赋值操作符，= 和 := （译者注：此为作者的误解，:= 是自动类型推导定义变量+赋值，= 则只是赋值，原文作者碰到的问题是函数外不能用 := ，只能 var + = 定义全局变量；函数内部其实两种操作符都是可以使用的）
  • 如果我只想要键值（dict.keys()）或取值（dict.values()）的列表，或者元组的列表（dict.items()），Go 中没有对应的函数，只能自己迭代 map 然后填列表
  • 我常用的一种写法是通过建立一个取值为函数的字典，通过键值调用相应的函数。在 Go 里面可以实现，但是函数的输入输出必须相同，也就是函数签名必须一致。*
  • 如果你使用 JSON，并且 JSON 是混合类型的，那么你中招了。你必须建立一个匹配 JSON 数据格式的自定义结构，然后把 JSON 解析成这个自定义的结构。相比 Python 时候的一句 obj = json.loads(json_blog) 多了很多工作。*

（*译者注：以上很多条都是因为作者没有使用 Go 中的 interface{} 造成的）

这次折腾值吗？

绝对值，一百万个值！速度的提升简直太惊人了！并且我还想强调一下，Go 是一个现在时髦的语言，所以再招新人的时候，让 Go 成为 Repustate 的重要技术支持会很重要。

 ===========================================

http://www.mikespook.com/2011/02/%E7%BF%BB%E8%AF%91go-%E5%92%8C-python-%E7%9A%84-web-%E6%9C%8D%E5%8A%A1%E5%99%A8%E6%80%A7%E8%83%BD%E5%AF%B9%E6%AF%94/

原文在此：http://ziutek.github.com/web_bench/

由于是早上看到 鱼哥，在推上的推荐，我实在忍不住……这是中午的草率之举，所以鱼哥 对本文的翻译负全责。

PS：别说我工作状态不饱满，我在等丫的程序执行完……

————翻译分割线————

Go 和 Python Web 服务器性能对比

我通常使用 Python 来构建 Web 应用。一年前，在兴趣的驱使下，我开始学习 Go。 在此期间，我重写了一些原本由 C 开发的 CGI 应用，包括运行于 chroot 环境下的同thttpd 服务器一起的应用。我开始寻找可以开发易于 chroot、且内置 Web 服务器的独立 Web 应用的工具。那时，我开始玩 web.go 框架、mustache.go 模板、Go 原生 http 包和 GoMySQL 数据库 API。我发现，有 http、mustache.go  GoMySQL 包的 Go 可以是我用来工作的不错的工具组合。因此，我决定使用 Go 编写我的应用。
MyMySQL （为我的应用定制开发的包，不过我将其贡献给了 Go 社区）。重写的应用即便是在比以前的负载更高的运营环境下，也工作得很好。我开始思考这个问题：用 Go 实现独立 Web 应用比 Python 到底快了（或者是慢了）多少。我决定做一些各种框架和服务器不同的用途的测试。为了比较，我选择了下面的 Go 包：

  • 原始的 Go http包；
  • web.go 框架（它使用运行于独立模式[standalone mode] 的 http 包）；
  • twister 框架 （它同样使用 http 包）。

和下面的 Python Web服务器/框架：

  • 使用 CherryPy WSGI 服务器的 web.py 框架；
  • 使用 flup FastCGI 做 nginx 服务器的后台处理的 web.py 框架；
  • tornado 异步服务器/框架；
  • nginx 做负载均衡的 tornado。

每一个用例，我都编写了一个小应用，略微复杂一些的、传统的 Hello World 例子。任何应用都包括：

  • 使用正则表达式通过 URL 路径传递参数；
  • 使用语句创建多行输出；
  • 使用 printf 形式的格式化函数/表达式格式化输出。

我想，这些都是在 Web 应用中常见的操作，所以应当包含在任何简易的性能对比测试中。所有测试应用的代码在下面的链接中：

测试环境

测试环境包括两台 使用千兆以太网链接的PC （请求发起者和应用服务器）。

  • 请求发起者：2 x Xeon 2.6 GHz with hyperthreading, Debian SID, kernel: 2.6.33.7.2-rt30-1-686 #1 SMP PREEMPT RT；
  • 服务器: MSI Netbook with two core Intel U4100 1.30GHz, AC power connected, 64-bit Ubuntu 10.10, kernel: 2.6.35-25-generic #44-Ubuntu SMP, Python 2.6.6-2ubuntu2, web.py 0.34-2, flup 1.0.2-1, tornado 0.2-1, nginx 0.7.67-3ubuntu1；

为了产生 HTTP 请求并且评估测试应用的性能，我使用 siege 性能测试工具。Siege 可以用多线程模拟多个用户。我使用了下面的命令产生请求：

siege -c 200 -t 20s http://SERVER_ADDR:8080/Hello/100

或者多个类似的命令，减少参数 -c 的量（在这个测试中，我同时运行了多个 Python 脚本）。它模拟了 200 用户的请求，并持续 20 秒。这个 URL 使得 Web 应用对每个请求都输出 100 行。Go 应用使用 Go 发布版 2011-02-01.1。

结果

GOMAXPROCS=1, 一个 Python 进程：

框架 请求速率 [1/sec]
Go http 1350  
Twister 1324  
Web.go 1141  
Tornado 882  
Tornado+nginx 862  
Web.py+CheryPy 169  
Web.py+nginx 114  

GOMAXPROCS=2, 两个 Python 并发进程：

框架 请求速率 [1/sec]
Go http 1768  
Twister 1746  
Tornado 1682  
Web.go 1516  
Tornado+nginx 1378  
Web.py+CheryPy 308  
Web.py+nginx 198  

GOMAXPROCS=4, 四个 Python 并发进程：

框架 请求速率 [1/sec]
Go http 2063  
Twister 2020  
Web.go 1753  
Tornado 1662  
Tornado+nginx 1364  
Web.py+CheryPy 304  
Web.py+nginx 211  

Web.py+nginx 工作的 flup FastCGI 选项：multiplexed=False, multithreaded=False。如果 multiplexed=True 它会运行得慢一些。如果 multithreaded=True 而只有一个进程服务于 nginx 服务器，会报下面的错误：

[error] 18166#0: *66139 connect() to
unix:/home/michal/Programowanie/web_bench/socket failed (11: Resource
temporarily unavailable) while connecting to upstream

FastCGI 的多进程由 spawn-fcgi 产生。

结论

你可以看到 Go 赢得了几乎所有的测试用例。web.go 框架的那个不太理想的结果可能是由于它先尝试用指定的 URL 寻找静态页面，然后才会执行处理方法。让我惊讶的是 tornado Python 框架如此之高的性能，尤其是跟 web.py 框架相比而言。我同样对 CherryPy 服务器比 nginx+flup 快感到惊讶 (我使用 web.py+flup+nginx 跑几乎所有的 Python Web 应用)。

 

=============================================

 http://tonychee1989.diandian.com/Python-C-Go-test

数学上有个关于圆周率的近似值计算公式：

π≈4×(1-1/3+1/5-1/7……)

后面多项式的值越多，最终的结果就越精确，于是，我写了3个程序：

  1. Python:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #!/usr/bin/env python3
                                                                           
    import sys
                                                                           
    n=int(sys.argv[1])
    n+=0 if n%2==1 else 1
    sign=1
    t=0
    for i in range(1,n+2,2):
        t+=(1/i)*sign
        sign=-sign
                                                                           
    s=4*t
    print ('\N{GREEK SMALL LETTER PI}={}'.format(s))

  2. C:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #include <stdio.h>
                                                                          
    int n,i;
    int sign=1;
    double t,s;
                                                                          
    int main(int argc,char ** argv)
    {
            n=atoi(argv[1]);
            n+=(n%2==1?0:1);
            for(i=1;i<n+2;i+=2)
            {
                    t+=(1.0f/(double)i)*sign;
                    sign=-sign;
            }
            s=4*t;
            printf("pi=%f\n",s);
    }

  3. Go:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    package main
                                                                        
    import "fmt"
    import "os"
    import "strconv"
                                                                        
    var(
            n int
            i int
            sign int =1
            t float64
            s float64
    )
                                                                        
    func main(){
            args:=os.Args
            n,_=strconv.Atoi(args[1])
            if n%2==0 {
                    n+=1
            }
            for i=1;i<n+2;i+=2 {
                    t+=(1.0/float64(i))*float64(sign)
                    sign=-sign
            }
            s=4*t
            fmt.Printf("pi=%f\n",s)
    }

    吐槽一下为什么我在Go语言中没有发现过选择运算符(?:)？？

另外，为便于测试，我同时还写了一个shell脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/bin/bash
#test.sh
                                                            
NUM=$1
                                                            
if [ ! $NUM ]; then
        echo -e '! $NUM defaults 1000000 !\n'
        NUM=1000000
fi
                                                            
echo -e '\n==Python pi.py==\n'
python3 --version
time ./pi.py $NUM
                                                            
echo -e '\n==C Lang pi_c==\n'
gcc --version|grep gcc
time ./pi_c $NUM
                                                            
echo -e '\n==Go Lang pi_go==\n'
go version
time ./pi_go $NUM

那么，接下来，就应该进行测试了，我想看看这三种语言执行效率怎样：

在终端输入命令：

1
./test.sh 100000000 2>&1|cat >report

最后，打开生成的report文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
==Python pi.py==
                                                 
Python 3.2.3
π=3.1415926735902504
                                                 
real    0m23.592s
user    0m23.381s
sys     0m0.188s
                                                 
==C Lang pi_c==
                                                 
gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3
pi=3.141593
                                                 
real    0m1.096s
user    0m1.084s
sys     0m0.008s
                                                 
==Go Lang pi_go==
                                                 
go version go1
pi=3.141593
                                                 
real    0m1.254s
user    0m1.248s
sys     0m0.004s

图表的形式会直观一些：

从图中能看到：

  • Python在C面前就已经慢的可以了，毕竟Python是一种解释型语言。

  • 而C也好，Go也好，作为编译型语言，效率上的确很高。

  • Go其实比C慢一点，而之前做的一个测试，有时候这玩意居然会比Python还慢（http://weibo.com/1323904711/yzyHZkWj4）？不知道是哪出问题了

最后再吐槽一下，Go语言为什么没有问号运算符啊？难道是因为追求可读性给去掉了？？！！

=================================== 

http://blog.jobbole.com/14386/

最近在忙一个Server+Client的项目，Client是Android手机，大概也就是几十的规模。Server是纯Go语言实现，没有apache或者ngix这种web server，也没有数据库，自己写了个文件管理module，处理这种小规模的服务没问题。算下来接触Go语言也有四个多月了，断断续续写了一些东西，这里记录一下心得吧。

先大概说下为什么用Go语言。我是一个对语言有洁癖的人，曾经是一个c+Python的坚定呐喊者，最常说的一句话就是，只要熟练这两种，什么情况都能应付，根本不用Java和C++(纯指我所在的领域）。核心代码用c，速度快，需要记的语言细节少；外围用Python glue，灵活，简洁，任何模块都容易上手，绝配。Java的繁琐，C++的无数无用的特性，都让我只在不得不用的时候才去用。Objective-C是另一个我欣赏的语言，问题是不跨平台，过于封闭。

可惜的是，在这个节奏极快的时代，不是所有情况下都适合上c。之前有一个项目也是类似的架构和规模，为了节省时间，当初几乎没有服务器平台编程经验的我，在服务器端选择用Django、Apache、MySQL做，成熟，社区活跃，又是python作为主要开发语言，这些都是这个选择的原因。说实话，几个月过去后，回首看，这不是一个愉快的经历。Django是一个好架构，大而全，而大而全有时也就意味着臃肿，五花八门的配置，过紧的模块耦合对引入第三方工具限制颇多，自带的ORM又不好用。之前从来没有搞过服务器配置的我，对Apache的配置和效率所带来的琐碎的东西也头疼。总的来说这个部分花了我很多时间，有新手学习服务器编程的必经过程，也有折腾Django和Apache没必要的时间浪费，很大部分上抵消了Python带来的快速开发的灵活性。而一旦服务器上线，动态语言带来的一些bug又会让人头疼。对于普通高校实验室这种没有完善的服务器调试的条件，基本就是改了就上线用，有些隐蔽bug到某些条件分支才会触发，一旦在运行中途出问题，改起来也麻烦。

从那时起，我就特别想，要是有一种语言能把c和Python的优点结合起来，也就是说

▲速度快，高性能

▲简洁明了，需要记的语言细节少，开发迅速(c)

▲灵活，开发快速，类Python的list，map等常用数据结构支持(Python)

▲完善的模块支持，模块也容易上手(Python)

▲对程序员友好的并行架构(Erlang)

▲安全，绝大部分问题能消灭在compile time中(C minus pointer)

那基本就是系统级和网络级编程最对我胃口的语言了。然后我就找到了Go。

Go语言是一个新语言，截至目前为止，第一版正式版还没有发布。Go语言的设计者是Robert Griesemer, Rob Pike和Ken Thompson，当年设计C和Unix，后来的Plan9团队中的人 。Go语言的设计理念很明确，就是将动态类型语言的编程容易度和静态类型语言的安全效率结合起来。如果你想更深入了解Go语言的发展历史以及完整的目标，请参考Go语言 FAQ。

当然，Go语言吸引我的地方，不是因为其是Google出品，也不是因为其设计者皆为大牛，而是因为，Go语言真的做到了它所宣称的目标。Go语言就如同C和Python中间的完美结合，如果你是Python爱好者，又追求代码的速度和并行化，那么简单说，Go语言就是为你设计的。Go语言有很浓厚的C的遗风，尽量屏蔽C++和Java的影响，比如没有独立的OO体系（并不是说不能OO），一切以struct为中心，没有exceptions(Oh yes!)，仍然有指针，等等。但是，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语言的优缺点，可以参考以下yufeng写的这篇文章，系统编程语言明日之星—Go（http://blog.yufeng.info/Go.pdf。

还有朋友要说，Go语言这么好，为什么没人用？我想说，眼界放开点，这个世界精彩的东西比你想象的多。Go语言被Google用于Youtube的数据库，被越来越多的国外公司(大部分创业公司)用于后端开发，甚至在天朝，也有完全用Go语言做服务开发的云应用公司了。可以说，随着Go 1即将到来的正式推出，Go语言的使用范围，应该会越来越广。

总结

如果你是Python和动态语言狂热爱好者，Go不一定能给你带来很大的惊喜，这纯粹取决于你得项目性质，考虑到Python目前在很多地方都用C做核心运算，速度在大部分情况下都不是大问题。scalability是一个问题，但并不是人人都会遇到的。

如果你是C爱好者，强烈建议你学习和使用Go。Go可以调用C/C++程序，又提供了太多的便利，速度上稍有牺牲，但并不大。在绝大部分场景下Go能给你带来媲美C的性能，而对于某些确实性能过于关键的场合，也可以通过cgo让Go和C搭配。

如果你是Java爱好者，除非你是做Android这种不得不用Java的平台，否则也建议你尝试学习Go，这个开发上感觉的差异如同比较开载着1吨石头的拖拉机和开保时捷911那么明显，而Java能给你的，Go能给得更好。

如果你是C++爱好者，!@#$%^&*，恭喜你，至少你的智商应该是没问题的。人生苦短，赶紧脱离C++这个苦海吧。你用来学89个C++高级特性的时间，估计已经用Go写了64个开源项目了。

如果你是像我一样的C和Python的爱好者，对动态语言又没有特殊的热爱……我还需要说什么呢？

让我们荡起双桨，去遨游Go语言的海洋吧。

 ###############################################

http://book.douban.com/review/5928325/

　过年在老家的时候不能上网，通过文档抽空学了下go语言。后来又买了这本书。总体上这本书是当前的 go语言书中比较不错的一本。但缺点在于对go的并行机制以及内存回收机制这两个非常重要的话题介绍的不够深入。go的并行机制是其最大的亮点go的存在基础,而内存回收机制更是是否能革c和java命的根基。 既然说到了这个书，当然也需要说说对go语言的看法。 
　　 
　　go语言除了go这个并行计算的亮点不说，其他的优点有： 
　　 
　　1. 非侵入式接口 习惯了java的侵入式接口，开始的时候这个我还不太接受。感觉这样设计，类的开发者不知道自己实现了那些接口，修改的时候如何确保不会影响使用方？没有了侵入接口的静态检查，会不会导致代码变更失控？但后来一想，java中流行的许多非侵入性框架不也通过代理模式实现了非侵入式接口。这个类似于流行的约定大于配置的概念。一些基本的，通用的接口比如Collection等，工具包中会前置约定或者由社区形成约定，大家遵循约定即可。 
　　 
　　2. go的面向工程的设计 由语言的进化可以看出，早期的语言一般只提供了语法规则以及编译器，甚至没有标准库。后来的语言都会提供一个内置的标准库。再后来的语言会提供包管理以及依赖管理机制。而go提供的不仅如此，提供包括工程管理，文档管理，内置的单元测试机制，源码格式化等一整套工具。 
　　 
　　http://jolestar.com/recently-reading-notes/

 

=================================================

http://www.cnblogs.com/AllenDang/archive/2012/03/03/2378534.html

从2000年至今，也写了11年代码了，期间用过VB、Delphi、C#、C++、Ruby、Python，一直在寻找一门符合自己心意和理念的语言。我很在意写代码时的手感和执行的效率，所以在Go出现之前一直没有找到。在熟悉Go之后，我虽没有停下脚步，也去体验了D语言，但几乎立即就放弃了，它的设计还是太复杂。

就说说Go吧。它的好其实也就两个字——简洁！

 

看很多朋友的留言都觉得这些“少个括号、少个分号”之类的东西没什么意义，真的吗？问题是，既然可以没有，为什么非得有？既然能够少打一个字符，为什么多打了还挺开心？还觉得天经地义？这里简单一点，那里简单一点，总的来说是不是就简单了很多？这里的设计简洁一点，那里简洁一点，是否整体就是紧凑高效？

很多东西，要整体去体会，才能感觉到真正的强大。没有前面这些语法上的各种“看起来没什么用”的支持，怎么能做到后面提到的那些设计上的简洁？

 

我坚信，少就是多，简单就是强大，不能减一分的设计才是真正的好设计！

 

简洁的变量声明和赋值

拿最简单的声明变量和赋值来看，下面这一句完成了声明类型到赋值，最后还有那个常见的分号作为语句的结束。

var i int = 10;

这个一点都不简洁对吧？为什么非要有“var”？为什么不能自己推导变量类型？为什么结尾非要加上分号？这三个问题，我相信Go语言的设计者也问过，并且都针对性的给了改进。重新来过。

i := 10

怎么样？“:=”是声明并推导类型的语法糖，结尾的分号也省了，因为这里我换行了，编译器明白的。

还可以一次性声明并赋值多个变量。

i, j, k := 1, 2, 3

不同的类型也可以。

i, j, k := 1, 1.0, “hello”

如果要声明一堆变量，但暂时不赋值呢？可以这样。

var (

    i, j int
    s string
    u, v, s = 2.0, 3.0, "bar"

)

Go的设计者甚至觉得多打几个“var”都不应该！

 

简洁的if

有点意思了对吧？我学习一门新语言的时候，第一眼看变量类型和声明，第二眼就会去看逻辑控制的语法。现在来看看都有些什么？

if i > 10 {

    println(“Greater then 10”)

}

稀松平常啊，难道一个简单的if还能更简单？恩，的确是的。首先if后面的条件判断没有人逼你再加上括号了，仅仅是少了两次按键嘛，还有呢？还有！下面这个应该是很常见的if使用场景。

result := SomeMethod()

if result > 0 {

}

很多时候result这个变量其实仅仅用于条件判断，完全可以在if之后就扔掉，所以Go有了这么个写法。

if result := SomeMethod(); result > 0 {

}

这个表达式太常用了，真是谁写谁知道，每次我写着一行都会心里一爽。来看看纠结一点的if段。

if a {

} else if b {

} else if c {

} else {

}

这种写法是可以的，但不是Go推荐的，理由是可以更简洁。比如强悍的switch。

 

强悍的switch

这是很大家熟知的switch用法，注意，没有break哦！Go里面case之间不会“下穿”。

switch tag {
    default: 
        s3()
    case 0, 1, 2, 3:
        s1()
    case 4, 5, 6, 7: 
        s2()
}
神奇一点的switch，嘿嘿，与if异曲同工之妙。
switch x := f(); {  // missing switch expression means "true"
    case x < 0: return -x
    default: return x
}

还有这个，有了这个更加明确的写法，你真的还会if…else if…else if…else…吗？

switch {
    case x < y: f1()
    case x < z: f2()
    case x == 4: f3()
}

条件判断舒服了，循环呢？

 

孤单的f


鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
Go变量与基础数据类型发布时间：2022-07-10
下一篇：
Go Gin Example发布时间：2022-07-10
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap