分钟级入门 Go 语言，冲！

// 单行注释 /* 多行注释 */ package main // 每一个源文件以包名开始，main 包比较特殊，用于声明一个可执行文件而不是库 import ( // import 语句声明了当前文件引用的包 "fmt" // 一个 Go 语言的标准包 "io/ioutil" // 这个包实现了一些 IO 操作 m "math" // Math 包，别名为 m "net/http" // 网络服务包 "os" // 系统操作函数，比如文件的读写 "strconv" // 字符串转化 ) // 函数定义，main() 函数比较特殊，是整个程序执行的入口。 // 函数使用 {} 包住函数体。 func main() { // 使用 fmt 包提供的函数打印字符串。 fmt.Println("Hello world!") // 调用当前包里的另一个函数。 beyondHello() } // 函数可以在 () 里带参数，如果没有参数，() 也是必须的。 func beyondHello() { var x int // 变量声明，变量在使用之前必须声明 x = 3 // 变量赋值 y := 4 // 短变量声明，编译器自动推断变量的类型 sum, prod := learnMultiple(x, y) // 函数可以有多个返回值 fmt.Println("sum:", sum, "prod:", prod) // 打印字符 learnTypes() // 函数调用 } /* 函数可以带参数，且可以有多个返回值，比如这里的 `x`, `y` 是参数，`sum`, `prod` 是返回值，注意 `sum`, `prod` 的类型是 int。 */ func learnMultiple(x, y int) (sum, prod int) { return x + y, x * y // Return two values. } // 一些内置类型和字面量 func learnTypes() { str := "Learn Go!" // 字符串类型 s2 := `A "raw" string literal can include line breaks.` // 同样是字符串类型 // 非 ASCII 字符，Go 使用 UTF-8 编码 g := 'Σ' // rune 类型，int32 的别称，存储 unicode 码点 f := 3.14195 // float64 c := 3 + 4i // complex128 复数类型 // var 关键字用于变量初始化 var u uint = 7 // Unsigned 无符号整型 var pi float32 = 22. / 7 // float32 类型 // 字符转化 n := byte('\n') // byte 是 uint8 的别名 // 数组的大小在编译是已经确定 var a4 [4]int // 大小为 4 的数组，元素类型为 int，初始值都是 0 a5 := [...]int{3, 1, 5, 10, 100} // 数组大小固定的数组，大小为 5，元素值分别是 3, 1, 5, 10, and 100 // 数组具有值语义 a4_cpy := a4 // a4_cpy 是 a4 的副本 a4_cpy[0] = 25 // 只有 a4_cpy 改变了，a4 保持不变 fmt.Println(a4_cpy[0] == a4[0]) // false // 切片的大小是动态变化的，数组和切片各有优点，但是大多数情况下使用切片比较多 s3 := []int{4, 5, 9} // 与 a5 对比下，s3 没有省略号 s4 := make([]int, 4) // 切片大小为 4，元素类型为 int，初始值都为 0 var d2 [][]float64 // 仅仅是声明，也没有分配内存 bs := []byte("a slice") // 类型转换 // 切片，与 map、channel 一样都是引用语义 s3_cpy := s3 // s3_cpy 和 s3 都指向同一个切片的底层数组 s3_cpy[0] = 0 // 底层数组发生改变 fmt.Println(s3_cpy[0] == s3[0]) // true // 切片的大小是动态的，它的长度可以按需增长 // 可以使用内置函数 append() 向切片的末尾添加元素，第一个参数是待增加的切片 s := []int{1, 2, 3} // s 是大小为 3 的切片 s = append(s, 4, 5, 6) // 增加 3 个元素，切片的大小变为 6 fmt.Println(s) // 更新后的切片变为 [1 2 3 4 5 6] // 除了像上面一样使用元素列表给切片添加元素，使用 ... 操作符给切片添加元素，就像下面这样 s = append(s, []int{7, 8, 9}...) // 第二个参数是切片字面量 fmt.Println(s) // 更新后的切片: [1 2 3 4 5 6 7 8 9] p, q := learnMemory() // p, q 声明为 *int 类型的指针 fmt.Println(*p, *q) // 打印 p、q 指针指向的内存存储的值 // map 是动态可增长关联数组，和其他语言中的 hash 或者字典很相似 m := map[string]int{"three": 3, "four": 4} m["one"] = 1 // Go语言里面，未使用的变量编译的时候是会报错的，但是可以使用下划线 _ 忽略，以免报错 _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs、 // 通常的使用方法是用它来忽略掉函数返回值 // 比如，你可以忽略 os.Create 的错误返回值，认为 file 总是可以创建成功 file, _ := os.Create("output.txt") fmt.Fprint(file, "This is how you write to a file, by the way") file.Close() fmt.Println(s, c, a4, s3, d2, m) // 输出变量 learnFlowControl() // 学习控制语句 } // 不像其他语言，Go 语言里函数的返回值是可以命名的 // 函数声明过程中，为返回类型指定名称，我们就可以在函数中直接返回而不用指定变量 func learnNamedReturns(x, y int) (z int) { z = x * y return // 相当于 return z 这里是隐式的，返回值 z 定义过 } // Go 支持垃圾回收 // Go 有指针但不支持指针运算 func learnMemory() (p, q *int) { // 命名返回值都是 *int 类型的指针 p = new(int) // new() 是为变量分配内存的函数 s := make([]int, 20) // 给 20 个 int 型分配一块内存 s[3] = 7 // 将索引为 3 的元素赋值为 7 r := -2 // 分配一个本地变量 return &s[3], &r // & 取值操作 } // 通过 math 库的别名调用方法（别名见程序 imports 部分） func expensiveComputation() float64 { return m.Exp(10) } func learnFlowControl() { // if 语句块使用 {} 括起来，但是 if 后面的判断部分不需要 () 中括号 if true { fmt.Println("told ya") } // 用 go fmt 命令可以帮助我们格式化代码 if false { // Pout. } else { // Gloat. } // 如果 if 语句分支过多，推荐使用 switch 语句 x := 42.0 switch x { case 0: case 1, 2: // 可以匹配多个值 case 42: // 执行到这里，switch 语句就算是结束了；如果还想执行下一个 case 语句，可以使用 fall through case 43: // 不会执行到这里 default: // Default 语句是可选 } // Type switch 可以对接口变量的值类型做判断 var data interface{} data = "" switch c := data.(type) { case string: fmt.Println(c, "is a string") case int64: fmt.Printf("%d is an int64\n", c) default: // 其他情况 } // 与 if 一样，for 语句也不用括号 // if 和 for 语句里面声明的变量都属于局部变量 for x := 0; x < 3; x++ { // ++ 自增 fmt.Println("iteration", x) } // x == 42 仍然是 42 // for 是 Go 语言唯一的循环语句，但它有其他不同形式 for { // Infinite loop. break // Just kidding. continue // Unreached. } // 可以使用 for-range 迭代 array、slice、字符串、map 或者 channel // for-range 返回一个值(channel)或者两个值(array、slice、string 和 map) for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} { fmt.Printf("key=%s, value=%d\n", key, value) // 输出键值 } // 可以使用下划线 _ 忽略键，当然也可以用来忽略值，不过值一般都是我们需要的 for _, name := range []string{"Bob", "Bill", "Joe"} { fmt.Printf("Hello, %s\n", name) } // 和 for 一样，if 语句中的 := 表示声明和赋值 // 先计算得到 y，再测试 y 是否大于 x if y := expensiveComputation(); y > x { x = y } // 函数字面量属于闭包 xBig := func() bool { return x > 10000 // 这里的 x 是上面 switch 语句里声明的 x 的引用 } x = 99999 fmt.Println("xBig:", xBig()) // true x = 1.3e3 // x == 1300 fmt.Println("xBig:", xBig()) // false now. // 除此之外，函数字面量可以定义并作为参数调用，只要符合以下条件： // a) 函数字面量被立即调用； // b) 函数返回值符合作为参数的条件； fmt.Println("Add + double two numbers: ", func(a, b int) int { return (a + b) * 2 }(10, 2)) // 调用函数，参数是 10、2 // 结果是 24 goto love // goto 语句 love: learnFunctionFactory() // 演示函数的返回值是函数 learnDefer() // defer 语句的简单使用 learnInterfaces() // 接口的使用 } func learnFunctionFactory() { // 下面这两种方式是一样的，不过第二种更常用 fmt.Println(sentenceFactory("summer")("A beautiful", "day!")) d := sentenceFactory("summer") fmt.Println(d("A beautiful", "day!")) fmt.Println(d("A lazy", "afternoon!")) } // 装饰器在其他语言里面很常见，Go 语言里面可以这样实现，通过函数字面量接收参数的方式实现 func sentenceFactory(mystring string) func(before, after string) string { return func(before, after string) string { return fmt.Sprintf("%s %s %s", before, mystring, after) // new string } } func learnDefer() (ok bool) { // defer 语句会将待执行函数推送到一个 list 里，待调用函数返回时按照先进后出的顺序执行 list 里的函数 defer fmt.Println("deferred statements execute in reverse (LIFO) order.") defer fmt.Println("\nThis line is being printed first because") // defer 常用在关闭一个文件等场景，比如在打开一个文件的下一行便调用 defer 关闭文件函数 return true } // 定义 Stringer，是一个接口类型，包含一个 String() 方法 type Stringer interface { String() string } // Define pair as a struct with two fields, ints named x and y. // 定义了一个结构体 pair，包含两个成员 x 和 y，都是 int 类型 type pair struct { x, y int } // 定义了一个 pair 类型的方法，pair 实现了接口 Stringer，因为它实现了接口里面定义的方法 func (p pair) String() string { // p 是接受者 return fmt.Sprintf("(%d, %d)", p.x, p.y) // Sprintf 是 fmt 包里面的一个公共方法； } func learnInterfaces() { p := pair{3, 4} // 声明并初始化结构体变量 p fmt.Println(p.String()) // 调用 String 方法 var i Stringer // 声明一个 Stringer 接口类型的变量 i i = p // 因为 pair 类型实现了接口 Stringer，所以可以将变量 p 赋值给接口变量 i fmt.Println(i.String()) // 通过变量 i 调用 String() 方法，与上面的输出相同 // 如果类型定义了 String() 方法，调用 fmt 包里的函数输出时会自动调用类型的 String() 方法 fmt.Println(p) // 输出与上面相同，Println() 会自动调用 String() 方法 fmt.Println(i) // 输出与上面相同 learnVariadicParams("great", "learning", "here!") } // 函数允许可变参数，即参数的个数可变 func learnVariadicParams(myStrings ...interface{}) { // 使用 for range 迭代可变参数 // 使用 _ 下划线忽略数组的索引 for _, param := range myStrings { fmt.Println("param:", param) } // 将可变参数值作为可变参数传递 fmt.Println("params:", fmt.Sprintln(myStrings...)) learnErrorHandling() } func learnErrorHandling() { // ",ok" 用来表示是否可行的惯用语法 m := map[int]string{3: "three", 4: "four"} if x, ok := m[1]; !ok { // ok 为 false，因为 map 不包含键 1 fmt.Println("no one there") } else { fmt.Print(x) // x 是值 } // 一个错误类型的值还可以包含更多的错误信息 if _, err := strconv.Atoi("non-int"); err != nil { // _ 下划线忽略返回值 fmt.Println(err) // 输出 'strconv.ParseInt: parsing "non-int": invalid syntax' } learnConcurrency() } // c 是 channel 变量，一个并发安全的类型 func inc(i int, c chan int) { c <- i + 1 // <- 是发送操作 } // 我们将使用 inc() 函数实现并发自增操作 func learnConcurrency() { // 内置的 make() 函数用于初始化 slice、map 和 channel c := make(chan int) // 开启 3 个协程并发执行，3个数字会发送到同一个 channel go inc(0, c) // go 关键字用于开启新的协程 go inc(10, c) go inc(-805, c) // 3 次读取 channel 并打印，但不知道读取的顺序是怎么样的 fmt.Println(<-c, <-c, <-c) // <- 是读取操作 cs := make(chan string) // 定义一个 channel，处理 string 类型 ccs := make(chan chan string) // 定义一个 channel，类型是 channel string go func() { c <- 84 }() // 开启一个协程，发送值 84 go func() { cs <- "wordy" }() // 开启一个协程，发送字符串 wordy // Select 的语法类似于 switch，但 Select 是用于 channel 操作，会随机选择一个准备好的 channel 执行 select { case i := <-c: // 读取到的值赋给变量 i fmt.Printf("it's a %T", i) case <-cs: // 忽略读取的值 fmt.Println("it's a string") case <-ccs: // ccs 是一个空的 channel，永远也不会执行到这里 fmt.Println("didn't happen.") } // 执行到这的话，将会从 c 或 cs 读取到值，对应的 goroutine 将完成并自动退出，另一个 goroutine 将会阻塞 learnWebProgramming() } // 调用 http.ListenAndServe 开启一个 web server func learnWebProgramming() { go func() { err := http.ListenAndServe(":8080", pair{}) // 参数 1 是监听的 TCP 地址，参数 2 是 http.Handler 类型的接口变量 fmt.Println(err) // 输出错误 }() requestServer() } // pair 类型实现接口 http.Handler 里定义的方法 ServeHTTP() func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { w.Write([]byte("You learned Go in Y minutes!")) // 传输数据 } func requestServer() { resp, err := http.Get("http://localhost:8080") fmt.Println(err) defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) fmt.Printf("\nWebserver said: `%s`", string(body)) } 源自：https://learnxinyminutes.com/docs/go/ -------------------------------------------------------------我是分割线----------------------------------------------------------- 你好，我是 Seekload，你情商，也可以叫我四哥。 前 PHPer，自学并成功上岸 Go 语言，乐于分享 Go 相关知识，欢迎加 VX：seekload01 学习交流，拉你进学习群，学习氛围好，并为你准备了以下资料： 1、最新版 Go 知识图谱及学习、成长路线图； 2、入门、进阶 Go 语言必看书籍； 3、价值 5000 大洋的视频资料，内含实战项目（不外传）； 另外还有四哥精编的 《Go语言面试题》(pdf)，含解析。