编程语言

Golang快速上手笔记

从一个main函数初见go的语法

package main //程序包名

//import "fmt"
import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Hello World")
    time.Sleep(5 * time.Second)

}

  • 第一行代码package main定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

  • 下一行import "fmt"告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

  • 下一行func main()是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）

变量的声明

变量的声明有以下几种

//声明变量 默认的值为0
var a int = 10
fmt.Println("a =", a)
//在初始化时，可以省去数据类型，通过值自动匹配类型
var b = 20
fmt.Println("b =", b)
//省去var关键字 不能用于全局变量
e := 50
fmt.Println("e =", e)

常量与枚举

const关键字用于定义常量

const length = 50

还可以用作枚举

const (
    Beijing= 0
    Shanghai= 1
    Dongying= 2
)

iota标识符

iota能够实现常量的数字自增

函数

go语言的函数有多种写法

func foo1(a string, b string) int {
    fmt.Println("a= " + a)
    fmt.Println("b=", b)

    c := 10
    return c
}

还可以返回多个变量

func foo2(a string, b int) (int, int) {
    fmt.Println("a= ", a)
    fmt.Println("b= ", b)
    return 66, 77
}
func foo3(a string, b int) (r1 int, r2 int) {
    fmt.Println("a= ", a)
    fmt.Println("b= ", b)
    r1 = 9
    r2 = 2
    return
}

go里面有两个保留的函数：init函数（能够应用于所有的package）和main函数（只能应用于package main）。这两个函数在定义时不能有任何的参数和返回值。

等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。下面是一个例子

package lib1

func LibTest() {
    println("lib1 test")
}
func init() {
    println("lib1 init")
}
package lib2

import "fmt"

func Lib2Test() {
    fmt.Println("lib2")
}
func init() {
    fmt.Println("lib2 init")

}

接下来在main.go中调用lib1与lib2

package main

import (
    "StudyGo/init/lib1"
    "StudyGo/init/lib2"
)

func main() {
    lib2.Lib2Test()
    lib1.LibTest()

}

能够观察到如下情况：

defer语句

defer语句被用于预定对一个函数的调用。可以把这类被defer语句调用的函数称为延迟函数。

如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。

package main
import "fmt"
func func1() {
    defer fmt.Println("func1 end")
}
func func2() {
    defer fmt.Println("func2 end")

}

func func3() {
    defer fmt.Println("func3 end")

}
func main() {
    defer func1()
    defer func2()
    defer func3()
}

可以观察到以下的输出结果

slice和map

slice

slice其实就是数组，我们可以通过以下几种办法来创建切片

var Array1 [5]int

Array2 := [10]int{1, 2, 3, 4}

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

func main() {
    var numbers = make([]int,3,5)
    printSlice(numbers)
}
func printSlice(x []int){
    fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。

package main


import "fmt"


func main() {
   var numbers []int
   printSlice(numbers)


   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)


   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)


   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)


   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)


   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

map

你可以通过以下几种办法声明一个map

	var map1 map[string]string
	map1 = make(map[string]string, 10)
	map1["1"] = "chen"
	map1["2"] = "na"
	map1["3"] = "dw"

	map2 := make(map[int]string)
	map2[1] = "java"
	map2[2] = "python"

	map3 := map[string]string{
		"1": "chen",
		"2": "na",
		"3": "dw",
	}

通过以下代码可以遍历整个map

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

删除一个元素

delete(map3, "1")

Comment