为什么我不喜欢go语言式的接口

所谓Go语言式的接口，就是不用显示声明类型T实现了接口I，只要类型T的公开方法完全满足接口I的要求，就可以把类型T的对象用在需要接口I的地方。这种做法的学名叫做Structural Typing，有人也把它看作是一种静态的Duck Typing。除了Go的接口以外，类似的东西也有比如Scala里的Traits等等。有人觉得这个特性很好，但我个人并不喜欢这种做法，所以在这里谈谈它的缺点。当然这跟动态语言静态语言的讨论类似，不能简单粗暴的下一个“好”或“不好”的结论。

路南网站建设公司成都创新互联,路南网站设计制作，有大型网站制作公司丰富经验。已为路南上千多家提供企业网站建设服务。企业网站搭建\成都外贸网站建设公司要多少钱，请找那个售后服务好的路南做网站的公司定做！

我的观点:

Go的隐式接口Duck Typing确实不是新技术, 但是在主流静态编程语言中支持Duck Typing应该是很少的(不清楚目前是否只有Go语言支持).

静态类型和动态类型虽然没有绝对的好和不好, 但是每个都是有自己的优势的, 没有哪一个可以包办一切. 而Go是试图结合静态类型和动态类型(interface)各自的优势.

那么就从头谈起：什么是接口。其实通俗的讲，接口就是一个协议，规定了一组成员，例如.NET里的ICollection接口：

public interface ICollection {

int Count { get; }

object SyncRoot { get; }

bool IsSynchronized { get; }

void CopyTo(Array array, int index);

}

这就是一个协议的全部了吗？事实并非如此，其实接口还规定了每个行为的“特征”。打个比方，这个接口的Count除了需要返回集合内元素的数目以外，还隐含了它需要在O(1)时间内返回这个要求。这样一个使用了ICollection接口的方法才能放心地使用Count属性来获取集合大小，才能在知道这些特征的情况下选用正确的算法来编写程序，而不用担心带来性能问题，这才能实现所谓的“面向接口编程”。当然这种“特征”并不但指“性能”上的，例如Count还包含了例如“不修改集合内容”这种看似十分自然的隐藏要求，这都是ICollection协议的一部分。

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

1、简单易学。

Go语言的作者本身就很懂C语言，所以同样Go语言也会有C语言的基因，所以对于程序员来说，Go语言天生就会让人很熟悉，容易上手。

2、并发性好。

Go语言天生支持并发，可以充分利用多核，轻松地使用并发。 这是Go语言最大的特点。

描述

Go的语法接近C语言，但对于变量的声明有所不同。Go支持垃圾回收功能。Go的并行模型是以东尼·霍尔的通信顺序进程（CSP）为基础，采取类似模型的其他语言包括Occam和Limbo，但它也具有Pi运算的特征，比如通道传输。

在1.8版本中开放插件（Plugin）的支持，这意味着现在能从Go中动态加载部分函数。

与C++相比，Go并不包括如枚举、异常处理、继承、泛型、断言、虚函数等功能，但增加了 切片(Slice) 型、并发、管道、垃圾回收、接口（Interface）等特性的语言级支持。

Go语言的特点

类型 在变量名后边

也可不显式声明类型, 类型推断, 但是是静态语言, name一开始放字符串就不能再赋值数字

方法,属性 分开 方法名首字母大写就是就是外部可调的

面向对象设计的一个重要原则：“优先使用组合而不是继承”

Dog 也是Animal , 要复用Animal 的属性和方法,

只需要在结构体 type 里面写 Animal

入口也是main, 用用试试

多态, 有这个方法就是这个接口的实现, 具体的类 不需要知道自己实现了什么接口,

使用: 在一个函数调用之前加上关键字go 就启动了一个goroutine

创建一个goroutine,它会被加入到一个全局的运行队列当中，

调度器 会把他们分配给某个 逻辑处理器 的队列，

一个逻辑处理器 绑定到一个 操作系统线程 ，在上面运行goroutine，

如果goroutine需要读写文件, 阻塞 ,就脱离逻辑处理器 直接 goroutine - 系统线程 绑定

编译成同名.exe 来执行, 不通过虚拟机, 直接是机器码, 和C 一样, 所以非常快

但是也有自动垃圾回收,每个exe文件当中已经包含了一个类似于虚拟机的runtime,进行goroutine的调度

默认是静态链接的，那个exe会把运行时所需要的所有东西都加进去，这样就可以把exe复制到任何地方去运行了, 因此 生成的 .exe 文件非常大

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

部署简单。Go编译生成的是一个静态可执行文件，除了glibc外没有其他外部依赖。这让部署变得异常方便：目标机器上只需要一个基础的系统和必要的管理、监控工具，完全不需要操心应用所需的各种包、库的依赖关系，大大减轻了维护的负担。这和Python有着巨大的区别。由于历史的原因，Python的部署工具生态相当混乱【比如setuptools,distutils,pip,

buildout的不同适用场合以及兼容性问题】。官方PyPI源又经常出问题，需要搭建私有镜像，而维护这个镜像又要花费不少时间和精力。

并发性好。Goroutine和channel使得编写高并发的服务端软件变得相当容易，很多情况下完全不需要考虑锁机制以及由此带来的各种问题。单个Go应用也能有效的利用多个CPU核，并行执行的性能好。这和Python也是天壤之比。多线程和多进程的服务端程序编写起来并不简单，而且由于全局锁GIL的原因，多线程的Python程序并不能有效利用多核，只能用多进程的方式部署;如果用标准库里的multiprocessing包又会对监控和管理造成不少的挑战【我们用的supervisor管理进程，对fork支持不好】。部署Python应用的时候通常是每个CPU核部署一个应用，这会造成不少资源的浪费，比如假设某个Python应用启动后需要占用100MB内存，而服务器有32个CPU核，那么留一个核给系统、运行31个应用副本就要浪费3GB的内存资源。

良好的语言设计。从学术的角度讲Go语言其实非常平庸，不支持许多高级的语言特性;但从工程的角度讲，Go的设计是非常优秀的：规范足够简单灵活，有其他语言基础的程序员都能迅速上手。更重要的是Go自带完善的工具链，大大提高了团队协作的一致性。比如gofmt自动排版Go代码，很大程度上杜绝了不同人写的代码排版风格不一致的问题。把编辑器配置成在编辑存档的时候自动运行gofmt，这样在编写代码的时候可以随意摆放位置，存档的时候自动变成正确排版的代码。此外还有gofix,

govet等非常有用的工具。

执行性能好。虽然不如C和Java，但通常比原生Python应用还是高一个数量级的，适合编写一些瓶颈业务。内存占用也非常省。

GO语言学习系列八——GO函数(func)的声明与使用

GO是编译性语言，所以函数的顺序是无关紧要的，为了方便阅读，建议入口函数 main 写在最前面，其余函数按照功能需要进行排列

GO的函数 不支持嵌套，重载和默认参数

GO的函数 支持 无需声明变量，可变长度，多返回值，匿名，闭包等

GO的函数用 func 来声明，且左大括号 { 不能另起一行

一个简单的示例：

输出为：

参数：可以传0个或多个值来供自己用

返回：通过用 return 来进行返回

输出为：

上面就是一个典型的多参数传递与多返回值

对例子的说明：

按值传递：是对某个变量进行复制，不能更改原变量的值

引用传递：相当于按指针传递，可以同时改变原来的值，并且消耗的内存会更少，只有4或8个字节的消耗

在上例中，返回值 (d int, e int, f int) { 是进行了命名，如果不想命名可以写成 (int,int,int){ ,返回的结果都是一样的，但要注意:

当返回了多个值，我们某些变量不想要，或实际用不到，我们可以使用 _ 来补位，例如上例的返回我们可以写成 d,_,f := test(a,b,c) ，我们不想要中间的返回值，可以以这种形式来舍弃掉

在参数后面以 变量 ... type 这种形式的，我们就要以判断出这是一个可变长度的参数

输出为：

在上例中， strs ...string 中， strs 的实际值是b,c,d,e,这就是一个最简单的传递可变长度的参数的例子，更多一些演变的形式，都非常类似

在GO中 defer 关键字非常重要，相当于面相对像中的析构函数，也就是在某个函数执行完成后，GO会自动这个；

如果在多层循环中函数里，都定义了 defer ,那么它的执行顺序是先进后出；

当某个函数出现严重错误时， defer 也会被调用

输出为

这是一个最简单的测试了，当然还有更复杂的调用，比如调试程序时，判断是哪个函数出了问题，完全可以根据 defer 打印出来的内容来进行判断，非常快速，这种留给你们去实现

一个函数在函数体内自己调用自己我们称之为递归函数，在做递归调用时，经常会将内存给占满，这是非常要注意的，常用的比如，快速排序就是用的递归调用

本篇重点介绍了GO函数(func)的声明与使用，下一篇将介绍GO的结构 struct

为什么 Go 语言把类型放在后面

不是为了与众不同。而是为了更加清晰易懂。

Rob Pike 曾经在 Go 官方博客解释过这个问题（原文地址：），简略翻译如下（水平有限翻译的不对的地方见谅）：

引言

Go语言新人常常会很疑惑为什么这门语言的声明语法（declaration syntax）会和传统的C家族语言不同。在这篇博文里，我们会进行一个比较，并做出解答。

C 的语法

首先，先看看 C 的语法。C 采用了一种聪明而不同寻常的声明语法。声明变量时，只需写出一个带有目标变量名的表达式，然后在表达式里指明该表达式本身的类型即可。比如：

int x;

上面的代码声明了 x 变量，并且其类型为 int——即，表达式 x 为 int 类型。一般而言，为了指明新变量的类型，我们得写出一个表达式，其中含有我们要声明的变量，这个表达式运算的结果值属于某种基本类型，我们把这种基本类型写到表达式的左边。所以，下述声明：

int *p;

int a[3];

指明了 p 是一个int类型的指针，因为 *p 的类型为 int。而 a 是一个 int 数组，因为 a[3] 的类型为 int（别管这里出现的索引值，它只是用于指明数组的长度）。

我们接下来看看函数声明的情况。C 的函数声明中关于参数的类型是写在括号外的，像下面这样：

int main(argc, argv)

int argc;

char *argv[];

{ /* ... */ }

如前所述，我们可以看到 main 之所以是函数，是因为表达式 main(argc, argv) 返回 int。在现代记法中我们是这么写的：

int main(int argc, char *argv[]) { /* ... */ }

尽管看起来有些不同，但是基本的结构是一样的。

总的来看，当类型比较简单时，C的语法显得很聪明。但是遗憾的是一旦类型开始复杂，C的这套语法很快就能让人迷糊了。著名的例子如函数指针，我们得按下面这样来写：

int (*fp)(int a, int b);

在这儿，fp 之所以是一个指针是因为如果你写出 (*fp)(a, b) 这样的表达式将会调用一个函数，其返回 int 类型的值。如果当 fp 的某个参数本身又是一个函数，情况会怎样呢？

int (*fp)(int (*ff)(int x, int y), int b)

这读起来可就点难了。

当然了，我们声明函数时是可以不写明参数的名称的，因此 main 函数可以声明为：

int main(int, char *[])

回想一下，之前 argv 是下面这样的

char *argv[]

你有没有发现你是从声明的「中间」去掉变量名而后构造出其变量类型的？尽管这不是很明显，但你声明某个 char *[] 类型的变量的时候，竟然需要把名字插入到变量类型的中间。

我们再来看看，如果我们不命名 fp 的参数会怎样：

int (*fp)(int (*)(int, int), int)

这东西难懂的地方可不仅仅是要记得参数名原本是放这中间的

int (*)(int, int)

它更让人混淆的地方还在于甚至可能都搞不清这竟然是个函数指针声明。我们接着看看，如果返回值也是个函数指针类型又会怎么样

int (*(*fp)(int (*)(int, int), int))(int, int)

这已经很难看出是关于 fp 的声明了。

你自己还可以构建出比这更复杂的例子，但这已经足以解释 C 的声明语法引入的某些复杂性了。

还有一点需要指出，由于类型语法和声明语法是一样的，要解析中间带有类型的表达式可能会有些难度。这也就是为什么，C 在做类型转换的时候总是要把类型用括号括起来的原因，像这样

(int)M_PI

Go 的语法

非C家族的语言通常在声明时使用一种不同的类型语法。一般是名字先出现，然后常常跟着一个冒号。按照这样来写，我们上面所举的例子就会变成下面这样：

x: int

p: pointer to int

a: array[3] of int

这样的声明即便有些冗长，当至少是清晰的——你只需从左向右读就行。Go 语言所采用的方案就是以此为基础的，但为了追求简洁性，Go 语言丢掉了冒号并去掉了部分关键词，成了下面这样：

x int

p *int

a [3]int

在 [3]int 和表达式中 a 的用法没有直接的对应关系（我们在下一节会回过头来探讨指针的问题）。至此，你获得了代码清晰性方面的提升，但付出的代价是语法上需要区别对待。

下面我们来考虑函数的问题。虽然在 Go 语言里，main 函数实际上没有参数，但是我们先誊抄一下之前的 main 函数的声明：

func main(argc int, argv *[]byte) int

粗略一看和 C 没什么不同，不过自左向右读的话还不错。

main 函数接受一个 int 和一个指针并返回一个 int。

如果此时把参数名去掉，它还是很清楚——因为参数名总在类型的前面，所以不会引起混淆。

func main(int, *[]byte) int

这种自左向右风格的声明的一个价值在于，当类型变得更复杂时，它依然相对简单。下面是一个函数变量的声明（相当于 C 语言里的函数指针）

f func(func(int,int) int, int) int

或者当它返回一个函数时：

f func(func(int,int) int, int) func(int, int) int

上面的声明读起来还是很清晰，自左向右，而且究竟哪一个变量名是当前被声明的也容易看懂——因为变量名永远在首位。

类型语法和表达式语法带来的差别使得在 Go 语言里调用闭包也变得更简单：

sum := func(a, b int) int { return a+b } (3, 4)

指针

指针有些例外。注意在数组 (array )和切片 (slice) 中，Go 的类型语法把方括号放在了类型的左边，但是在表达式语法中却又把方括号放到了右边：

var a []int

x = a[1]

类似的，Go 的指针沿用了 C 的 * 记法，但是我们写的时候也是声明时 * 在变量名右边，但在表达式中却又得把 * 放到左左边：

var p *int

x = *p

不能写成下面这样

var p *int

x = p*

因为后缀的 * 可能会和乘法运算混淆，也许我们可以改用 Pascal 的 ^ 标记，像这样

var p ^int

x = p^

我们也许还真的应该把 * 像上面这样改成 ^ （当然这么一改 xor 运算的符号也得改），因为在类型和表达式中的 * 前缀确实把好些事儿都搞得有点复杂，举个例子来说，虽然我们可以像下面这样写

[]int("hi")

但在转换时，如果类型是以 * 开头的，就得加上括号：

(*int)(nil)

如果有一天我们愿意放弃用 * 作为指针语法的话，那么上面的括号就可以省略了。

可见，Go 的指针语法是和 C 相似的。但这种相似也意味着我们无法彻底避免在文法中有时为了避免类型和表达式的歧义需要补充括号的情况。

总而言之，尽管存在不足，但我们相信 Go 的类型语法要比 C 的容易懂。特别是当类型比较复杂时。

文章标题：go语言类型声明有什么用,go语言类型声明有什么用处
网页链接：http://hbruida.cn/article/hoihgs.html