golang string转int8_Golang从0到1

<h2> 原文<span style="font-weight:bold;">https://</span><span style="font-weight:bold;">milapneupane.com.np/201</span><span style="font-weight:bold;">9/07/06/learning-golang-from-zero-to-hero/</span><span style="font-weight:bold;"/></h2>

<blockquote> “Go是一种开源编程语言，可以轻松构建简单，可靠，高效的软件”。 ——GoLang </blockquote>

在许多语言中，有许多方法可以解决给定的问题。程序员可以花很多时间思考解决问题的最佳方法。另一方面，Golang坚持精简的功能 - 只有一种正确的方法可以解决问题。

这节省了开发人员的时间，并使大型代码库易于维护。Golang中没有像地图和过滤器这样的“富有表现力”的功能。

<blockquote> “如果你有增加表现力的功能，通常会增加费用” ——罗伯派克 </blockquote>

<i>最近发布的golang新标识：https：//http://blog.golang.org/go-brand</i>

<h2>入门</h2>

Golang由包组成。包main告诉Golang编译器该程序被编译为可执行文件，而不是共享库。它是应用程序的入口点。主包定义为：

让我们通过main.go 在Go lang工作区中创建一个文件来编写一个简单的hello world示例

<h3>工作区</h3>

Go中的工作空间由环境变量GOPATH定义。

您编写的任何代码都将写在工作区内。Go将搜索GOPATH目录中的所有的包，或者GOROOT在安装Go时默认设置的目录。 GOROOT是安装go的路径。

设置 GOPATH 为所需的目录。现在，让我们将 ~/workspace设置为GOPATH。

在main.go 我们刚刚创建的工作空间文件夹中使用以下代码创建文件。

HELLO WORLD!

在上面的示例中，<code>fmt</code>是Go中的内置包实现了格式化I / O的函数。

我们使用<code>import</code>关键字在Go中导入包。<code>func main</code> 是代码执行的主要入口点。<code>Println</code> 是包内的一个函数，<code>fmt</code>它为我们打印“hello world”。

让我们看一下运行这个文件。我们可以通过两种方式运行Go命令。我们知道，Go是一种编译语言，所以我们首先需要在执行之前编译它。

这将创建一个二进制可执行文件 main ，现在我们可以运行

<i>注意：要尝试运行本文提到的代码，您可以使用 https://play.golang.org</i>

<h2>变量</h2>

Go中的变量是明确声明的。Go是一种静态类型语言。这意味着在变量声明时检查变量类型。变量可以声明为：

在这种情况下，该值将设置为0.使用以下语法声明和初始化具有不同值的变量：

这里变量自动指定为int。我们可以使用变量声明的简写定义：

我们还可以在同一行中声明多个变量：

<h2>数据类型</h2>

与任何其他编程语言一样，Golang支持各种不同的数据结构。让我们探讨一下：

<h3>NUMBER, STRING, AND BOOLEAN</h3>

一些INT类型的有int，int8，int16，int32，int64， uint，uint8，uint16，uint32，uint64，uintptr ......

字符串类型存储一系列字节。它用关键字<code>string</code>表示和声明。

使用关键字<code>bool</code>存储布尔类型。

Golang还支持复杂的数字类型数据类型，可以用<code>complex64</code>和<code>complex128</code>。

<h3>ARRAYS, SLICES, AND MAPS</h3>

数组是相同数据类型的元素序列。数组具有在声明中定义的固定长度，因此不能进行扩展。数组声明为：

数组也可以是多维的。我们可以使用以下格式创建它们：

当数组的值在运行时更改时，数组限制了这种情况。数组也不提供获取子数组的能力。为此，Golang有一个名为slices的数据类型。

切片存储一系列元素，可以随时扩展。切片声明类似于数组声明 - 没有定义容量：

这将创建一个零容量和零长度的切片。切片也可以定义容量和长度。我们可以使用以下语法：

这里，切片的初始长度为5，容量为10。

切片是数组的抽象。切片使用数组作为底层结构。切片包含三个组件：容量，长度和指向底层数组的指针，如下图所示：

通过使用append或copy函数可以增加切片的容量。append函数可以为数组的末尾增加值，并在需要时增加容量。

增加切片容量的另一种方法是使用复制功能。只需创建另一个具有更大容量的切片，并将原始切片复制到新创建的切片：

我们可以创建切片的子切片。这可以使用以下命令完成：

var m map[string]int

package main

import ( "fmt" )

func main() { m := make(map[string]int) // adding key/value m["clearity"] = 2 m["simplicity"] = 3 // printing the values fmt.Println(m["clearity"]) // -> 2 fmt.Println(m["simplicity"]) // -> 3 } ```

<h2>类型转换</h2>

可以使用类型转换将一种类型的数据类型转换为另一种类型。我们来看一个简单的类型转换：

package main

import ( "fmt" )

func increment(i <i>int) { </i>i }

func main() { i := 2 switch i { case 1: fmt.Println("one") case 2: fmt.Println("two") default: fmt.Println("none") } }

package main

import ( "fmt" )

func increment(i <i>int) { </i>i }

func main() { i := 2 switch i { case 1: fmt.Println("one") case 2: fmt.Println("two") default: fmt.Println("none") } }

package main

import ( "fmt" )

func increment(i <i>int) { </i>i }

func main() { i := 0 sum := 0 for i < 10 { sum = 1 i } fmt.Println(sum) }

package main

import ( "fmt" )

func increment(i <i>int) { </i>i }

func main() { sum := 0 for i := 0; i < 10; i { sum = i } fmt.Println(sum) }

for { }

var ap * int

a := 12 ap =＆a

fmt.Println（* AP） // => 12

package main

import ( "fmt" )

func increment(i <i>int) { </i>i }

func main() { i := 10 increment(&i) fmt.Println(i) }

//=> 11

package main

import ( "fmt" )

func add(a int, b int) int { c := a b return c }

func main() { fmt.Println(add(2, 1)) } //=> 3

这里c被定义为返回变量。因此，定义的变量c将自动返回，而无需在结尾的return语句中定义。

您还可以从一个函数返回多个返回值，将返回值与逗号分隔开。

<h2>方法，结构和接口</h2>

Golang不是一个完全面向对象的语言，但是有结构体，接口和方法，来支持面向对象的开发。

<h3>结构体</h3>

结构体是不同字段的类型集合。结构体用于将数据分组在一起。例如，如果我们想要对Person类型的数据进行分组，我们会定义一个人的属性，其中可能包括姓名，年龄，性别。可以使用以下语法定义结构：

在定义了人类型结构体的情况下，现在让我们创建一个人：

我们可以用点（.）轻松访问这些数据

您还可以使用其指针直接访问结构的属性：

<h3>方法</h3>

方法是具有接收器的特殊类型的函数。接收器既可以是值，也可以是指针。让我们创建一个名为describe的方法，它是我们上面的例子中<code>person</code>结构体的一个方法：

正如我们在上面的例子中所看到的，现在可以使用点运算符调用该方法 <code>pp.describe</code>。请注意，接收器是指针。使用指针，我们传递对该值的引用，因此如果我们对方法进行任何更改，它将反映在接收器<code>pp</code>中。它也不会创建对象的新副本，从而节省了内存。

请注意，在上面的示例中，age的值已更改，而name的值未更改，因为方法setName属于接收器类型，而setAge属于指针类型。

<h3>接口</h3>

Golang接口是方法的集合。接口有助于将类型的属性组合在一起。我们以动物接口为例：

这里的animal是接口类型。现在让我们创建两种不同类型的animal来实现animal接口：

在main函数中，我们创建了一个<code>a</code>类型为<code>animal</code>的变量。我们为animal分配snake和cat类型，并使用Println打印a.description。由于我们以不同的方式实现了两种类型（猫和蛇）中描述的方法，我们得到了不同animal的描述。

<h2>包</h2>

我们在一个包中写入Golang中的所有代码。该主包是程序执行的入口点。Go中有很多内置包。我们一直使用的最多的是fmt包。

<blockquote> “Go packages in the main mechanism for programming in the large that go provides and they make possible to divvy up a large project into smaller pieces.”
— Robert Griesemer </blockquote> <h3>安装一个包</h3>

我们安装的软件包保存在GOPATH中，这是我们的工作目录。您可以通过我们的工作目录中的pkg文件夹进入包 <code>cd $GOPATH/pkg</code>。

<h3>创建自定义包</h3>

让我们从创建一个文件夹custom_package开始：

要创建自定义包，我们需要首先使用我们需要的包名创建一个文件夹。假设我们正在构建一个包 <code>person</code>。为此，我们创建一个名为<code>person</code>的文件夹在<code>custom_package</code>文件夹中：

现在让我们在这个文件夹中创建一个文件person.go。

<blockquote> go install </blockquote>

package main

import ( "custom_package/person" "fmt" )

func main() { p := person.Description("Milap") fmt.Println(p) }

// => The person name is: Milap

godoc person Description

godoc -http =“：8080”

package main

import ( "encoding/json" "fmt" )

func main() { mapA := map[string]int{"apple": 5, "lettuce": 7} mapB, _ := json.Marshal(mapA) fmt.Println(string(mapB)) }

package main

import ( "encoding/json" "fmt" )

type response struct { PageNumber int json:"page" Fruits []string json:"fruits" }

func main() { str := {"page": 1, "fruits": ["apple", "peach"]} res := response{} json.Unmarshal([]byte(str), &res) fmt.Println(res.PageNumber) }

//=> 1

resp, err := http.Get("http://example.com/")

package main

import ( "fmt" "net/http" )

func main() { resp, err := http.Get("http://example.com/") if err != nil { fmt.Println(err) return } fmt.Println(resp) }

package main

import ( "errors" "fmt" )

func Increment(n int) (int, error) { if n < 0 { // return error object return 0, errors.New("math: cannot process negative number") } return (n 1), nil }

func main() { num := 5 if inc, err := Increment(num); err != nil { fmt.Printf("Failed Number: %v, error message: %v", num, err) } else { fmt.Printf("Incremented Number: %v", inc) } }

// => The person name is: Milap

<h3>defer</h3>

Defer总是在函数结束时执行。

在上面的例子中，我们使用panic()来恐慌地执行程序。正如您所注意到的，有一个延迟语句，它将使程序在程序执行结束时执行该行。当我们需要在函数结束时执行某些操作时，也可以使用Defer，例如关闭文件。

<h2>并发</h2>

Golang在构建时考虑了并发性。Golang中的并发可以通过轻量级线程的Go例程来实现。

<h3>Go routine</h3>

Goroutine是可以与另一个函数并行或同时运行的函数。创建Goroutine非常简单。只需在函数前面添加关键字Go，我们就可以使它并行执行。Go协程非常轻量级，因此我们可以创建数千个例程。让我们看一个简单的例子：

正如您在上面的示例中所看到的，函数c是一个Goroutine，它与主Go线程并行执行。有时我们希望在多个线程之间共享资源。Golang不喜欢将一个线程的变量与另一个线程共享，因为这会增加死锁和资源等待的可能性。还有另一种在Goroutine之间共享资源的方法：channels。

<h3>通道</h3>

我们可以使用通道在两个Goroutine之间传递数据。在创通道时，必须指定通道接收的数据类型。让我们创建一个字符串类型的简单通道，如下所示：

使用这个通道，我们可以发送字符串类型数据。我们都可以在此通道中发送和接收数据：

<h3>单向通道</h3>

在某些情况下，我们希望Goroutine通过通道接收数据但不发送数据，反之亦然。为此，我们还可以创建单向通道。让我们看一个简单的例子：

在上面的示例中,<code>sc</code>是一个Goroutine，它只能向通道发送消息但不能接收消息。

<h3>使用select为Goroutine处理多个通道</h3>

在一个函数中可能有多个通道正在等待。为此，我们可以使用<code>select</code>语句。让我们看一个更清晰的例子：

在上面的示例中，main正在等待两个通道c1和c2。使用select case语句打印主函数，消息从通道中发送，无论它先收到哪个。

<h3>缓冲通道</h3>

您可以在Golang中创建缓冲通道。使用缓冲通道，如果缓冲区已满，则将阻止发送到通道的消息。我们来看看这个例子：

<h2>为什么GOLANG成功了？</h2> <blockquote> Simplicity… — Rob-pike </blockquote> <h2>Great!</h2>

我们了解了Golang的一些主要组件和功能。

<ol><li>变量，数据类型</li><li>数组切片和Map</li><li>函数</li><li>循环和条件语句</li><li>指针</li><li>包</li><li>方法，结构和接口</li><li>错误处理</li><li>并发-Goroutines和channels</li></ol>

恭喜你，你现在对Go有了不错的认识。

<blockquote> One of my most productive days was throwing away 1,000 lines of code. --Ken Thompson </blockquote>

不要停在这里。继续前进。考虑一个小应用程序并开始构建。