gpt4 book ai didi

深入分析Go语言与C#的异同

转载 作者:我是一只小鸟 更新时间:2023-06-19 14:31:51 26 4
gpt4 key购买 nike

摘要:本文由葡萄城技术团队于博客园原创并首发。转载请注明出处: 葡萄城官网 ,葡萄城为开发者提供专业的开发工具、解决方案和服务,赋能开发者.

前言

为了更加深入地介绍Go语言以及与C#语言的比较,本文将会从多个维度出发进行详细的阐述。首先,将从Go语言的关键字方面介绍Go与C#在语言特性上的异同,并且探讨两种语言在关键字方面的优化和不足之处。其次,本文将通过代码示例、性能测试等方式,展示Go语言在关键字方面的优势,从而为读者呈现出Go语言的强大之处。除此之外,为了更好地帮助读者理解Go语言,本文还将介绍一些优秀的Go语言工具和社区资源,供读者进一步学习和探索。相信通过这些内容的全面介绍,读者们会对Go语言有更全面深入的认识和了解.

文章目录:

1.Go的前世今生 。

​  1.1Go语言诞生的过程 。

​  1.2逐步成型 。

​  1.3正式发布 。

​  1.4 Go安装指导 。

2.Go和C#的关键字比较 。

​  2.1Go与C#都有的关键字 。

​   2.1.1.Var 。

​   2.1.2. Switch-case-default 。

​   2.1.3.If-else 。

​   2.1.4. For 。

​   2.1.5. Struct 。

​​  2.2Go与C#不太一样但是意思差不多的关键字 。

​   2.2.1. Package与namespace 。

​​   2.2.2. Import与using 。

​​   2.2.3. Type与class 。

​   2.2.4. Defer与finally 。

​  2.3Go有而 C#没有的关键字 。

​​   2.3.1. Fallthrough 。

​​   2.3.2.Func 。

3.文章小结 4.扩展链接 。

1.Go的前世今生

1.1Go语言诞生的过程

话说早在 2007 年 9 月的一天,Google 工程师 Rob Pike 和往常一样启动了一个 C++项目的构建,按照他之前的经验,这个构建应该需要持续 1 个小时左右。这时他就和 Google公司的另外两个同事 Ken Thompson 以及 Robert Griesemer 开始吐槽并且说出了自己想搞一个新语言的想法。当时 Google 内部主要使用 C++构建各种系统,但 C++复杂性巨大并且原生缺少对并发的支持,使得这三位大佬苦恼不已.

第一天的闲聊初有成效,他们迅速构想了一门新语言:能够给程序员带来快乐,能够匹配未来的硬件发展趋势以及满足 Google 内部的大规模网络服务。并且在第二天,他们又碰头开始认真构思这门新语言。第二天会后,Robert Griesemer 发出了如下的一封邮件:

可以从邮件中看到,他们对这个新语言的期望是: 在 C 语言的基础上,修改一些错误,删除一些诟病的特性,增加一些缺失的功能。 比如修复 Switch 语句,加入 import 语句,增加垃圾回收,支持接口等。而这封邮件,也成了 Go 的第一版设计初稿.

在这之后的几天,Rob Pike 在一次开车回家的路上,为这门新语言想好了名字Go。在他心中,”Go”这个单词短小,容易输入并且可以很轻易地在其后组合其他字母,比如 Go 的工具链:goc 编译器、goa 汇编器、gol 连接器等,并且这个单词也正好符合他们对这门语言的设计初衷:简单.

1.2逐步成型

在统一了 Go 的设计思路之后,Go 语言就正式开启了语言的设计迭代和实现。2008 年,C语言之父,大佬肯·汤普森实现了第一版的 Go 编译器,这个版本的 Go 编译器还是使用C语言开发的,其主要的工作原理是将Go编译成C,之后再把C编译成二进制文件。到2008年中,Go的第一版设计就基本结束了。这时,同样在谷歌工作的伊恩·泰勒(Ian Lance Taylor)为Go语言实现了一个gcc的前端,这也是 Go 语言的第二个编译器。伊恩·泰勒的这一成果不仅仅是一种鼓励,也证明了 Go 这一新语言的可行性 。有了语言的第二个实现,对Go的语言规范和标准库的建立也是很重要的。随后,伊恩·泰勒以团队的第四位成员的身份正式加入 Go 语言开发团队,后面也成为了 Go 语言设计和实现的核心人物之一。罗斯·考克斯(Russ Cox)是Go核心开发团队的第五位成员,也是在2008年加入的。进入团队后,罗斯·考克斯利用函数类型是“一等公民”,而且它也可以拥有自己的方法这个特性巧妙设计出了 http 包的 HandlerFunc 类型。这样,我们通过显式转型就可以让一个普通函数成为满足 http.Handler 接口的类型了。不仅如此,罗斯·考克斯还在当时设计的基础上提出了一些更泛化的想法,比如 io.Reader 和 io.Writer 接口,这就奠定了 Go 语言的 I/O 结构模型。后来,罗斯·考克斯成为 Go 核心技术团队的负责人,推动 Go 语言的持续演化。到这里,Go 语言最初的核心团队形成,Go 语言迈上了稳定演化的道路.

1.3正式发布

2009年10月30日,罗伯·派克在Google Techtalk上做了一次有关 Go语言的演讲,这也是Go语言第一次公之于众。十天后,也就是 2009 年 11 月 10 日,谷歌官方宣布 Go 语言项目开源,之后这一天也被 Go 官方确定为 Go 语言的诞生日.

(Go语言吉祥物Gopher) 。

1.4.Go安装指导

1.Go语言安装包下载 。

Go 官网: https://golang.google.cn/ 。

选择对应的安装版本即可(建议选择.msi文件).

2.查看是否安装成功 + 环境是否配置成功 。

打开命令行:win + R 打开运行框,输入 cmd 命令,打开命令行窗口.

命令行输入 go version 查看安装版本,显示下方内容即为安装成功.

2.Go和C#的关键字比较

Go有25个关键字,而C#则有119个关键字(其中包含77个基础关键字和42个上下文关键字)。单从数量上来讲,C#的数量是Go的5倍之多,这也是Go比C#更简单的原因之一.

Go中的 25 个关键字:

break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

(Go关键字) 。

2.1Go与C#都有的关键字

  • break
  • case
  • const
  • continue
  • default
  • else
  • for
  • goto
  • if
  • interface
  • return
  • struct
  • switch
  • var

以上14个关键字是Go和C#共有的,它们之中大部分的用法都是完全相同的,这里重点说一下在Go中有特殊语法的关键字.

2.1.1.Var

Var在Go中用来表示定义变量,但语法和 C#不同。C#中只有一种定义变量的方法,而 Go中有两种,它们分别是:

  • 普通方式
                        
                          var i int = 1

                        
                      

这种方式是Go的原始变量定义方式,一般包级别的变量都是这样定义的,并且如果定义那些编译器可以自动推断的类型,比如上述的例子,其后的类型可以省略.

  • 语法糖(是的,Go中也有语法糖…)
                        
                          i, j := 1, "hello"

                        
                      

上述代码可简写为语法糖形式。事实上,Go代码中,90%变量都以此方式定义,因为几乎所有函数都有多个返回值,这种定义方式可省去许多麻烦.

2.1.2.Switch-case-default

Switch-case是一个连用的方法,但是case和default这两个关键字在 Go中除了可以和 switch 连用,还可以和select 语句连用.

同时Go中默认把 switch 语句的一个弊端修复了,即 switch 子句中不用再写 break 了.

                        
                          switch n := "a"; n {

case n == "a":

fmt.Println("a")

case n == "b":

fmt.Println("b")

case n == "c":

fmt.Println("c")

}

                        
                      

上面这段代码的fmt是Go中的标准输出包,其中的Println函数等同于C#中的Console.WriteLine方法。同时这段代码的最终结果只会输出a,而 在C#中,同样的代码会把abc全部输出出来,这也是Go为何比C#简单的原因之一.

除此之外,switch 语句后面出现了一种全新的写法:n := "a"; n,这种写法在Go中的控制语句(if, else if, switch-case, for)中都可以使用,分号前是变量的定义,分号后是定义的判断条件。这种语法优点类似于 C#中的普通 for 循环的前两个子句.

最后,可以发现switch之后没有跟小括号,因为在Go中,控制块的子句后面都是不需要写小括号的,如果写了同样会被 gofmt 自动格式化掉.

2.1.3. If-else

Go中的if-else和C#几乎也是相同的,它俩最大的区别是Go中特殊语法,可以在 if-else 控制块中直接给变量赋值并且在控制块中使用这些值.

                        
                          func isEven(n int) bool {

return n % 2 == 0

}

func main() {

if n := rand.Intn(1000); isEven(n) {

fmt.Printf("%d是偶数\\n", n)

} else {

fmt.Printf("%d是奇数\\n", n)

}

}

                        
                      

2.1.4. For

Go中的循环控制语句有且只有一个 for 关键字。而 C#中的 while、foreach 等在Go中都是通过 for 的各种变形达成的.

  • while 语句
                        
                          for true {

// ...

}

                        
                      
  • for 语句
                        
                          for i := 0; i < n; i++ {

// ...

}

                        
                      

Go中普通的 for 循环和 C#中唯一的差别就是 i++从表达式变成了语句。也就是说,Go中没有i = i++这样的语法,也没有++i这样的语法,只有i++这种语法.

  • foreach 语句
                        
                          array := [5]int{1, 2, 3, 4, 5}

for index, value := range array {

// ...

}

                        
                      

foreach 语句的写法和 C#中很不相同,上述的例子是 foreach 遍历一个int类型的数组,其中用到了一个range关键字,这个关键字会把数组拆分成两个迭代子对象index 和value,for range可以遍历数组、切片、字符串、map 及通道(channel),这个语法同样类似于 JavaScript 的循环语法。例如下面的代码就是遍历数组中的值并输出:

                        
                          for key, value := range []int{1, 2, 3, 4} {

fmt.Printf("key:%d value:%d\\n", key, value)

}

                        
                      

代码输出如下:

                        
                          key:0 value:1

key:1 value:2

key:2 value:3

key:3 value:4

                        
                      

2.1.5 Struct

Go中的struct关键字和C#中的作用是相同的,即定义一个结构体。因为Go中是没有类这个概念的,所以struct就相当于是C#中class的定义。同样的,struct在Go中是 值类型 结构,因此使用的时候一定需要注意案值传递导致的复制问题。( 需要注意的是Go中的struct只能定义字段,不能定义函数。) 。

                        
                          // struct的定义是配合type关键字一起使用的

type People struct {

name string // 定义的字段和Go语言其他的风格相同,名字在前,类型在后

age int

}

                        
                      

2.2Go与C#不一样但使用方法差不多的关键字

  • package
  • import
  • type
  • defer

2.2.1.Package与namespace

Go中的package和C#的namespace基本相同,就是定义组织的一个包,主要作用是对代码模块进行隔离。但Go和C#不同的是,C#十分灵活,即使不在一个文件夹下的代码都可以定义为相同的namespace。但是Go中package内的文件都需要在相同的文件夹内才能被正确编译,并且一个文件夹内只能出现最多一个包名。除此之外,类似于C#中的Main方法,Go中可运行程序的执行入口也是一个 main函数,但是main函数必须定义在package main下.

                        
                          // Go中,同一个文件夹只能同时存在一个包名

// 包名可以和文件夹名不同,但是必须有且只有一个

package main

// main函数只能在main包下才能正确作为启动函数运行

func main() {

//do something

}

// 同文件夹下的另一个文件,比如hello.go

package hello //编译器报错

                        
                      

2.2.2.Import与using

Import和using的作用都是用来导入其他模块的代码。但是Go比C#多了一个强制要求:没有在代码模块中使用import或者是定义了但是没有使用的变量,在编译时会直接报错。这样做的目的除了使代码看起来更简洁以外,最主要的原因是import语句还有另一个重要功能就是调用包中的init()函数。例如如下代码:

                        
                          // hello文件夹下的demo文件夹内的 demo.go

package demo

var me string

func init() {

me = "jeffery"

}

func SayHello() {

fmt.Printf("hello, %s", me)

}

// hello文件夹下的hello.go

package main

import "hello/demo"

func main() {

demo.SayHello() // 输出:hello, jeffery

}

                        
                      

上述的程序定义了一个demo文件,当demo文件第一次被import关键字加载到其他包时,会自动调用其init()函数,这时就会把变量me赋值为jeffery,之后调用SayHello()函数时,返回的就都是”hello, jeffery”了。也正是因为init函数的存在,不使用的import需要被删除,因为如果不删除很有可能会自动调用到未被使用的包内的 init 函数.

2.2.3. Type与class

  • 常规用法

把 type和class 对比其实是不太合理的。因为 C#中class关键字是定义一个类型和这个类型的具体实现,比如下述的代码在 C#中的意思是定义一个名为People的类,并且定义了这类中有一个属性 Age.

                        
                          interface IAnimal {

public void Move();

}

class People {

public int Age { get;set; }

}

                        
                      

然而Go中的type关键字仅仅是用来定义类型名称的,如果想要定义其实现,必须后面再更上具体实现的关键字。比如上述的代码定义在Go中就变成了如下:

                        
                          type IAnimal interface {

Move()

}

type People struct {

Age int

}

                        
                      

上述只是 type 的最常用用法,除此之外 type 还有两个其他的用法:

  • 以一个基准类型定义一个新类型
                        
                          type Human People

                        
                      

这样的语句相当于用People类型定义了一个Human的新类型。 注意,这里是一个新类型,而不是 C#中的继承 。因此如果People内有一个Move函数,那Human对象是无法调用这个Move函数的,如果非要使用,则需要强制类型转换。(Go中的强制类型转换是类型+ (),比如上述的例子 Human(People)就可以把 People 类型强转为 Human 类型) 。

  • 定义类型别名
                        
                          type Human = People

                        
                      

如果使用了等号进行定义,那就相当于给类型 People 定义了一个别名 Human,这种情况下 People 中的代码 Human 也是可以正常使用的。上面两种用法基本都不常用,这里只做了解即可.

2.2.4.Defer与finally

Go中的defer和C#的finally是一样的,在一个方法执行结束退出之前只可以干一件事。而和 C#不太一样的是,Go中的 defer 语句不用必须写在最后,比如我们会经常看到这样风格的代码:

                        
                          var mutex sync.Mutex // 一个全局锁,可以类似的等价于C#中的Monitor类

func do() {

mutex.Lock()

defer mutex.Unlock()

// ...

}

                        
                      

上面这个例子的意思是定义一个全局锁,在do函数进入时,加锁,在退出时解锁。之后再去写自己的业务逻辑。除此之外,defer也可以写多个,但最终的执行顺序是从下向上执行,也就是最后定义的defer先执行.

2.3Go有而 C#没有的关键字

  • fallthrough
  • func

2.3.1. Fallthrough

这个关键字是为了兼容C语言中的 fallthrough,其目的是是在 switch-case 语句中再向下跳一个case,比如下面这个例子:

                        
                          switch n := "a"; n {

case n == "a":

fmt.Println("a")

fallthrough

case n == "b":

fmt.Println("b")

case n == "c":

fmt.Println("c")

}

                        
                      

这个例子的最终输出结果就是:

                        
                          a

b

                        
                      

2.3.2.Func

和其他函数(比如 JavaScript 的 function,Python 中的 def)一样,Go中的 func就是用来定义函数的.

                        
                          // 定义了一个函数名称为getName的函数

// 其中包含一个int类型的参数id

// 以及两个返回值,string和bool类型

func getName(id int) (string, bool) {

return "jeffery", true

}

                        
                      

Go中的函数以及其他一系列需要定义类型的语法中,永远都遵循 名称在前,类型在后 。此外,Go中的func同样也可以配合type使用定义C#中的委托,比如我们可以在 C#中定义一个.Net Core 的中间件:

                        
                          public delegate void handleFunc(HttpContext httpContext);

public delegate handleFunc middleware(handleFunc next);

                        
                      

这样的代码可以在 Go中这样实现:

                        
                          type handleFunc func(httpContext HttpContext)

type middleware func(next handleFunc) handleFunc

                        
                      

3.文章小结

Go语言相较于C#在关键字上的优点有以下几个:

1.更简洁的语法:Go语言致力于简化代码的编写和理解,使得语言关键字的数量更少,更加简洁明了。相比之下,C#拥有更多的关键字,从而使代码的可读性稍微降低.

2.更好的并发性支持:Go语言天然支持并发编程,通过goroutine和channel管道,可以轻松实现高并发的程序。而C#对于并发编程需要手动处理锁,信号量等机制来控制线程的并发,代码比较繁琐.

3.更好的内存管理:Go语言使用垃圾回收机制,不需要开发者手动管理内存,避免了许多内存泄漏等问题。相比之下,C#需要开发者手动进行内存管理,需要使用using关键字或者手动释放内存等机制来控制内存,这增加了代码的复杂性.

4.更好的性能:由于采用了更简洁的语法和更好的内存管理,Go语言编写的程序具有更好的性能表现。与C#相比,Go语言的程序不仅运行速度更快,而且资源消耗更少,性能更出色.

4.扩展链接

如何使用 Blazor 框架在前端浏览器中导入/导出 Excel XLSX 。

万物皆可集成系列:低代码对接微信小程序 。

C#编写服务器端API 。

最后此篇关于深入分析Go语言与C#的异同的文章就讲到这里了,如果你想了解更多关于深入分析Go语言与C#的异同的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。

26 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com