美文网首页
Go 语言入门

Go 语言入门

作者: Gundy_ | 来源:发表于2019-07-19 15:33 被阅读0次

    原文https://milapneupane.com.np/2019/07/06/learning-golang-from-zero-to-hero/

    image

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

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

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

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

    image
    最近发布的golang新标识：https：//blog.golang.org/go-brand

    入门

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

    package main

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

    工作区

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

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

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

    # export env
export GOPATH=~/workspace
# go inside the workspace directory
cd ~/workspace

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

    HELLO WORLD!

     package main

 import (
     "fmt"
 )

 func main() {
     fmt.Println("Hello World!")
 }

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

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

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

    > go build main.go

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

    > ./main 
# Hello World!

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

    变量

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

    var a int

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

    var a = 1

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

    message := "hello world"

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

    var b，c int = 2,3

    数据类型

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

    NUMBER, STRING, AND BOOLEAN

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

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

    使用关键字bool存储布尔类型。

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

    var a bool = true
var b int = 1
var c string = "hello world"
var d float32 = 1.222
var x complex128 = cmplx.Sqrt(-5 + 12i)

    ARRAYS, SLICES, AND MAPS

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

    var a [5] int

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

    var multiD [2] [3] int

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

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

    var b [] int

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

    numbers：= make（[] int，5,10）

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

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

    image

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

    numbers = append(numbers, 1, 2, 3, 4)

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

    // create a new slice
number2 := make([]int, 15)
// copy the original slice to new slice
copy(number2, number)

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

     package main

 import (
     "fmt"
 )

 func main() {
     // initialize a slice with 4 len and values
     number2 := []int{1, 2, 3, 4}
     fmt.Println(number2) // -> [1 2 3 4]
     // create sub slices
     slice1 := number2[2:]
     fmt.Println(slice1) // -> [3 4]
     slice2 := number2[:3]
     fmt.Println(slice2) // -> [1 2 3]
     slice3 := number2[1:4]
     fmt.Println(slice3) // -> [2 3 4]
 }

    Map是Go中的数据类型，它将键映射到值。我们可以使用以下命令定义映射：

    var m map[string]int

    这 m 是新的map变量，其键是string，值是integers。我们可以轻松地将键和值添加到地map中：

    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
 }

    类型转换

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

     package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

 func main() {
     a := 1.1
     b := int(a)
     fmt.Println(b)
     //-> 1
 }

    并非所有类型的数据类型都可以转换为其他类型。要确保数据类型与转换兼容。

    条件语句

    IF ELSE

    对于条件语句，我们可以使用if-else语句，如下例所示。确保花括号与条件位于同一行。

     package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

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

    SWITCH CASE

    Switch cases 有助于组织多个条件语句. 以下示例显示了一个简单的switch case语句：

     package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

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

    Looping

    Golang有一个循环关键字。单个for循环命令有助于实现不同类型的循环：

     package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

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

    上面的示例类似于C中的while循环。对于for循环，可以使用相同的for语句：

     package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

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

    Go中的无限循环：

    for {
}

    指针

    Golang提供了指针。指针是保存值的地址的地方。指针由*定义。根据数据类型定义指针。例：

    var ap * int

    这ap是指向整数类型的指针。该&操作可用于获取变量的地址。

    a := 12
ap =＆a

    可以使用 *运算符访问指针指向的值 ：

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

    在将结构体作为参数传递或者为已定义类型声明方法时，通常首选指针。

    • 传递值时，实际复制的值意味着更多的内存
    • 传递指针后，函数更改的值将反映在方法/函数调用者中。

    例：

    package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

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

 //=> 11

    注意：在文中运行示例代码时，不要忘记将其包含在main包中，并在需要时导入fmt或其他包，如上面第一个main.go示例所示。

    函数

    main包中定义的main函数是golang程序执行的入口点。可以定义和使用更多的函数。让我们看一个简单的例子：

     package main

 import (
     "fmt"
 )

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

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

    正如我们在上面的例子中所看到的，使用func关键字后跟函数名来定义Golang函数。函数所需的参数需要根据其数据类型定义，最后是返回的数据类型。

    函数的返回值也可以在函数中预定义：

    package main

 import (
     "fmt"
 )

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

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

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

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

    package main

 import (
     "fmt"
 )

 func add(a int, b int) (int, string) {
     c := a + b
     return c, "successfully added"
 }

 func main() {
     sum, message := add(2, 1)
     fmt.Println(message)
     fmt.Println(sum)
 }

 //=> successfully added
 //=> 3

    方法，结构和接口

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

    结构体

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

    type person struct {
     名字串
     年龄int
     性别串
 }

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

    //way 1: specifying attribute and value
p = person{name: "Bob", age: 42, gender: "Male"}
//way 2: specifying only value
person{"Bob", 42, "Male"}

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

    p.name
//=> Bob
p.age
//=> 42
p.gender
//=> Male

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

    pp = &person{name: "Bob", age: 42, gender: "Male"}
pp.name
//=> Bob

    方法

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

    package main

 import "fmt"

 // struct defination
 type person struct {
     name   string
     age    int
     gender string
 }

 // method defination
 func (p *person) describe() {
     fmt.Printf("%v is %v years old.", p.name, p.age)
 }

 func (p *person) setAge(age int) {
     p.age = age
 }

 func (p person) setName(name string) {
     p.name = name
 }

 func main() {
     pp := &person{name: "Bob", age: 42, gender: "Male"}
     pp.describe()
     // => Bob is 42 years old
     pp.setAge(45)
     fmt.Println(pp.age)
     //=> 45
     pp.setName("Hari")
     fmt.Println(pp.name)
     //=> Bob
 }

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

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

    接口

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

     type animal interface {
     description() string
 }

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

    package main

 import (
     "fmt"
 )

 type animal interface {
     description() string
 }

 type cat struct {
     Type  string
     Sound string
 }

 type snake struct {
     Type      string
     Poisonous bool
 }

 func (s snake) description() string {
     return fmt.Sprintf("Poisonous: %v", s.Poisonous)
 }

 func (c cat) description() string {
     return fmt.Sprintf("Sound: %v", c.Sound)
 }

 func main() {
     var a animal
     a = snake{Poisonous: true}
     fmt.Println(a.description())
     a = cat{Sound: "Meow!!!"}
     fmt.Println(a.description())
 }

 //=> Poisonous: true
 //=> Sound: Meow!!!

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

    包

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

    “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

    安装一个包

    go get 
// example
go get github.com/satori/go.uuid

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

    创建自定义包

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

    > mkdir custom_package
> cd custom_package

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

    > mkdir person
> cd person

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

    package person

 func Description(name string) string {
     return "The person name is: " + name
 }

 func secretName(name string) string {
     return "Do not share"
 }

    我们现在现在需要安装包，以便可以导入和使用它。所以让我们安装它：

    > go install

    现在让我们回到custom_package文件夹并创建一个main.go文件

     package main

 import (
     "custom_package/person"
     "fmt"
 )

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

 // => The person name is: Milap

    现在我们可以导入我们创建的person包,并使用函数Description。请注意，secretName 我们在包中创建的函数将无法访问。在Go中，以小写字母开头的方法名称将是私有的。

    包文档

    Golang内置了对包文档的支持。运行以下命令以生成文档：

    godoc person Description

    这将为我们的包开发人员生成Description函数的文档。要查看文档，请使用以下命令运行Web服务器：

    godoc -http =“：8080”

    现在打开URLhttp//localhost8080/pkg/ 并查看我们刚创建的包的文档。

    GO中的一些内置包

    FMT

    该包实现了格式化的I / O功能。我们已经使用该包打印到stdout。

    JSON

    Golang中另一个有用的包是json包。这有助于编码/解码JSON。让我们举一个例子来编码/解码一些json：

    encode

    package main

 import (
     "encoding/json"
     "fmt"
 )

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

    Decode

    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

    在使用unmarshal解码json字节时，第一个参数是json字节，第二个参数是我们希望json映射到的响应类型struct的地址。请注意， json:”page” 映射页面键是结构体中的PageNumber键。

    错误处理

    错误是程序的不希望的和意外的结果。假设我们正在对外部服务进行API调用。此API调用可能成功或可能失败。当存在错误类型时，可以识别Golang程序中的错误。我们来看看这个例子：

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

    这里的err表示API调用可能会通过或可能失败。我们可以检查错误是否为nil，并相应地处理响应：

     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)
 }

    函数返回自定义错误

    当我们编写自己的函数时，有些情况下我们会遇到错误。可以通过errors来返回这些错误：

      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

    在Go中构建的大多数软件包或我们使用的外部软件包都有一个错误处理机制。所以我们调用的任何函数都可能存在错误。这些错误永远不应该被忽略，并且总是在我们称之为函数的地方优雅地处理，就像我们在上面的例子中所做的那样。

    panic

    panic是一种未经处理的错误，在程序执行期间突然遇到。在Go中，panic不是处理程序中异常的理想方式。建议使用错误对象。发生panic时，程序执行停止。panic之后执行的事情就是defer。

    package main

import "fmt"

func main() {
 f()
 fmt.Println("Returned normally from f.")
}

func f() {
 defer func() {
     if r := recover(); r != nil {
         fmt.Println("Recovered in f", r)
     }
 }()
 fmt.Println("Calling g.")
 g(0)
 fmt.Println("Returned normally from g.")
}

func g(i int) {
 if i > 3 {
     fmt.Println("Panicking!")
     panic(fmt.Sprintf("%v", i))
 }
 defer fmt.Println("Defer in g", i)
 fmt.Println("Printing in g", i)
 g(i + 1)
}

    defer

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

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

    并发

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

    Go routine

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

    package main

 import (
     "fmt"
     "time"
 )

 func main() {
     go c()
     fmt.Println("I am main")
     time.Sleep(time.Second * 2)
 }

 func c() {
     time.Sleep(time.Second * 2)
     fmt.Println("I am concurrent")
 }

 //=> I am main
 //=> I am concurrent

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

    通道

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

    c := make(chan string)

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

    package main

 import "fmt"

 func main() {
     c := make(chan string)
     go func() { c <- "hello" }()
     msg := <-c
     fmt.Println(msg)
 }

 //=>"hello"接收方通道等待发送方向通道发送数据。

    单向通道

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

     package main

 import (
     "fmt"
 )

 func main() {
     ch := make(chan string)
     go sc(ch)
     fmt.Println(<-ch)
 }

 func sc(ch chan<- string) {
     ch <- "hello"
 }

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

    使用select为Goroutine处理多个通道

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

     package main

 import (
     "fmt"
     "time"
 )

 func main() {
     c1 := make(chan string)
     c2 := make(chan string)
     go speed1(c1)
     go speed2(c2)
     fmt.Println("The first to arrive is:")
     select {
     case s1 := <-c1:
         fmt.Println(s1)
     case s2 := <-c2:
         fmt.Println(s2)
     }
 }

 func speed1(ch chan string) {
     time.Sleep(2 * time.Second)
     ch <- "speed 1"
 }

 func speed2(ch chan string) {
     time.Sleep(1 * time.Second)
     ch <- "speed 2"
 }

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

    缓冲通道

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

    package main

 import "fmt"

 func main() {
     ch := make(chan string, 2)
     ch <- "hello"
     ch <- "world"
     ch <- "!" // extra message in buffer
     fmt.Println(<-ch)
 }

 // => fatal error: all goroutines are asleep - deadlock!

    为什么GOLANG成功了？

    Simplicity… — Rob-pike

    Great!

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

    1. 变量，数据类型
    2. 数组切片和Map
    3. 函数
    4. 循环和条件语句
    5. 指针
    6. 包
    7. 方法，结构和接口
    8. 错误处理
    9. 并发-Goroutines和channels

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

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

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

    相关文章

      网友评论

          本文标题：Go 语言入门

          本文链接：https://www.haomeiwen.com/subject/azhslctx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Go 语言入门|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！