锐客网

  1. 首页 > 生活百科 > it技术 > >

go语言的理论 go语言基于什么

IT技术错误

如何看待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; ib.N; i{
var s Stack
s.Push(MyObject{})
s.Push(MyObject{})
【go语言的理论 go语言基于什么】s.Pop()
sink = s.Peek().(MyObject)
}
}
func BenchmarkGo2(b *testing.B) {
for i := 0; ib.N; i{
var s Stack(MyObject)
s.Push(MyObject{})
s.Push(MyObject{})
s.Pop()
sink = s.Peek()
}
}
结果：
BenchmarkGo1BenchmarkGo1-161283752887.0 ns/op48 B/op2 allocs/opBenchmarkGo2BenchmarkGo2-162840647941.9 ns/op24 B/op2 allocs/op
在这种情况下，我们分配更少的内存，同时泛型的速度是非泛型的两倍 。
合约（Contracts）
上面的堆栈示例适用于任何类型 。但是，在许多情况下，你需要编写仅适用于具有某些特征的类型的代码 。例如，你可能希望堆栈要求类型实现 String() 函数
Go语言的优势有哪些1. 部署简单
Go
编译生成的是一个静态可执行文件，除了glibc外没有其他外部依赖 。这让部署变得异常方便：目标机器上只需要一个基础的系统和必要的管理、监控工具，完全不需要操心应用所需的各种包、库的依赖关系，大大减轻了维护的负担 。
2. 并发性好
Goroutine和channel使得编写高并发的服务端软件变得相当容易，很多情况下完全不需要考虑锁机制以及由此带来的各种问题 。单个Go应用也能有效的利用多个CPU核，并行执行的性能好 。
3. 良好的语言设计
从学术的角度讲Go语言其实非常平庸，不支持许多高级的语言特性;但从工程的角度讲，Go的设计是非常优秀的：规范足够简单灵活，有其他语言基础的程序员都能迅速上手 。更重要的是
Go 自带完善的工具链，大大提高了团队协作的一致性 。
4. 执行性能好
虽然不如 C 和 Java ， 但相比于其他编程语言 ， 其执行性能还是很好的 ， 适合编写一些瓶颈业务，内存占用也非常省 。
对比 Go 语言 ， Rust 有什么优势和劣势？我并没有什么编程的经验，觉得编程实在是太复杂了，不喜欢去研究太多，对这个也不怎么懂 ， 只能说自己是个半吊子，就是所掌握的知识，也是东拼西凑的，朋友和我说点儿，自己去书上看一点儿，只能说根据自己的体验给出一些体会吧 。
Rust的优势是：
1、Rust把安全、精确的内存管理作为一切的中心放在首要的位置 。
2、Rust同时拥有特别强的控制性和特别强的安全性 。
3、Rust语言通过： 优秀的类型系统设计、 严格的编译器静态审查、 配合程序员局部核对、加上少量的运行时校验，保障了内存安全 。
4、Rust的语言特别的复杂，导致学习曲线比较陡峭，对于初学者来说难度较大 。但学通之后将终生受益 。
5、效率高，速度特别的快
6、 支持范型
7、 社区活跃度很高，更加的强调了社区的作用 。
8、Rust 有更强的语义 ， 更容易捕获错误的逻辑，编译器直接检查出你代码中的不安全的部分
Rust的劣势是：
1、 语言相对来说比较复杂，对于新手来说，让新手摸不着头脑 。
2、还不算太稳定 。
其实我觉得什么代码啊编程啊这些东西还是比较适合理工的学生去研究，我一看脑袋就大，完全不明白在讲什么 。我大概了解的就是这些，语言的话大家可以多方面的去了解，也不是说有缺点就是不好，看配置看个人吧，每个人习惯不一样 ， 也许有的人用不稳定的还觉得挺好呢 ， 有的人就喜欢比较完美的 ， 在我看来编程这个东西真的是很复杂，会有很多的代码，这些代码弄得我自己头都大了，有的时候还得去恶补一下 。
Golang 中更好的错误处理：理论和实践技巧 云和安全管理服务专家新钛云服 张春翻译
这种方法有几个缺点 。首先，它可以对程序员隐藏错误处理路径，特别是在捕获异常不是强制性的情况下，例如在 Python 中 。即使在具有必须处理的 Java 风格的检查异常的语言中，如果在与原始调用不同的级别上处理错误 ， 也并不总是很明显错误是从哪里引发的 。
我们都见过长长的代码块包装在一个 try-catch 块中 。在这种情况下，catch 块实际上充当 goto 语句，这通常被认为是有害的（奇怪的是，C 中的关键字被认为可以接受的少数用例之一是错误后清理，因为该语言没有 Golang- 样式延迟语句） 。
如果你确实从源头捕获异常，你会得到一个不太优雅的 Go 错误模式版本 。这可能会解决混淆代码的问题，但会遇到另一个问题：性能 。在诸如 Java 之类的语言中 ， 抛出异常可能比函数的常规返回慢数百倍 。
Java 中最大的性能成本是由打印异常的堆栈跟踪造成的 ， 这是昂贵的，因为运行的程序必须检查编译它的源代码。仅仅进入一个 try 块也不是空闲的，因为需要保存 CPU 内存寄存器的先前状态，因为它们可能需要在抛出异常的情况下恢复 。
如果您将异常视为通常不会发生的异常情况，那么异常的缺点并不重要 。这可能是传统的单体应用程序的情况，其中大部分代码库不必进行网络调用——一个操作格式良好的数据的函数不太可能遇到错误（除了错误的情况） 。一旦您在代码中添加 I/O，无错误代码的梦想就会破灭：您可以忽略错误，但不能假装它们不存在！
try {
doSometing()
} catch (IOException e) {
// ignore it
}
与大多数其他编程语言不同 ， Golang 接受错误是不可避免的 。如果在单体架构时代还不是这样，那么在今天的模块化后端服务中，服务通常和外部 API 调用、数据库读取和写入以及与其他服务通信。
以上所有方法都可能失败，解析或验证从它们接收到的数据（通常在无模式 JSON 中）也可能失败 。Golang 使可以从这些调用返回的错误显式化 ， 与普通返回值的等级相同 。从函数调用返回多个值的能力支持这一点，这在大多数语言中通常是不可能的 。Golang 的错误处理系统不仅仅是一种语言怪癖，它是一种将错误视为替代返回值的完全不同的方式！
重复 if err != nil
对 Go 错误处理的一个常见批评是被迫重复以下代码块：
res, err := doSomething()
if err != nil {
// Handle error
}
对于新用户来说，这可能会觉得没用而且浪费行数：在其他语言中需要 3 行的函数很可能会增长到 12 行：
这么多行代码！这么低效！如果您认为上述内容不优雅或浪费代码，您可能忽略了我们检查代码中的错误的全部原因：我们需要能够以不同的方式处理它们！对 API 或数据库的调用可能会被重试 。
有时事件的顺序很重要：调用外部 API 之前发生的错误可能不是什么大问题（因为数据从未通过发送），而 API 调用和写入本地数据库之间的错误可能需要立即注意，因为 这可能意味着系统最终处于不一致的状态 。即使我们只想将错误传播给调用者，我们也可能希望用失败的解释来包装它们，或者为每个错误返回一个自定义错误类型 。
并非所有错误都是相同的，并且向调用者返回适当的错误是 API 设计的重要部分 ， 无论是对于内部包还是 REST API。
不必担心在你的代码中重复 if err != nil ——这就是 Go 中的代码应该看起来的样子 。
自定义错误类型和错误包装
从导出的方法返回错误时，请考虑指定自定义错误类型，而不是单独使用错误字符串 。字符串在意外代码中是可以的，但在导出的函数中，它们成为函数公共 API 的一部分 。更改错误字符串将是一项重大更改——如果没有明确的错误类型，需要检查返回错误类型的单元测试将不得不依赖原始字符串值！事实上，基于字符串的错误也使得在私有方法中测试不同的错误案例变得困难 ， 因此您也应该考虑在包中使用它们 。回到错误与异常的争论 ， 返回错误也使代码比抛出异常更容易测试 ， 因为错误只是要检查的返回值 。不需要测试框架或在测试中捕获异常。
可以在 database/sql 包中找到简单自定义错误类型的一个很好的示例 。它定义了一个导出常量列表，表示包可以返回的错误类型，最著名的是 sql.ErrNoRows 。虽然从 API 设计的角度来看 ， 这种特定的错误类型有点问题（您可能会争辩说 API 应该返回一个空结构而不是错误），但任何需要检查空行的应用程序都可以导入该常量并在代码中使用它不必担心错误消息本身会改变和破坏代码 。
对于更复杂的错误处理，您可以通过实现返回错误字符串的 Error() 方法来定义自定义错误类型 。自定义错误可以包括元数据 ， 例如错误代码或原始请求参数 。如果您想表示错误类别，它们很有用 。DigitalOcean 的本教程展示了如何使用自定义错误类型来表示可以重试的一类临时错误 。
通常，错误会通过将低级错误与更高级别的解释包装起来，从而在程序的调用堆栈中传播 。例如，数据库错误可能会以下列格式记录在 API 调用处理程序中：调用 CreateUser 端点时出错：查询数据库时出错：pq：检测到死锁 。这很有用 ， 因为它可以帮助我们跟踪错误在系统中传播的过程，向我们展示根本原因（数据库事务引擎中的死锁）以及它对更广泛系统的影响（调用者无法创建新用户） 。
自 Go 1.13 以来，此模式具有特殊的语言支持，并带有错误包装 。通过在创建字符串错误时使用 %w 动词，可以使用 Unwrap() 方法访问底层错误 。除了比较错误相等性的函数 errors.Is() 和 errors.As() 外，程序还可以获取包装错误的原始类型或标识 。这在某些情况下可能很有用，尽管我认为在确定如何处理所述错误时最好使用顶级错误的类型 。
Panics
不要 panic()！长时间运行的应用程序应该优雅地处理错误而不是panic 。即使在无法恢复的情况下（例如在启动时验证配置），最好记录一个错误并优雅地退出 。panic比错误消息更难诊断 ， 并且可能会跳过被推迟的重要关闭代码 。
Logging
我还想简要介绍一下日志记录，因为它是处理错误的关键部分 。通常你能做的最好的事情就是记录收到的错误并继续下一个请求 。
除非您正在构建简单的命令行工具或个人项目，否则您的应用程序应该使用结构化的日志库，该库可以为日志添加时间戳，并提供对日志级别的控制 。最后一部分特别重要，因为它将允许您突出显示应用程序记录的所有错误和警告 。通过帮助将它们与信息级日志分开，这将为您节省无数时间 。
微服务架构还应该在日志行中包含服务的名称以及机器实例的名称 。默认情况下记录这些时，程序代码不必担心包含它们 。您也可以在日志的结构化部分中记录其他字段，例如收到的错误（如果您不想将其嵌入日志消息本身）或有问题的请求或响应 。只需确保您的日志没有泄露任何敏感数据，例如密码、API 密钥或用户的个人数据！
对于日志库，我过去使用过 logrus 和 zerolog，但您也可以选择其他结构化日志库 。如果您想了解更多信息，互联网上有许多关于如何使用这些的指南 。如果您将应用程序部署到云中，您可能需要日志库上的适配器来根据您的云平台的日志 API 格式化日志 - 没有它，云平台可能无法检测到日志级别等某些功能 。
如果您在应用程序中使用调试级别日志（默认情况下通常不记录），请确保您的应用程序可以轻松更改日志级别 ， 而无需更改代码 。更改日志级别还可以暂时使信息级别甚至警告级别的日志静音，以防它们突然变得过于嘈杂并开始淹没错误 。您可以使用在启动时检查以设置日志级别的环境变量来实现这一点 。
原文：
Go CSP并发模型Gogo语言的理论的CSP并发模型
Go实现go语言的理论了两种并发形式 。第一种是大家普遍认知的：多线程共享内存 。其实就是Java或者C等语言中的多线程开发 。另外一种是Go语言特有的go语言的理论，也是Go语言推荐的：CSP（communicating sequential processes）并发模型 。
CSP 是 Communicating Sequential Process 的简称go语言的理论，中文可以叫做通信顺序进程go语言的理论，是一种并发编程模型，由 Tony Hoare 于 1977 年提出 。简单来说，CSP 模型由并发执行的实体（线程或者进程）所组成 ， 实体之间通过发送消息进行通信 ， 这里发送消息时使用的就是通道 ， 或者叫 channel 。CSP 模型的关键是关注 channel，而不关注发送消息的实体 。Go 语言实现了 CSP 部分理论。
“不要以共享内存的方式来通信 ， 相反 ， 要通过通信来共享内存 。”
Go的CSP并发模型，是通过goroutine和channel来实现的 。
goroutine 是Go语言中并发的执行单位 。其实就是协程 。
channel是Go语言中各个并发结构体(goroutine)之前的通信机制 。通俗的讲，就是各个goroutine之间通信的”管道“，有点类似于Linux中的管道 。
Channel
Goroutine
go语言的理论的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于go语言基于什么、go语言的理论的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：农村路由器网速怎么样设置，农村路由器网速怎么样设置最快

    下一篇：flutter打开微信小程序，flutter 打开网页