Bootstrap
侧边栏



gohello world

go第一个程序

package main

import "fmt"

func main() {
    fmt.Println("Hello world.")
}

输入结果

Hello world.

gomap(映射)

gomap 定义

package main

import "fmt"

func main() {
    m1 := make(map[string]string)
    m1["name"] = "tom"
    m1["age"] = "20"
    m1["email"] = "tom@gmail.com"

    fmt.Printf("%v\n", m1)

    m2 := map[string]string{
        "name": "kite",
        "age": "20",
        "email": "kite@gmail.com",
    }

    fmt.Printf("%v\n", m2)
}

访问gomap

通过map的下标访问map的值

package main

import "fmt"

func main() {
    m1 := make(map[string]string)

    m1["name"] = "tom"
    m1["age"] = "20"
    m1["email"] = "tom@gmail.com"

    name := m1["name"]
    age := m1["age"]
    email := m1["email"]

    fmt.Printf("%v\n", name)
    fmt.Printf("%v\n", age)
    fmt.Printf("%v\n", email)
}

运行结果:

tom
20
tom@gmail.com
    

检测键是否在gomap中

package main

import "fmt"

func main() {
    m1 := make(map[string]string)
    m1["name"] = "tom"
    m1["age"] = "20"
    m1["email"] = "tom@gmail.com"

    key1 := "name"
    key2 := "age1"

    v, ok := m1[key1]
    fmt.Printf("%v\n", v)
    fmt.Printf("%v\n", ok)

    fmt.Println("---------")

    v2, ok2 := m1[key2]
    fmt.Printf("%v\n", v2)
    fmt.Printf("%v\n", ok2)
}

运行结果:

tom
true
---------

false

go遍历map

一般使用for range循环对map进行遍历

package main

import "fmt"

func main() {
    m1 := make(map[string]string)
    m1["name"] = "Bob"
    m1["age"] = "30"
    m1["email"] = "bob@qq.com"

    for k, v := range m1 {
        fmt.Printf("%v %v\n", k, v)
    }
}

结果

name Bob
age 30
email bob@qq.com

Go 函数

函数的分类

函数可以分为:
  • 有名函数
  • 匿名函数

Go函数返回值

go函数的返回值可以:

  • 无返回值
  • 有一个返回值
  • 有多个返回值
  • 函数无返回值

通常打印类语句就不用返回值啦

package main

import "fmt"

func f() {
    fmt.Println("I like go.")
}

func main() {
    f()
}
  • 函数有一个返回值

返回值直接在return语句中指定

package main

import "fmt"

func sum(a int, b int) (ret int) {
    ret = a+b
    return ret
}
func main() {
    r := sum(10, 20)
    fmt.Printf("%v\n", r)
}
  • 有2个返回值,值在return语句中指定

大多数编程语句都是这样的返回方式

package main

import "fmt"

func f2() (name string, age int) {
    name = "nick"
    age = 20
    return name, age
}

func main() {
    name, age := f2()
    fmt.Println(name, age)
}
  • 函数有2个返回值

返回值没有在return语句中指定

package main

import "fmt"

func f2() (name string, age int) {
    name = "Bob"
    age = 20
    return
}

func main() {
    name, age := f2()
    fmt.Println(name, age)
}
  • return覆盖命名返回值

返回值名称没有被使用

这点也与许多编程语言不同

package main

import "fmt"

func f2() (name string, age int) {
    game := "mc"
    num := 3
    return game, num
}

func main() {
    game, num := f2()
    fmt.Println(game, num)
}

虽然返回值覆盖了,但类型还是必须要一一对应的。

一般不这么做,因为定义的值就没有意义了

  • 只定义类型,不定义值

定义时,不定义返回值,只定义类型

返回时才指定返回值

package main
package main

import "fmt"

func f2() (string, int) {
    game := "mc"
    num := 3
    return game, num
}

func main() {
    game, num := f2()
    fmt.Println(game, num)
}

这种方式很灵活,用得很多

Go函数类型

go是静态强类型高级语言,函数也是有类型的

函数的参数,函数的返回值,都是函数类型的一部分

查看函数类型

查看函数类型可以使用 %T

package main

import "fmt"

func get() string {
    name := "tom"
    return name
}

func main()  {
    fmt.Printf("%T\n",get) // get是函数名
}

注意:查看函数的类型时,不要带()

带()的函数,表示执行函数

运行结果:

func() string

没错,func() string就是一个类型

列举一些函数类型:

  • func() - 无参数,无返回值
  • func(int) string - 参数为int型,返回值为string
  • func(int, int) (string, string) - 2个参数,2个返回值
  • func(func()) - 参数是一个函数func()
  • func(func()) func() - 参数是一个函数,返回值也是一个函数

函数类型可以根据需要自由定义

再次注意:函数的参数,函数参数的个数,函数的返回值,函数返回值的个数,都是函数类型的一部分


                        


                


                


                


                


                


                


                


                


                


                


                


                


                


                


                


                

Go相关资源

相关资源
B站 油管 CSDN 博客中国

更新记录

更新记录
时间 位置 内容
go 增加go教程