go语言技术博客 go语言开发博客

go语言web框架beego安装(go mod方式)

go语言web框架beego安装(go mod方式)_不忘初心，方得始终-CSDN博客

重要:将bee命令放到GOROOT/bin目录下，这步很关键

cp bee /usr/local/go/bin/

注：或者可以将GOPATH/bin设置为环境变量

echo ’export PATH=" PATH"' ~/.bashrc

source ~/.bashrc

router路由下方法名要大写,访问权限

wq保存

生效环境变量: source /etc/profile

go build -o abc.exe可指定编译后的文件名

Golang常用环境变量说明与设置详解

环境变量GOBIN表示我们开发程序编译后二进制命令的安装目录。

当我们使用go install命令编译和打包应用程序时，该命令会将编译后二进制程序打包GOBIN目录，一般我们将GOBIN设置为GOPATH/bin目录。

export GOBIN=$GOPATH/bin

Go get包管理mod

windows下默认项目路径在go安装目录的src下(beego)

相关问答

Q1: go语言实现一个简单的简单网关

网关=反向代理+负载均衡+各种策略，技术实现也有多种多样，有基于 nginx 使用 lua 的实现，比如 openresty、kong；也有基于 zuul 的通用网关；还有就是 golang 的网关，比如 tyk。

这篇文章主要是讲如何基于 golang 实现一个简单的网关。

转自： troy.wang/docs/golang/posts/golang-gateway/

整理：go语言钟文文档:

启动两个后端 web 服务（代码）

这里使用命令行工具进行测试

具体代码

直接使用基础库 httputil 提供的NewSingleHostReverseProxy即可，返回的reverseProxy对象实现了serveHttp方法，因此可以直接作为 handler。

具体代码

director中定义回调函数，入参为*http.Request，决定如何构造向后端的请求，比如 host 是否向后传递，是否进行 url 重写，对于 header 的处理，后端 target 的选择等，都可以在这里完成。

director在这里具体做了：

modifyResponse中定义回调函数，入参为*http.Response，用于修改响应的信息，比如响应的 Body，响应的 Header 等信息。

最终依旧是返回一个ReverseProxy，然后将这个对象作为 handler 传入即可。

参考 2.2 中的NewSingleHostReverseProxy，只需要实现一个类似的、支持多 targets 的方法即可，具体实现见后面。

作为一个网关服务，在上面 2.3 的基础上，需要支持必要的负载均衡策略，比如：

随便 random 一个整数作为索引，然后取对应的地址即可，实现比较简单。

具体代码

使用curIndex进行累加计数，一旦超过 rss 数组的长度，则重置。

具体代码

轮询带权重，如果使用计数递减的方式，如果权重是5,1,1那么后端 rs 依次为a,a,a,a,a,b,c,a,a,a,a…，其中 a 后端会瞬间压力过大；参考 nginx 内部的加权轮询，或者应该称之为平滑加权轮询，思路是：

后端真实节点包含三个权重：

操作步骤：

具体代码

一致性 hash 算法，主要是用于分布式 cache 热点/命中问题；这里用于基于某 key 的 hash 值，路由到固定后端，但是只能是基本满足流量绑定，一旦后端目标节点故障，会自动平移到环上最近的那么个节点。

实现：

具体代码

每一种不同的负载均衡算法，只需要实现添加以及获取的接口即可。

然后使用工厂方法，根据传入的参数，决定使用哪种负载均衡策略。

具体代码

作为网关，中间件必不可少，这类包括请求响应的模式，一般称作洋葱模式，每一层都是中间件，一层层进去，然后一层层出来。

中间件的实现一般有两种，一种是使用数组，然后配合 index 计数；一种是链式调用。

具体代码

Q2: 【golang】海量数据去重-布隆过滤器

在做域名爆破中，遇到了把一个300G的子域名json文件进行去重，一开始是考虑使用字典进行去重，但是数据量大了，会造成内存泄露。看网上资料介绍了一种方案，就是使用布隆过滤器。

布隆过滤器是一种数据结构，概率型数据结构，特定是高效插入和查询，可以用来告诉你“某一值一定不存在或者kennel存在”。

相比于传统的map、set等数据结构，占用空间更少，但其返回结果是概率型的，不确定。

布隆过滤器内部维护一个bitArray(位数组)，开始所有数据为0，当一个元素过来时，能过多个哈希函数（hash1、hash2、hash3）计算不同的hash值，并通过hash值找到bitArray的下标，将里面的值改为由0变为1。布隆过滤器有一个误判率，误判率越低，数组越长，所在空间越大，误判率越高，数组越小，所占空间越小。

这里贴上一个技术大牛的博客地址，里面对布隆过滤器用法以及在redis里面处理缓存穿透问题的详细介绍。

Q3: golang获取到string和直接赋值strimg不一样

1、 string的定义

Golang中的string的定义在reflect包下的value.go中，定义如下：

StringHeader 是字符串的运行时表示，其中包含了两个字段，分别是指向数据数组的指针和数组的长度。

// StringHeader is the runtime representation of a string.

// It cannot be used safely or portably and its representation may

// change in a later release.

// Moreover, the Data field is not sufficient to guarantee the data

// it references will not be garbage collected, so programs must keep

// a separate, correctly typed pointer to the underlying data.

type StringHeader struct {

Data uintptr

Len int

}

1

2

3

4

5

6

7

8

9

10

1

2

3

4

5

6

7

8

9

10

2、string不可变

Golang中的字符串是不可变的，不能通过索引下标的方式修改字符串中的数据：

在这里插入图片描述

运行代码，可以看到编译器报错，string是不可变的

在这里插入图片描述

但是能不能进行一些骚操作来改变元素的值呢？

package main

import (

"fmt"

"reflect"

"unsafe"

)

func main() {

a := "hello,world"

b := a[6:]

bptr := (*reflect.StringHeader) (unsafe.Pointer(b))

fmt.Println(a)

fmt.Println(b)

*(*byte)(unsafe.Pointer(bptr.Data)) = '.'

fmt.Println(a)

fmt.Println(b)

}

// 运行结果

hello,world

world

unexpected fault address 0x49d7e3

fatal error: fault

[signal 0xc0000005 code=0x1 addr=0x49d7e3 pc=0x4779fa]

goroutine 1 [running]:

runtime.throw(0x49c948, 0x5)

C:/Program Files/Go/src/runtime/panic.go:1117 +0x79 fp=0xc0000dbe90 sp=0xc0000dbe60 pc=0x405fd9

runtime.sigpanic()

C:/Program Files/Go/src/runtime/signal_windows.go:245 +0x2d6 fp=0xc0000dbee8 sp=0xc0000dbe90 pc=0x4189f6

main.main()

F:/go_workspace/src/code/string_test/main.go:20 +0x13a fp=0xc0000dbf88 sp=0xc0000dbee8 pc=0x4779fa

runtime.main()

C:/Program Files/Go/src/runtime/proc.go:225 +0x256 fp=0xc0000dbfe0 sp=0xc0000dbf88 pc=0x4087f6

runtime.goexit()

C:/Program Files/Go/src/runtime/asm_amd64.s:1371 +0x1 fp=0xc0000dbfe8 sp=0xc0000dbfe0 pc=0x435da1

Process finished with the exit code 2

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

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

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

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

在上面的代码中，因为在go语言中不能进行指针的加减运算，因此取切片，让b的Data指针指向’,'所在的位置。然后把"hello,world"中的逗号改为点，但是发现还是不行，程序直接崩溃了。看来go语言中的指针得到了大大的限制，设计者并不想让程序员过度使用指针来写出一些不安全的代码。

3、使用string给另一个string赋值

Golang中的字符串的赋值并不是拷贝底层的字符串数组，而是数组指针和长度字段的拷贝。例如：当我们定义了一个字符串 a := “hello,world” 然后定义了 b := a 底层所做的操作只是创建了两个StringHeader的结构体，它们的Data字段都指向同一段数据，如下图：

在这里插入图片描述

我们可以利用代码来证实这一点：

package main

import (

"fmt"

"reflect"

"unsafe"

)

func main() {

a := "hello,world"

b := a

fmt.Println(a)

fmt.Println(b)

aptr := (*reflect.StringHeader) (unsafe.Pointer(a))

bptr := (*reflect.StringHeader) (unsafe.Pointer(b))

fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))

fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))

}

// 运行结果

hello, world

hello, world

a ptr: 0x6bdb76

b ptr: 0x6bdb76

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

28

29

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

28

29

在上面的代码中，将a和b转换为StringHeader类型的指针，然后分别打印出，a和b的Data指针的值，发现是相同的

那么如果对a做切片赋值给b呢？

func main() {

a := "hello,world"

b := a[6:]

fmt.Println(a)

fmt.Println(b)

aptr := (*reflect.StringHeader) (unsafe.Pointer(a))

bptr := (*reflect.StringHeader) (unsafe.Pointer(b))

fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))

fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))

}

// 运行结果

hello,world

world

a ptr: 0xd4d849

b ptr: 0xd4d84f

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

0xd4d849 - 0xd4d84f = 0x000006

显然，也没有分配新的数组并拷贝数据，而是将原字符数组的指针的偏移赋给了b的StringHeader的Data

4、string重新赋值

如果对一个已经赋值的字符串重新赋值，也不会修改原内存空间，而是申请了新的内存空间，对其赋值，并指向新的内存空间。如下图：

在这里插入图片描述

也可以使用代码来证实一下：

package main

import (

"fmt"

"reflect"

"unsafe"

)

func main() {

a := "hello,world"

aptr := (*reflect.StringHeader) (unsafe.Pointer(a))

fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))

fmt.Println("a len", aptr.Len)

a = "hello,golang"

newAPtr := (*reflect.StringHeader) (unsafe.Pointer(a))

fmt.Println("b ptr:", unsafe.Pointer(newAPtr.Data))

fmt.Println("b len:", newAPtr.Len)

}

// 运行结果

a ptr: 0x3ed7f4

a len 11

b ptr: 0x3edb2c

b len: 12

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

28

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

28

文章知识点与官方知识档案匹配

Go技能树九阴真经字符串

2043 人正在系统学习中

点击阅读全文

打开CSDN APP，看更多技术内容

Golang底层原理剖析之string类型与字符编码_cheems~的博客_g...

string类型 string结构 go语言中默认使用的是UTF-8编码 string由两部分组成,一部分是指向字符串起始地址的指针,另一部分是字节个数len注意不是字符个数,是字节个数!这个数据类型占用16B空间,指向字符串起始地址的指针和存在字节个数的整...

继续访问

...底层系列二(基础)_GoGo在努力的博客_golang string底层

1、 string的定义 Golang中的string的定义在reflect包下的value.go中,定义如下: StringHeader 是字符串的运行时表示,其中包含了两个字段,分别是指向数据数组的指针和数组的长度。 // StringHeader is the runtime representation of a...

继续访问

最新发布 Golang: []string 和 ...string

… 参数语法形成了可变参数的参数。它将接受零个或多个string参数，并将它们作为切片引用

继续访问

常用的Golang字符串（string）操作

文章目录Golang中常用的字符串操作一、标准库相关的Package二、常用字符串操作判断是否为空字符串 正文 Golang中常用的字符串操作 一、标准库相关的Package 二、常用字符串操作 判断是否为空字符串 思路：直接判断是否等于""空字符串，由于golang中字符串不能为nil，且为值类型，所以直接与空字符串比较即可 举例： str := "" if str == ""{...

继续访问

golang中的string_xiaodongdonga的博客_golang ...string

golang中的string 在golang中,string其实是个结构体,如图 ,在这个结构体中有两个值,一个是指向字符数组的指针str,另一个是这个字符串的长度len。 另外在golang中用的是UFT8边长编码,里面字母是用一个字节,西方的文字使用两个字节,...

继续访问

Golang中对字符串string的相关操作_Codex_97的博客_go 字符...

golang中拥有string的内置类型,可以使用与普通slice类型相似的性质。 1.简介 strings包提供了很多操作字符串的简单函数,通常一般的字符串操作都可以在这个包中找到。 strconv 包提供了基本数据类型和字符串之间的转换。在Go 中,没有隐式...

继续访问

go-string-set:一种在GoLang中创建字符串集的方法

概述 通过字符串设置方法。 用法 go get github.com/wojnosystems/go-string-set package main import ( "github.com/wojnosystems/go-string-set/string_set" "strings" ) func main () { myPeople := string_set . New () myPeople . Add ( "Bob" ) myPeople . Add ( "Jane" ) myPeople . Add ( "Gary" ) myPeople . Add ( "Bob" ) if myPeople . Exists ( "Bob" ) { // Bob exists in myPeople, so this code block execute

Golang：strings包和字符串操作

strings包 string类型值是不可变的，如果想要获得一个不一样的字符串，就只能基于原字符串进行剪裁，拼接等操作，然后将得到的新字符串存放到一块联系内存中。 string值包含了指向底层字节数组头部的指针值，以及该字节数组的长度。在string值上做切片，就相当于在其底层字节数组做切片。 而字符串拼接时（使用+），会把所有被拼接的字符串依次拷贝到一个崭新且足够大的连续内存空间中，并把持有新...

继续访问

golang中的strings.SplitN_盼盼编程的博客_strings.splitn

golang中的字符串操作strings.SplitN package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "hello world hello world" //str := "wo" //以str为分隔符,将s切分成多个子串,结果中**不包含*...

继续访问

Golang_String常用操作_itzhuzhu.的博客_golang strings

func main() { var x string = "ITzhuzhu" var y string = "itzhuzhu" fmt.Println(strings.EqualFold(x, y)) //true fmt.Println(x == y) //false } 1 2 3 4 5 6 返回子串在字符串第一次出现的索引,如果没有则...

继续访问

Golang类型的String()方法

作用 用于定制fmt.Println(x)、fmt.Printf("%v", x)、fmt.Print(x)时输出的内容。 示例 package main import "fmt" type Couple struct { Husband string Wife string } func (self Couple) String() string { return "(husband:" + self.Husband + ", wife:" + self.Wife +

继续访问

golang的string

golang中的string是不可变的字节序列，零值是空字符串，默认是UTF-8编码。 golang中使用字符串最需要注意的是，golang中的字符串是字节序列，string == []byte，由于一个字符占用的字节数不确定，所以无法通过下标[i]的方式稳定地获取对应位置的字符。 也就意味着字符串的第i个字节，不一定就是第i个字符，原因请参考 unicode与UTF-8 文字符号在golang中被称为rune，发音为/ru:n/，意思是符号。由于utf-8最多使用4个字节来编码，所以rune类型是int3

继续访问

golang中的strings.Trim_盼盼编程的博客_strings.trim

golang中的字符串操作strings.Trim package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "Hello world hello world" str := "world" //var s = []string{"11","22","33"} //删除s首尾...

继续访问

Golang 字符串

Go语言的代码是由Unicode字符组成的，它们都必须由Unicode编码规范中的UTF-8编码格式进行编码并存储，Unicode编码规范中的编码格式定义的是字符与字节序列之间的转换方式。其中的UTF-8是一种可变宽的编码方案，它会用一个或多个字节的二进制数来表示某个字符，最多使用四个字节。Go语言中的一个string类型值会由若干个Unicode字符组成，每个Unicode字符都可以由一个rune类型的值来承载。stringforrange。...

继续访问

golang字符串[]string(slice)去重

1、现实代码 // []string 去重 func RemoveDuplicate(list []string) []string { // 这个排序很关键 sort.Strings(list) i := 0 var newlist = []string{""} for j := 0; j len(list); j++ { if strings.Compare(newlist[i], list[j]) == -1 { newlist = append(newlist, lis

继续访问

深入理解golang string

golang string string的定义 // string is the set of all strings of 8-bit bytes, conventionally but not // necessarily representing UTF-8-encoded text. A string may be empty, but // not nil. Values of string type are immutable. type string string string里存储的是字符

继续访问

golang中string包

对于基本类型来说，字符串所需要执行的操作会比较复杂，所以一般语言都会额外封装一些方法用于处理字符串，go语言标准库中也存在这样一个名为strings的库 包含判断，判断一个字符中是否有相应的某个子字符串是经常遇到的一种字符串操作，再go语言中可以使用strings包中的两个方法判断 ...

继续访问

golang中的strings.TrimLeft

golang中的字符串操作strings.TrimLeft package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "Hello world hello world" str := "Hello" //var s = []string{"11","22","33"} //删除s头部连续的包含在str中的字符串 .

继续访问

golang入门time与string转换, time加减时间, 两个时间差

package mainimport ( "fmt" "time")var timeLayoutStr = "2006-01-02 15:04:05" //go中的时间格式化必须是这个时间//var timeLayoutStr = 2006/01/02 03:04:05 //合法, 格式可以改变//var timeLayoutStr = 2019/01/02 15:04:05 /...

继续访问

Golang——string

1.string结构体底层 由两部分组成：指向底层[ ]byte数组的指针；长度（类似切片结构体） 2.相同的string常量不会重复存储 //由s1、s2的指针指向一块相同的只读内存，这段内存以utf-8编码存放hello数组 s1 := "hello" s2 := "hello" 3.string常量会在编译期分配到只读段，对应数据地址不可写入，故string不支持修改。 要修改必须转[]byte，string和[]byte转换，会将这段只读内存的数据复制到堆/栈上。 //wrong s := "he

继续访问

热门推荐 golang -----------字符串（rune,string,type）

一、内存布局 字符串在Go语言内存模型中用一个2字长的数据结构表示。它包含一个指向字符串存储数据的指针和一个长度数据。因为string类型是不可变的，对于多字符串共享同一个存储数据是安全的。切分操作str[i:j]会得到一个新的2字长结构，一个可能不同的但仍指向同一个字节序列(即上文说的存储数据)的指针和长度数据。这意味着字符串切分可以在不涉及内存分配或复制操作。这使得字符串切分的效率等同于...

继续访问

Golang string 常用方法

strings.Compare(p1, p2) 判断p1是否大于p2，大于:1,小于:-1,等于:0。2.strings.LastIndex(p1,p2) p2在p1中最后一次出现的位置,未出现返回-1。1.strings.Replace(p1,p2,p3,n) 将p1中的p2替换成p3，最多替换n个。1.strings.Index(p1,p2) p2在p1中第一次出现的位置,未出现返回-1。2.strings.ReplaceAll(p1,p2,p3) 将p1中的所有p2替换成p3。

继续访问

golang中的字符串

在go中rune是一个unicode编码点。 我们都知道UTF-8将字符编码为1-4个字节，比如我们常用的汉字，UTF-8编码为3个字节。所以rune也是int32的别名。

继续访问

golang之字符串

Go语言的字符有两种类型： 一种是byte型，或者叫uint8类型，代表了ASCII码的一个字符。 一种是rune类型，或者叫int32类型，代表一个UTF-8字符，当需要处理中文、日文等unicode字符时，则需要用到rune类型。 ...

继续访问

Golang的 string 类型

一点睛 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 二 string 使用注意事项和细节 1 Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文乱码问题不会再困扰程序员。 2 字符串一旦赋值了，字符串就不能修改了，在 Go 中字符串是不可变的。 3 字符串的两种表示形式。 a 双引号——会识别转义字符 .

继续访问

Golang Strings 官方包常用方法，学会这些够用了

1.判断是否以某字符串打头/结尾 2.字符串分割 3.返回子串索引 4.字符串连接 5.字符串转化为大小写 6.统计某个字符在字符串出现的次数 7.判断字符串的包含关系 8.字符串替换

Q4: 如何看待go语言泛型的最新设计？

Go 由于不支持泛型而臭名昭著，但最近，泛型已接近成为现实。Go 团队实施了一个看起来比较稳定的设计草案，并且正以源到源翻译器原型的形式获得关注。本文讲述的是泛型的最新设计，以及如何自己尝试泛型。

例子

FIFO Stack

假设你要创建一个先进先出堆栈。没有泛型，你可能会这样实现：

type Stack []interface{}func (s Stack) Peek() interface{} {

 

return s[len(s)-1]

}

func (s *Stack) Pop() {

 *s = (*s)[:

len(*s)-1]

}

func (s *Stack) Push(value interface{}) {

 *s = 

append(*s, value)

}

但是，这里存在一个问题：每当你 Peek 项时，都必须使用类型断言将其从 interface{} 转换为你需要的类型。如果你的堆栈是 *MyObject 的堆栈，则意味着很多 s.Peek().(*MyObject)这样的代码。这不仅让人眼花缭乱，而且还可能引发错误。比如忘记 * 怎么办？或者如果您输入错误的类型怎么办？s.Push(MyObject{})` 可以顺利编译，而且你可能不会发现到自己的错误，直到它影响到你的整个服务为止。

通常，使用 interface{} 是相对危险的。使用更多受限制的类型总是更安全，因为可以在编译时而不是运行时发现问题。

泛型通过允许类型具有类型参数来解决此问题：

type Stack(type T) []Tfunc (s Stack(T)) Peek() T {

 

return s[len(s)-1]

}

func (s *Stack(T)) Pop() {

 *s = (*s)[:

len(*s)-1]

}

func (s *Stack(T)) Push(value T) {

 *s = 

append(*s, value)

}

这会向 Stack 添加一个类型参数，从而完全不需要 interface{}。现在，当你使用 Peek() 时，返回的值已经是原始类型，并且没有机会返回错误的值类型。这种方式更安全，更容易使用。（译注：就是看起来更丑陋，^-^）

此外，泛型代码通常更易于编译器优化，从而获得更好的性能（以二进制大小为代价）。如果我们对上面的非泛型代码和泛型代码进行基准测试，我们可以看到区别：

type MyObject struct {

    X 

int

}

var sink MyObjectfunc BenchmarkGo1(b *testing.B) {

 

for i := 0; i  b.N; i++ {

  

var s Stack

  s.Push(MyObject{})

  s.Push(MyObject{})

  s.Pop()

  sink = s.Peek().(MyObject)

 }

}

func BenchmarkGo2(b *testing.B) {

 

for i := 0; i  b.N; i++ {

  

var s Stack(MyObject)

  s.Push(MyObject{})

  s.Push(MyObject{})

  s.Pop()

  sink = s.Peek()

 }

}

结果：

BenchmarkGo1BenchmarkGo1-16     12837528         87.0 ns/op       48 B/op        2 allocs/opBenchmarkGo2BenchmarkGo2-16     28406479         41.9 ns/op       24 B/op        2 allocs/op

在这种情况下，我们分配更少的内存，同时泛型的速度是非泛型的两倍。

合约（Contracts）

上面的堆栈示例适用于任何类型。但是，在许多情况下，你需要编写仅适用于具有某些特征的类型的代码。例如，你可能希望堆栈要求类型实现 String() 函数

Q5: erlang golang学习哪个

我最早使用的语言是Java和Python， 并且一直都对Python充满好感， 我喜欢这种很朴实和高效率的感觉， 但我却最后没有采用Python，原因其实也很简单， 我就是不喜欢缩进语法， 就跟很多人换工作仅仅是为了屏幕更大一点一样， 另外就是有了同样很棒的可选方案， 这就是Ruby， 所以我最终采用了Ruby作为主力编程语言， 同样也为不能使用Python而有一点小遗憾，毕竟Python的健壮性比Ruby好很多，只不过Ruby也一直在进步， 所以这一点无伤大雅

我们都知道，无论是Python还是Ruby，甚至Java， 都是在解决业务层的问题， 属于应用型语言， 以解决业务逻辑为主， 但还有一个领域是系统领域，偏网络层和底层操作，在这一块我一直在寻找一种优雅的方案， C++被我首先给淘汰掉了， C的开发效率太低， Java倒是比较合适， 就是太臃肿，而且缺少系统编程的基因，毕竟它是企业级开发出身的

最后我选择了Erlang， 因为它在网络层方面表现优秀， 同时容错性和健壮性都很不错， 它的虚拟机是唯一可以跟JVM媲美的， 而且还有OTP的超重量级武器， 几乎可以是通杀网络层应用， 但根据我的总结它有一个硬伤和一个软肋，这一点后面展开，可以说选择Erlang是我目前所知道的方案里面是最优的

直到有一天我了解了Golang， 我知道Golang其实也蛮早的， 大概08年的时候就知道Google在搞一门奇怪的语言， 之后的几年，一直有不少以老莫为代表的人在嘀咕Golang， 其实我一直没太关注，我从ROR中吸取的经验是，成熟度对于商用很重要， 后来基于Golang开发的产品越来越多，让我不得不去研究一下， 这我才知道， 这就是我梦想中的Python， 效率和性能达到了最佳的平衡，对Go了解越多， 就越不愿意用Erlang写代码，主要原因：

1、Erlang的硬伤在于代码的可读性、表现力， 让我来举个小例子， 比如你为你的系统软件构建一个RESTFUL的接口，我们大致了解一下代码风格，先不说Erlang， 无论是你c/c++/python/ruby/java 出身， 对Go是不是有种很久违的感觉, 为什么说是硬伤？ 因为对一门语言来说，语法是不大可能会大幅度变更的， 而且不会出现大的变化， 我不知道有没有人读过《松本行弘的编程世界》，里面阐述的道理很明白， 真正好的编程方式是人去主宰计算机而不是计算机主宰人， 我感觉Erlang就有点主宰我的编程思维的感觉(我的视力本身就不好，它还在不断的扼杀我的眼睛！)， 编程首先是门逻辑学，其次是工程学，最后才是数学， 又让我想起吴军的《数学之美》所说的， 人工智能上个世纪一直在走弯路， 期望机器的高度图灵完备， 而忽视人类本身已有的文明，统计归纳的应用

2、Erlang的软肋在于高质量的库少，尽管有不少杀手级应用， 同样Go在这方面也是软肋， 这一点对于一个不到五年的语言有情可原， 但对于一个20多年的语言是不是有点说不过去， 比如你用json解析库，很多人都是从mochiweb这个基本不更新的库中去抽取， 而我认为对于类似json这种东西可以考虑融入到语言标准库中， 因为未来的商业软件的api化趋势越来越明显，说的难听点 ， 一个倚老卖老一个与时俱进，反正我对Golang的库一点也不担心， 目前的成绩易经非常棒了， 远远优于Ruby/Python的前五年， 可参见已有的高质量的库列表

3、Erlang不合群， 这主要体现在跟其他语言的交互性上， 当然这也有深层次的原因， Erlang本身有自己的哲学， 如出错恢复机制， 你融入一个其他语言的东西进去， 这帐就不好算，就好比你硬要让一个喝咖啡的跟一个吃大蒜的坐在一起， 总之你写一个Erlang的port远远比Go复杂， 甚至比Python/Java还要复杂， 这就造成了Erlang在底层编程上效果不是很好， 没法利用linux已有的很多优秀成果，我一直认为Erlang的什么的mysql/pg/oracle驱动都没有必要存在， Erlang一定是一个self-container应用， 你只要用到了其他东西， 根据木桶理论， 你就不敢号称9个9，以系统的眼光看问题， 我觉得一个系统的鲁棒性不能依赖于某一组件， 这也是为什么爱立信本身的Erlang应用并不广泛

4、说说数据类型吧， 我不止听到1个人说Erlang对字符串的处理不有好， 它把string当做list来处理，其实本质上是该这么，但，还是那句话， 违背了面向人的哲学， 应该做一些DSL， 比如Golang里面的 := 就是一个糖衣， 等价于 var xx yyy = zzzz， 大大方便的程序员少敲不少字符, Golang里面对字符转可以说基本和python差不多， slice map函数很强大， 支持lambda条件，虽然Erlang的基本类型很少， 但有很多构造， 所谓构造等价于Golang里面复杂的struct， 也奇怪了，我就是感觉Erlang构造伤眼睛好吗？可能是各种括号的比对的原因吧， 而且我认为这是不必要的， 显然Erlang缺少DSL的基因， 当然跟Erlang出身的年代有关， 我不夸张的说， 自打用Erlang以后我的视力又下降了100度左右， 我不是很喜欢lisp所说的符号也是一种语法， 可能这又跟函数式编程有关吧：形式推导远大于逻辑演绎

5、其实我最不关注的是性能问题， 因为随着摩尔定律， 单位计算单元的性价比会无限高，但Golang既然提出它的性能逼近C， 那我还是提一下吧， 当然， Erlang也还可以， 虽然比Java慢， 但跟Python一个档次吧

6、再谈谈报错机制， 因为Erlang的的报错信息太让人纠结了， 起初以为我不会看出错信息， 后来也使用了Sasl， 还是不够直观，甚至有时要用工具分析crash文件来定位问题，还是跟Erlang的哲学有关， 在Erlang中一切都是并行的， 所以它根本不care是物理哪一行出错， 只跟Actor绑定， 然后告诉你Actor的ID和出错代号， 你自己凭经验去分析吧，这样做的好处是可以很方便定位出并行中出现的问题，但凡事都是相对的， 在这一点上有点纠枉过正，根据我的经验， 绝大部分时候我只希望先给我明确的指出哪一行出错了好吗？ 甚至把顺序的backtrace用完整的英文句子打印出来好吗？至于并行中的错误及时在命令式多线程语言中是不常见的，虽然并不是没有， 但遇到错误我再费劲去调试好了， 但并不是所有的逻辑都用并行的思维去定位问题， 我甚至认为， 对于一个系统不完全是并行也不完全是串行，跟好比我们衡量世界不能单纯的唯物也不能完全的唯心一样， 这一点Golang就做了很好的折中， 不需要并行的时候你老老实实的写串行代码， 需要并行的时候也有较复杂的机制来应对， 合乎情理

7、再说说招人吧， 以前招过好几个C出来的人，说实话水平很好， 可以一周就完成一个小组件， libevent用的熟的很，后来我逼人家用Erlang，结果把人家逼走了，至今我还很后悔， 自己的一厢情愿强加在别人身上真是太不合适了，但我招纯Erlang出来的人，可以说比招objc的人还难， 没有人，空谈技术的优雅性首先就是不靠谱的，再看看邮件列表， Golang的活跃度明显比Erlang高很多， 基本逼近Ruby，更重要的是， 我根本不担心Golang的人才，因为只要熟悉Python/C/Ruby/或者C++， 基本可以实现半天入门， 之后就可以噼里啪啦边搜资料边干活了，虽然有足够的深度，但门槛极其平缓，工程人员也可以复用很多已有的知识。 Erlang在这一点其实跟第一点硬伤有关，大部分人学一周都摸不着头脑，不是每个人的抽象思维和世界观都是一样的好吗， 所以函数式编程尽管不比命令式语言起步晚，但始终学的人很少，这就是历史， 对于大部分人， 更希望解决问题，创造价值， 而不是数学来推导去

8、最后我建议， 如果你是玩c/c++的， 现在开始学Golang，是最好的时机， 跟一门靠谱的语言一起成长， 这种感觉非常棒， 你用Erlang折腾1个应用， 用Go恐怕都完成了10个开源项目， 当然，也要结合自己的口味， Golang就是Sublime Text， Erlang就是Emacs

相信自己的判断，相信自己的逻辑， 赢就是赢，输就是输

转载仅供参考，版权属于原作者。祝你愉快，满意请采纳哦

关于go语言技术博客和go语言开发博客的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。