一篇有关Golang的简短文章，面向新开发者或那些不花很多时间研究该语言的人，并且希望对其进行简短，简洁，深思熟虑的原始介绍。 编写的所有代码都在一个repl中。

Go真的很酷，根据Stack Overflows 2017数据集，这是最赚钱的技术。 Go开发人员的平均年薪约为110k ： 此链接就在这里！

（侧边栏上的技术->顶部付费技术以进行验证）

但这只是学习Go的一部分原因。 主要原因是： 学习它只会加快您对基本计算机科学主题的理解。 为什么？ 好吧， Golang是一种经过深思熟虑的现代语言，它利用了之前创建的许多编程语言的最佳实践。

这也是Google制作的一种语言，用于处理几乎每个人都在使用的海量数据和与处理其搜索引擎相关的问题。

另一方面，要全面学习Go，就是要学习如何构建可为低级问题提供答案的软件。 换句话说，它是为其他软件提供服务的软件。 从某种意义上讲，如果您了解Golang，那么您就会知道如何构建与该字段的内容相关的程序。

让我们深入研究一些代码。 故事是这样开始的：

现在是这次，就像在2018年一样。但是突然之间，时间跳了……提前了240年。 仿佛您一直都在被奥斯汀·鲍尔斯冻结。 突然间拯救宇宙取决于你。 在结尾处加捻。

我写了一段大约150行的代码，完整地讲了一个很短的故事（很多印刷品），我将在结尾处写。 我将从头到尾仔细阅读代码。 从简单开始，然后变得有点密集。

package main

import ( "fmt" "time" "strconv" "io" "strings")

包主 ？ 所有Go源代码都是软件包的一部分，每个文件都需要一个package语句。 package main是运行代码的文件。 其他软件包文件是导入到软件包main中的模块。 这些模块是可重用的代码段，可在package main使用或实现。

因此，导入的模块包含我将在此文件中使用的源代码。

type Aliens struct {  species int}

type NotEarthling struct {  total int  century string  thingamajig string}

type Earthling struct {  total int  century string  name string  age int64}

type WordSpaceship struct {  health string  weapon string}

type NumberSpaceship struct {  health int  weapon int}

具有不同用法的多个结构。

什么是结构 ？ 这是创建对象的方式，每个值可以具有不同的类型。 关键是所写的单词，一个字符串。 虽然，每个键必须具有指定的类型，但它不是动态的。

创建对象的另一种主要方法是使用地图 。 但是，在这种情况下，每个键和值都必须是单一类型：

• make（map [string] int）所有键必须是字符串，所有值必须是int

因此，在映射中，每个键必须是一种类型，而每个值都必须是一种类型。 在结构中，每个值都可以使用不同的类型。

var you = Earthling{century: "21st", name: "you", age: 24}

func main() {    defer fmt.Println("Is this all a dream?")

    now := time.Now()    nanos := now.UnixNano()    fmt.Printf("Right now it is: %v! \nPop! AHHHHH\n\n", now)

变量声明发生在全局范围内，因此必须使用var关键字进行初始化。 这是初始化结构的一种方法 。 注意，我指定了键并将其值设置为结构定义中编写的相应类型。 请注意，我还没有初始化每个键/值（您不需要）。

推迟 ？ 这将创建一个函数调用的后进先出堆栈，以在func main() {...}完成后调用。 我说一个称为defer的堆栈可以被多次调用，每次调用它时，被压入堆栈的最后一个函数将被首先调用。

：=，这是什么？ 也就是说，编译器将动态确定类型。 与之类似，以这种方式将值初始化为变量时，无需指定类型，这是唯一的方式。

time.Now（）返回此值：2017–12–28 01：41：05.240081928 +0000 UTC

now.UnixNano（）返回此值：1514425756675856179，这是自8年前创建Golang以来发生的纳秒数。

Printf允许以各种形式注销值：

％v给出默认值

％T给出值的类型

是两种主要形式。

仍在下面的功能主体中。

    nanos = nanos + 7600000000000000000

    years := (nanos - now.UnixNano())/1000000000/31622400

    now = time.Unix(0, nanos)

    fmt.Printf("And now it is: %v!\nOh hell!\n\n", now)

在开始的时候，未来大约240年就是76000000000000000000纳秒。

years是一种计算，请转换为秒，然后转换为年。

time.Unix（seconds，nano seconds）会将纳秒转换为：2258–10–29 00：55：56.675856179 +0000 UTC

    var e []Earthling    var ne []NotEarthling

    for i := 0; i < 70000; i++ {        e = append(e, Earthling{})    }

    for i := 0; i < 44; i++ {        ne = append(ne, NotEarthling{})    }

    aliens := Aliens{2}

    futureEarthling := Earthling{len(e), "22nd", "The Future", 32141}

    futureNotEarthling := NotEarthling{len(ne), "99th", "Grok grok grok"}

var关键字调用设置了一个只能用指定类型填充的零值数组（空数组）。 不能将整数，字符串等添加到此数组。

在以下for循环中 ，我将指定类型的空结构附加到数组。

在这种情况下，只有两种外来物种。 地球与非 地球 。

请注意，如何将FutureEarthling设置为结构Earthlings而不指定键，这是一种简写，只要您将值按struct中定义的相应顺序放置，在这种情况下： {int，string，string，int64} ，然后可以用这种方式填写字段。

现在，每个Earthling对象都有一个名为Greet的函数……让我们检查一下单独的函数，而不是main函数。

func (e *Earthling) Greet(y int64) string {

    century, _ := strconv.ParseInt(e.century[0:2], 0, 64)

    if century > 21 && century < 30 {

      age := strconv.FormatInt(you.age, 10)

      str := "Welcome to the future young Padawan, you are in the: " + e.century + " century. And I am: " + e.name + ". You are now... " + age + "years old. The world is under attack, and you have been revived to defend it! Big scary invader has something to say..."

      return str

    } else {      e.age = e.age + y      return "Where am I???"    }}

好的，所以这对应于此人正在经历的生存危机，它已经唤醒了很远的未来，还有一个随机的未来家伙有话要说！

嗯…看顶部： （e * Earthling） 。 这是什么？ 好吧， e将成为调用该方法的Earthling对象的实例。 和* ？ 这是一个指针 。 我邀请您打开下面的副本，将其删除*，然后看看会发生什么。

这意味着什么： you.Greet（year） 正在创建 you 的副本， 除非您指向它的内存地址 。 如果不这样做，什么你做you将不会改变主函数中的对象。 指针确保可以更改对象。

在此代码段中，我们还有一个新库…… strconv 。 这是您要将int更改为字符串（反之亦然）或许多其他类型时使用的库。 Go有很多数据类型……int，int8，int16，int32，int64。 我命名的全部就是int，换句话说，一个人可以继续……键入galore。

如果仔细观察，我使用指针的全部原因是为了改变年轻的帕达万的年龄。

numberShip := NumberSpaceship{100, 3}wordShip := WordSpaceship{"Read this to defeat me.", "Powerful words!"}

wordAttack := make(chan int)finished := make(chan int)

go func() {    for {        numberShip.health = numberShip.health - <-wordAttack        if numberShip.health <= 0 {            Extinction(&aliens)            finished <- 0        }    }}()

fmt.Println(Fight(&numberShip, &wordShip, wordAttack, finished))

好的，首先，两个结构的第一个参数是它们的健康状况。 因此，对于数字船来说 ，健康是100，对于词船来说 ，健康是一个句子…… "Read this to defeat me" ……？ 我将在底部的功能Fight中使用该功能，该功能使用所谓的Reader 。

make（chan int）创建所谓的通道。 发送/接收值的管道。 发送是这样的： <-wordAttack ，接收是： 完成的<-0 。

go func（）{…}（）是goroutine的创建。 当同时使用通道和goroutine时，要记住的主要一点是， 只要通道向其发送值 ，goroutine就会继续。 因此，让我们检查一下从何处获取其值，即Fight函数。

func Fight(ns *NumberSpaceship, ws *WordSpaceship, c, f chan int) string {    x := len(ws.weapon)    r := strings.NewReader(ws.health)    b := make([]byte, ns.weapon)    for {        select {            case c <- x:                fmt.Println("Hit it!")            case <-f:                fmt.Println("He's finished!")                return "\nYou saved time, space, eternity, everything!\n"        }        _, err := r.Read(b)        if err == io.EOF {            return "You failed, the universe is to end."        }    }}

首先，检查功能签名。 通过引用变量的内存地址（带有＆ ）来调用该函数。 在签名中，函数需要一个指针 （即引用的变量）作为NumberSpaceship和WordSpaceship的参数。

另外，请检查两个chan ints类型如何仅写入一次。 如果参数类型彼此相邻且具有相同的确切类型，则可以将它们分组。

首先， 字符串库，“实现简单的功能来处理UTF-8编码的字符串”。 在此功能中，将创建一个读取器来读取字符串。

好的，字符串阅读器的实现：

• r：= strings.NewReader（ws.health）返回一个新的Reader ，它将从s中读取： "Read this to defeat me" 。
• b：= make（[] byte，ns.weapon）返回指定长度的字节片。 ws.weapon是值3。
• _，err：= r.Read（b）更细微。 _也可以是变量名，我们称它为n 。 如果n存在，则意味着Read读取的字节数将返回n 。 但是，如果保留原样，则不必使用返回的值。 否则，您必须这样做，也就是说Go不允许使用不声明的变量。 因此，首先， Read返回读取的字节数，其次，当且仅当读取整个字符串时，它才返回错误，在这种情况下，将返回io.EOF （文件末尾）错误。 否则，其值为： <nil> 。
• 因此， r是读者。 b是输入字符串的内容。 读取是调用该函数来实现的功能。

所以，总结了读者 ，为什么它正在使用，一旦串读NumberSpaceship胜和WordSpaceship损失。 战斗非常激烈。

快速说明： 对于{…} ，请执行无限循环，直到函数返回。

至于WordSpaceship的攻击。

• select正在等待通道c和f的多个通信操作。 当准备好发送数据或接收数据时，只要函数不返回，它将继续这样做。
• 假设<-x ，连续将x的值发送到此通道。 然后，回到func main的goroutine，执行以下操作： numberShip.health = numberShip.health — <-wordAttack破坏船。 因此，该通道将清空它刚收到的x。 通道接收值并将其发送到相应的goroutine之后
• case <-f仅在f具有与其关联的值时运行，并且仅在if语句之后的main ： finish <-0中发生时才发生。

那是战斗！ 战斗结束后，无论谁输了，他们的整个物种都灭绝了……这就是它的编写方式，逻辑并没有像实际那样被合并。

type Aliens struct {    species int}

func Extinction(a *Aliens) {    a.species = a.species - 1}

func main() {    aliens := Aliens{2}    Extinction(&aliens)}

相当多的逻辑。

从真实代码中注销的全部内容！

Right now it is: 2017-12-28 21:40:35.066259304 +0000 UTC! Pop! AHHHHH

And now it is: 2258-10-29 20:47:15.066259304 +0000 UTC!Oh hell!

Where am I??? 

Welcome to the future young Padawan, you are in the: 22nd century. And I am: The Future. You are now... 264 years old. The Universe is under attack, and you have been revived to defend it! Big scary invader has something to say... 

Tord thaz geck hild quemp 240! 

He challenged you! You're the chosen one, so you must save the Universe! Jump on this spaceship.

VRRRROOOOOOOOOOOOMMMMMMMM BOOM BOP BOOM BOP

Hit it!Hit it!Hit it!Hit it!Hit it!Hit it!Hit it!He's finished!

You saved time, space, eternity, everything!

AHHH, the aliens left a bomb, the Universe is to disintegrate into nothingness!

Some higher being sort of thing says: There are  0  sentient beings left alive.

Was that all a dream?

和代表：

如果您有兴趣了解更多有关Go，入门文档/练习方面的问题，我强烈建议您这样做！

非常感谢！ 你是最好的！ 高朗先生也有话要说。

From: https://hackernoon.com/golang-the-highest-paying-technology-to-know-9c6089d7081d