go语言技能树 go语言 语法
GO语言（十三）：使用 Go 和 Gin 开发 RESTful API（下）
当客户端在 发出POST请求时/albums，您希望将请求正文中描述的专辑添加到现有专辑数据中。
创新互联建站网站建设公司，提供成都网站制作、网站设计、外贸网站建设，网页设计，建网站，PHP网站建设等专业做网站服务;可快速的进行网站开发网页制作和功能扩展；专业做搜索引擎喜爱的网站，是专业的做网站团队，希望更多企业前来合作!
为此，您将编写以下内容：
1、编写代码
a.添加代码以将专辑数据添加到专辑列表。
在此代码中：
1）用于Context.BindJSON 将请求正文绑定到newAlbum。
2） album将从 JSON 初始化的结构附加到albums 切片。
3）向响应添加201状态代码，以及表示您添加的专辑的 JSON。
b.更改您的main函数，使其包含该router.POST函数，如下所示。
在此代码中：
1）将路径中的POST方法与 /albumspostAlbums函数相关联。
使用 Gin，您可以将处理程序与 HTTP 方法和路径组合相关联。这样，您可以根据客户端使用的方法将发送到单个路径的请求单独路由。
a.如果服务器从上一节开始仍在运行，请停止它。
b.从包含 main.go 的目录中的命令行，运行代码。
c.从不同的命令行窗口，用于curl向正在运行的 Web 服务发出请求。
该命令应显示添加专辑的标题和 JSON。
d.与上一节一样，使用curl检索完整的专辑列表，您可以使用它来确认添加了新专辑。
该命令应显示专辑列表。
当客户端向 发出请求时GET /albums/[id]，您希望返回 ID 与id路径参数匹配的专辑。
为此，您将：
a.在您在上一节中添加的函数下方postAlbums，粘贴以下代码以检索特定专辑。
此getAlbumByID函数将提取请求路径中的 ID，然后找到匹配的专辑。
在此代码中：
（1）Context.Param用于从 URL 中检索id路径参数。当您将此处理程序映射到路径时，您将在路径中包含参数的占位符。
（2）循环album切片中的结构，寻找其ID 字段值与id参数值匹配的结构。如果找到，则将该album结构序列化为 JSON，并将其作为带有200 OK HTTP 代码的响应返回。
如上所述，实际使用中的服务可能会使用数据库查询来执行此查找。
（3）如果找不到专辑，则返回 HTTP 404错误。
b.最后，更改您的main，使其包含对router.GET的新调用，路径现在为/albums/:id ，如以下示例所示。
在此代码中：
（1）将/albums/:id路径与getAlbumByID功能相关联。在 Gin 中，路径中项目前面的冒号表示该项目是路径参数。
a.如果服务器从上一节开始仍在运行，请停止它。
b.在包含 main.go 的目录中的命令行中，运行代码以启动服务器。
c.从不同的命令行窗口，用于curl向正在运行的 Web 服务发出请求。
该命令应显示您使用其 ID 的专辑的 JSON。如果找不到专辑，您将收到带有错误消息的 JSON。
恭喜！您刚刚使用 Go 和 Gin 编写了一个简单的 RESTful Web 服务。
本节包含您使用本教程构建的应用程序的代码。
Go语言和其他语言的不同之基本语法
Go语言作为出现比较晚的一门编程语言，在其原生支持高并发、云原生等领域的优秀表现，像目前比较流行的容器编排技术Kubernetes、容器技术Docker都是用Go语言写的，像Java等其他面向对象的语言，虽然也能做云原生相关的开发，但是支持的程度远没有Go语言高，凭借其语言特性和简单的编程方式，弥补了其他编程语言一定程度上的不足，一度成为一个热门的编程语言。
最近在学习Go语言，我之前使用过C#、Java等面向对象编程的语言，发现其中有很多的编程方式和其他语言有区别的地方，好记性不如烂笔头，总结一下，和其他语言做个对比。这里只总结差异的地方，具体的语法不做详细的介绍。
种一棵树最好的时间是十年前，其次是现在。
3)变量初始化时候可以和其他语言一样直接在变量后面加等号，等号后面为要初始化的值，也可以使用变量名：=变量值的简单方式
3）变量赋值 Go语言的变量赋值和多数语言一致，但是Go语言提供了多重赋值的功能，比如下面这个交换i、j变量的语句：
在不支持多重赋值的语言中，交换两个变量的值需要引入一个中间变量：
4)匿名变量
在使用其他语言时，有时候要获取一个值，却因为该函数返回多个值而不得不定义很多没有的变量，Go语言可以借助多重返回值和匿名变量来避免这种写法，使代码看起来更优雅。
假如GetName()函数返回3个值，分别是firstName,lastName和nickName
若指向获得nickName，则函数调用可以这样写
这种写法可以让代码更清晰，从而大幅降低沟通的复杂度和维护的难度。
1）基本常量
常量使用关键字const 定义，可以限定常量类型，但不是必须的，如果没有定义常量的类型，是无类型常量
2）预定义常量
Go语言预定义了这些常量 true、false和iota
iota比较特殊，可以被任务是一个可被编译器修改的常量，在每个const关键字出现时被重置为0，然后在下一个const出现之前每出现一个iota，其所代表的数字会自动加1.
3)枚举
1）int 和int32在Go语言中被认为是两种不同类型的类型
2）Go语言定义了两个浮点型float32和float64，其中前者等价于C语言的float类型，后者等价于C语言的double类型
3）go语言支持复数类型
复数实际上是由两个实数（在计算机中使用浮点数表示）构成，一个表示实部（real）、一个表示虚部（imag）。也就是数学上的那个复数
复数的表示
实部与虚部
对于一个复数z=complex(x,y),就可以通过Go语言内置函数real(z)获得该复数的实部，也就是x，通过imag(z)获得该复数的虚部，也就是y
4）数组(值类型，长度在定义后无法再次修改，每次传递都将产生一个副本。)
5）数组切片（slice）
数组切片（slice）弥补了数组的不足，其数据结构可以抽象为以下三个变量：
6）Map 在go语言中Map不需要引入任何库，使用很方便
Go循环语句只支持for关键字，不支持while和do-while
goto语句的语义非常简单，就是跳转到本函数内的某个标签
今天就介绍到这里，以后我会在总结Go语言在其他方面比如并发编程、面向对象、网络编程等方面的不同及使用方法。希望对大家有所帮助。
Go语言之Context
golang在1.6.2的时候还没有自己的context，在1.7的版本中就把golang.org/x/net/context包被加入到了官方的库中。中文译作“上下文”，它主要包含了goroutine 的运行状态、环境等信息。
context 主要用来在 goroutine 之间传递上下文信息，包括：同步信号、超时时间、截止时间、请求相关值等。
该接口定义了四个需要实现的方法：
如果有个网络请求Request，然后这个请求又可以开启多个goroutine做一些事情，当这个网络请求出现异常和超时时，这个请求结束了，这时候就可以通过context来跟踪这些goroutine，并且通过Context来取消他们,然后系统才可回收所占用的资源。
为了更方便的创建Context，包里头定义了Background来作为所有Context的根，它是一个emptyCtx的实例。
Background返回一个非空的Context。它永远不会被取消。它通常用来初始化和测试使用，作为一个顶层的context，也就是说一般我们创建的context都是基于Background。
TODO返回一个非空的Context。当不清楚要使用哪个上下文的时候可以使用TODO。
他们两个本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的Context。
有了如上的根Context，那么是如何衍生更多的子Context的呢？这就要靠context包为我们提供的With系列的函数了。
通过这些函数，就创建了一颗Context树，树的每个节点都可以有任意多个子节点，节点层级可以有任意多个。
WithCancel函数，最常用的派生 context 方法。该方法接受一个父 context。父 context 可以是一个 background context 或其他 context。
WithDeadline函数，该方法会创建一个带有 deadline 的 context。当 deadline 到期后，该 context 以及该 context 的可能子 context 会受到 cancel 通知。另外，如果 deadline 前调用 cancelFunc 则会提前发送取消通知。
WithTimeout和WithDeadline基本上一样，这个表示是超时自动取消，是多少时间后自动取消Context的意思。
WithValue函数和取消Context无关，它是为了生成一个绑定了一个键值对数据的Context，这个绑定的数据可以通过Context.Value方法访问到，一般我们想要通过上下文来传递数据时，可以通过这个方法，如我们需要tarce追踪系统调用栈的时候。
使用Context的程序应遵循以下规则，以使各个包之间的接口保持一致：
1.不要将 Context 塞到结构体里。直接将 Context 类型作为函数的第一参数，而且一般都命名为 ctx。
2.不要向函数传入一个 nil 的 context，如果你实在不知道传什么，标准库给你准备好了一个 context：todo。
3.不要把本应该作为函数参数的类型塞到 context 中，context 存储的应该是一些共同的数据。例如：登陆的 session、cookie 等。
4.同一个 context 可能会被传递到多个 goroutine，别担心，context 是并发安全的。
GO语言商业案例（十八）：stream
切换到新语言始终是一大步，尤其是当您的团队成员只有一个时有该语言的先前经验。现在，Stream 的主要编程语言从 Python 切换到了 Go。这篇文章将解释stream决定放弃 Python 并转向 Go 的一些原因。
Go 非常快。性能类似于 Java 或 C++。对于用例，Go 通常比 Python 快 40 倍。
对于许多应用程序来说，编程语言只是应用程序和数据库之间的粘合剂。语言本身的性能通常并不重要。然而，Stream 是一个API 提供商，为 700 家公司和超过 5 亿最终用户提供提要和聊天平台。多年来，我们一直在优化 Cassandra、PostgreSQL、Redis 等，但最终，您会达到所使用语言的极限。Python 是一门很棒的语言，但对于序列化/反序列化、排名和聚合等用例，它的性能相当缓慢。我们经常遇到性能问题，Cassandra 需要 1 毫秒来检索数据，而 Python 会花费接下来的 10 毫秒将其转换为对象。
看看我如何开始 Go 教程中的一小段 Go 代码。（这是一个很棒的教程，也是学习 Go 的一个很好的起点。）
如果您是 Go 新手，那么在阅读那个小代码片段时不会有太多让您感到惊讶的事情。它展示了多个赋值、数据结构、指针、格式和一个内置的 HTTP 库。当我第一次开始编程时，我一直喜欢使用 Python 更高级的功能。Python 允许您在编写代码时获得相当的创意。例如，您可以：
这些功能玩起来很有趣，但是，正如大多数程序员会同意的那样，在阅读别人的作品时，它们通常会使代码更难理解。Go 迫使你坚持基础。这使得阅读任何人的代码并立即了解发生了什么变得非常容易。 注意：当然，它实际上有多“容易”取决于您的用例。如果你想创建一个基本的 CRUD API，我仍然推荐 Django + DRF或 Rails。
作为一门语言，Go 试图让事情变得简单。它没有引入许多新概念。重点是创建一种非常快速且易于使用的简单语言。它唯一具有创新性的领域是 goroutine 和通道。（100% 正确CSP的概念始于 1977 年，所以这项创新更多是对旧思想的一种新方法。）Goroutines 是 Go 的轻量级线程方法，通道是 goroutines 之间通信的首选方式。Goroutines 的创建非常便宜，并且只需要几 KB 的额外内存。因为 Goroutine 非常轻量，所以有可能同时运行数百甚至数千个。您可以使用通道在 goroutine 之间进行通信。Go 运行时处理所有复杂性。goroutines 和基于通道的并发方法使得使用所有可用的 CPU 内核和处理并发 IO 变得非常容易——所有这些都不会使开发复杂化。与 Python/Java 相比，在 goroutine 上运行函数需要最少的样板代码。您只需在函数调用前加上关键字“go”：
Go 的并发方法很容易使用。与 Node 相比，这是一种有趣的方法，开发人员必须密切关注异步代码的处理方式。Go 中并发的另一个重要方面是竞争检测器。这样可以很容易地确定异步代码中是否存在任何竞争条件。
我们目前用 Go 编写的最大的微服务编译需要 4 秒。与以编译速度慢而闻名的 Java 和 C++ 等语言相比，Go 的快速编译时间是一项重大的生产力胜利。我喜欢在程序编译的时候摸鱼，但在我还记得代码应该做什么的同时完成事情会更好。
首先，让我们从显而易见的开始：与 C++ 和 Java 等旧语言相比，Go 开发人员的数量并不多。根据StackOverflow的数据， 38% 的开发人员知道 Java， 19.3% 的人知道 C++，只有 4.6% 的人知道 Go。GitHub 数据显示了类似的趋势：Go 比 Erlang、Scala 和 Elixir 等语言使用更广泛，但不如 Java 和 C++ 流行。幸运的是，Go 是一种非常简单易学的语言。它提供了您需要的基本功能，仅此而已。它引入的新概念是“延迟”声明和内置的并发管理与“goroutines”和通道。（对于纯粹主义者来说：Go 并不是第一种实现这些概念的语言，只是第一种使它们流行起来的语言。）任何加入团队的 Python、Elixir、C++、Scala 或 Java 开发人员都可以在一个月内在 Go 上发挥作用，因为它的简单性。与许多其他语言相比，我们发现组建 Go 开发人员团队更容易。如果您在博尔德和阿姆斯特丹等竞争激烈的生态系统中招聘人员，这是一项重要的优势。
对于我们这样规模的团队（约 20 人）来说，生态系统很重要。如果您必须重新发明每一个小功能，您根本无法为您的客户创造价值。Go 对我们使用的工具有很好的支持。实体库已经可用于 Redis、RabbitMQ、PostgreSQL、模板解析、任务调度、表达式解析和 RocksDB。与 Rust 或 Elixir 等其他较新的语言相比，Go 的生态系统是一个重大胜利。它当然不如 Java、Python 或 Node 之类的语言好，但它很可靠，而且对于许多基本需求，你会发现已经有高质量的包可用。
Gofmt 是一个很棒的命令行实用程序，内置在 Go 编译器中，用于格式化代码。就功能而言，它与 Python 的 autopep8 非常相似。我们大多数人并不真正喜欢争论制表符与空格。格式的一致性很重要，但实际的格式标准并不那么重要。Gofmt 通过使用一种正式的方式来格式化您的代码来避免所有这些讨论。
Go 对协议缓冲区和 gRPC 具有一流的支持。这两个工具非常适合构建需要通过 RPC 通信的微服务。您只需要编写一个清单，在其中定义可以进行的 RPC 调用以及它们采用的参数。然后从这个清单中自动生成服务器和客户端代码。生成的代码既快速又具有非常小的网络占用空间并且易于使用。从同一个清单中，您甚至可以为许多不同的语言生成客户端代码，例如 C++、Java、Python 和 Ruby。因此，内部流量不再有模棱两可的 REST 端点，您每次都必须编写几乎相同的客户端和服务器代码。.
Go 没有像 Rails 用于 Ruby、Django 用于 Python 或 Laravel 用于 PHP 那样的单一主导框架。这是 Go 社区内激烈争论的话题，因为许多人主张你不应该一开始就使用框架。我完全同意这对于某些用例是正确的。但是，如果有人想构建一个简单的 CRUD API，他们将更容易使用 Django/DJRF、Rails Laravel 或Phoenix。对于 Stream 的用例，我们更喜欢不使用框架。然而，对于许多希望提供简单 CRUD API 的新项目来说，缺乏主导框架将是一个严重的劣势。
Go 通过简单地从函数返回错误并期望调用代码来处理错误（或将其返回到调用堆栈）来处理错误。虽然这种方法有效，但很容易失去问题的范围，以确保您可以向用户提供有意义的错误。错误包通过允许您向错误添加上下文和堆栈跟踪来解决此问题。另一个问题是很容易忘记处理错误。像 errcheck 和 megacheck 这样的静态分析工具可以方便地避免犯这些错误。虽然这些变通办法效果很好，但感觉不太对劲。您希望该语言支持正确的错误处理。
Go 的包管理绝不是完美的。默认情况下，它无法指定特定版本的依赖项，也无法创建可重现的构建。Python、Node 和 Ruby 都有更好的包管理系统。但是，使用正确的工具，Go 的包管理工作得很好。您可以使用Dep来管理您的依赖项，以允许指定和固定版本。除此之外，我们还贡献了一个名为的开源工具VirtualGo，它可以更轻松地处理用 Go 编写的多个项目。
我们进行的一个有趣的实验是在 Python 中使用我们的排名提要功能并在 Go 中重写它。看看这个排名方法的例子：
Python 和 Go 代码都需要执行以下操作来支持这种排名方法：
开发 Python 版本的排名代码大约花了 3 天时间。这包括编写代码、单元测试和文档。接下来，我们花了大约 2 周的时间优化代码。其中一项优化是将分数表达式 (simple_gauss(time)*popularity) 转换为抽象语法树. 我们还实现了缓存逻辑，可以在未来的特定时间预先计算分数。相比之下，开发此代码的 Go 版本大约需要 4 天时间。性能不需要任何进一步的优化。因此，虽然 Python 的最初开发速度更快，但基于 Go 的版本最终需要我们团队的工作量大大减少。另外一个好处是，Go 代码的执行速度比我们高度优化的 Python 代码快大约 40 倍。现在，这只是我们通过切换到 Go 体验到的性能提升的一个示例。
与 Python 相比，我们系统的其他一些组件在 Go 中构建所需的时间要多得多。作为一个总体趋势，我们看到 开发 Go 代码需要更多的努力。但是，我们花更少的时间 优化 代码以提高性能。
我们评估的另一种语言是Elixir.。Elixir 建立在 Erlang 虚拟机之上。这是一种迷人的语言，我们之所以考虑它，是因为我们的一名团队成员在 Erlang 方面拥有丰富的经验。对于我们的用例，我们注意到 Go 的原始性能要好得多。Go 和 Elixir 都可以很好地服务数千个并发请求。但是，如果您查看单个请求的性能，Go 对于我们的用例来说要快得多。我们选择 Go 而不是 Elixir 的另一个原因是生态系统。对于我们需要的组件，Go 有更成熟的库，而在许多情况下，Elixir 库还没有准备好用于生产环境。培训/寻找开发人员使用 Elixir 也更加困难。这些原因使天平向 Go 倾斜。Elixir 的 Phoenix 框架看起来很棒，绝对值得一看。
Go 是一种非常高性能的语言，对并发有很好的支持。它几乎与 C++ 和 Java 等语言一样快。虽然与 Python 或 Ruby 相比，使用 Go 构建东西确实需要更多时间，但您将节省大量用于优化代码的时间。我们在Stream有一个小型开发团队，为超过 5 亿最终用户提供动力和聊天。Go 结合了 强大的生态系统 、新开发人员的 轻松入门、快速的性能 、对并发的 可靠支持和高效的编程环境 ，使其成为一个不错的选择。Stream 仍然在我们的仪表板、站点和机器学习中利用 Python 来提供个性化的订阅源. 我们不会很快与 Python 说再见，但今后所有性能密集型代码都将使用 Go 编写。我们新的聊天 API也完全用 Go 编写。
GO语言商业案例（十六）：Curve-
Golang 的创建是为了实现最大的用户效率和编码效率。已经熟悉 Java 或 PHP 的程序员可以在几周内接受 Go 的培训（许多人最终会更喜欢它）。在本文中，Dewet Diener 探讨了 Golang 的优缺点，以及它的测试驱动开发 (TDD) 如何完美契合。
Golang 由 Google 开发和设计，于 2009 年作为一种综合性编程语言首次出现，旨在最大限度地提高编码效率。创建该语言的目的是修正其他已建立语言的缺陷。尽管 Golang（或简称为“Go”）是一门年轻的语言，但已经积累了大量的开发人员，因此我们想分享为什么在 Curve 我们喜欢 Golang，以及我们如何采用它来实现我们移动银行业务的目标到云端。
Go 是一种精致的编程语言：它支持“所见即所得”的原则，这意味着清晰易读的代码和更少的复杂抽象。该语言本身易于使用且易于训练。尽管如此，作为一个相对较新的生态系统，要找到对 Go 具有广泛预先知识的工程师可能会很棘手。
然而，与其他编程语言不同，Go 的创建是为了最大限度地提高用户效率。因此，具有 Java 或 PHP 背景的开发人员和工程师可以在几周内获得使用 Go 的技能和培训——根据我们的经验，他们中的许多人最终更喜欢它。
在 Curve，我们大力提倡测试驱动开发 (TDD)，Go 的框架与这种方法保持一致。通过简单地命名一个文件 foo_test.go 并在该文件中添加结构化测试函数，Go 将快速有效地运行您的单元测试。这一创新功能提高了生产力，因为它可以更加专注于测试驱动的开发和改进的同行评审机会。
Golang 具有出色的生产优化品质，例如内存占用小，这支持其在大型项目中作为构建块的能力，以及开箱即用的与其他架构的轻松交叉编译。由于 Go 代码被编译为单个静态二进制文件，因此它可以轻松进行容器化，并且通过扩展，将 Go 部署到任何高可用性环境（例如 Kubernetes）中几乎是微不足道的。
它提供了一种机制来保护工作负载，通过拥有非常纤薄的生产容器而没有任何无关的依赖项。这使得构建、部署和维护基于 Go 的资产更加直接和安全，并为希望建立或发展其微服务战略的公司提供了可靠的选择。
Go 是专门为满足我们快速发展的技术生态系统的需求而创建的。例如，Go 可以满足您构建 API 所需的一切，并将其作为其标准库的一部分。它使用简单，高性能的 http 服务器消除了团队设计新项目时经常发生的一些常见的 探索 和设计瘫痪问题——这对于一些其他流行语言（如 Java 和 Node.js）来说太常见了。
Golang 还通过其内置于语言本身的自动格式化程序巧妙地解决了代码格式化分歧。这完全消除了格式争议，进而提高了团队的生产力和注意力。
尽管我是 Go 的拥护者，但它显然也不是没有缺陷。一个争论不休的特性是 Go 没有显式接口，这是许多开发人员习惯的概念。虽然不是有害的，但它可以使选择最适合您的结构的接口成为一项任务。这是因为您不会像在其他流行的编程语言中那样编写 X 实现 Y，但您很快就会接受。
依赖管理也是另一个不属于 Google Golang 开发团队原始设计的功能。开源社区介入并创建了 Glide 和 Dep，最初的努力并没有完全解决问题。从 Go 1.11 开始，添加了对模块的支持，这似乎已成为官方的依赖管理工具。这些挑战并没有削弱 Go 作为一种高效编程语言的独创性，并且它继续为我们提供优于其他编程语言的显着优势。
Golang 吸引了全球敏锐的开发人员的注意，并且围绕它的兴奋继续增长。开源社区因有趣的项目而蓬勃发展；最著名的是 Docker 和 Kubernetes。
正是这种新鲜、有创意但又简单的包装吸引了我们去Go：它是一种令人兴奋的编码语言，可以帮助我们在 Curve 中快速开发以构建更好的产品。
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.字符串替换
本文名称：go语言技能树 go语言 语法
本文路径：http://myzitong.com/article/doohpho.html