1、hello world！

// 同一个目录下面不能有个多 package main
package main

// 导包
import "fmt"

// 程序入口
func main() {
    fmt.Println("Hello world")
}

2、HTTP文件服务器

// 标记当前文件为 main 包，main 包也是 Go 程序的入口包
package main

// 导入 net/http 包，这个包的作用是 HTTP 的基础封装和访问
import (
    "net/http"
)

/**
HTTP文件服务器
*/
// 程序执行的入口函数 main()
func main() {

    // 使用 http.FileServer 文件服务器将当前目录作为根目录（/目录）的处理器，访问根目录，就会进入当前目录
    http.Handle("/", http.FileServer(http.Dir(".")))
    // 默认的 HTTP 服务侦听在本机 8080 端口
    http.ListenAndServe(":8080", nil)
}

// 在浏览器里输入http://127.0.0.1:8080即可浏览文件，这些文件正是当前目录在HTTP服务器上的映射目录。

3、并发编程

// 同一个目录下面不能有个多 package main
package main

// 导入格式化（fmt）、随机数（math/rand）、时间（time）包参与编译
import (
    "fmt"
    "math/rand"
    "time"
)

// 生产数据的函数，传入一个标记类型的字符串及一个只能写入的通道
// 数据生产者
func producer(header string, channel chan<- string) {
    // for{} 构成一个无限循环
    // 无限循环，不停地生产数据
    for {
        // 使用 rand.Int31() 生成一个随机数，使用 fmt.Sprintf() 函数将 header 和随机数格式化为字符串
        // 将随机数和字符串格式化为字符串发送给通道
        channel <- fmt.Sprintf("%s: %v", header, rand.Int31())
        // 使用 time.Sleep() 函数暂停 1 秒再执行这个函数。如果在 goroutine 中执行时，暂停不会影响其他 goroutine 的执行
        // 等待1秒
        time.Sleep(time.Second)
    }
}

// 消费数据的函数，传入一个只能写入的通道
// 数据消费者
func customer(channel <-chan string) {
    // 不停的获取数据
    for {
        // 从通道中获取数据，此处会阻塞直到信道中返回数据
        message := <-channel
        // 打印数据
        fmt.Println(message)
    }
}

// 程序的入口函数，总是在程序开始时执行
func main() {

    // 创建一个字符串类型的通道
    channel := make(chan string)
    // 并发执行一个生产者函数，两行分别创建了这个函数搭配不同参数的两个 goroutine
    // 创建producer()函数的并发goroutine
    go producer("cat", channel)
    go producer("dog", channel)
    // 执行消费者函数通过通道进行数据消费
    // 数据消费函数
    customer(channel)
}

/**
整段代码中，没有线程创建，没有线程池也没有加锁，仅仅通过关键字 go 实现 goroutine，和通道实现数据交换。

编译成exe文件：go build go-test/test3/concurrent.go
*/

4、计算器

add.go

package simplemath

// 加法
func Add(a int, b int) int{
    return a + b
}

sqrt.go

package simplemath

import "math"

// 平方根
func Sqrt(i int) int{
    v := math.Sqrt(float64(i))
    return int(v)
}

main.go

package main

// 引入其他包
import (
    "fmt"
    "go-test/simplemath"
    "os"
    "strconv"
)
// 定义一个用于打印程序使用指南的函数
var Usage = func(){
    fmt.Println("USAGE：calc command [arguments] ...")
    fmt.Println("\nThe commands are:\n\tadd\t计算两个数值相加\n\tsqrt\t计算一个非负数的平方根")
}

// 程序入口函数
func main(){
    /*
     * 用于获取命令行参数，注意程序名本身是第一个参数，
     * 比如 calc add 1 2 这条指令，第一个参数是 calc
     */
    // := 声明并初始化变量，不需要通过 var 声明该变量
    args := os.Args
    // 除程序名本身外，至少需要传入两个其他参数，否则退出
    if args == nil || len(args) < 3{
        Usage()
        return
    }
    // 第二个参数表示计算方法
    switch args[1]{
        // 加法
        case "add":
            // 至少需要4个参数
            if len(args) != 4{
                fmt.Println("USAGE: calc add <integer1><integer2>")
                return
            }
            // 获取待相加的类型，并将类型转换为整型
            v1, err1 := strconv.Atoi(args[2])
            v2, err2 := strconv.Atoi(args[3])
            // 获取参数出错，则退出
            if err1 != nil || err2 != nil{
                fmt.Println("USAGE: calc add <integer1><integer2>")
                return
            }
            // 从 simplemath 包引入 Add 方法
            ret := simplemath.Add(v1, v2)
            fmt.Println("Result: ", ret)
        // 求方根
        case "sqrt":
            if len(args) != 3{
                fmt.Println("USAGE: calc sqrt <integer>")
                return
            }
            v, err := strconv.Atoi(args[2])
            if err != nil{
                fmt.Println("USAGE: calc sqrt <integer>")
                return
            }
            ret := simplemath.Sqrt(v)
            fmt.Println("Result: ", ret)

        default:
            Usage()
    }
}