Go语言编程

Posted 2020-11-20 revoid

第1章 初识Go语言

　　1.1 语言简史

　　1.2 语言特性

　　　　1.2.1 自动垃圾回收

　　　　1.2.2 更丰富的内置类型

　　　　1.2.3 函数多返回值

　　　　1.2.4 错误处理

　　　　1.2.5 匿名函数和闭包

　　　　1.2.6 类型和接口

　　　　1.2.7 并发编程

package main

import "fmt"

func sum(values []int,resultChan chan int) {
    sum := 0
    for _,value := range values {
        sum += value
    }
    resultChan <- sum
}

func main() {
    values := []int {1,2,3,4,5,6,7,8,9,10}
    
    resultChan := make(chan int,2)
    go sum(values[:len(values)/2],resultChan)
    go sum(values[len(values)/2:],resultChan)
    
    sum1,sum2 := <-resultChan,<-resultChan
    
    fmt.Println("Result:",sum1,sum2,sum1+sum2)
}

paracalc

　　　　1.2.8 反射

package main

import (
    "fmt"
    "reflect"
)

type Bird struct {
    Name string
    LifeExpectance int
}

func (b *Bird) Fly() {
    fmt.Println("I am flying...")
}

func main() {
    sparrow := &Bird{"Sparrow",3}
    s := reflect.ValueOf(sparrow).Elem()
    typeOfT := s.Type()
    for i := 0; i < s.NumField(); i++ {
        f := s.Field(i)
        fmt.Printf("%d: %s %s = %v
",i,typeOfT.Field(i).Name,f.Type(),f.Interface())
    }
}

reflect

　　　　1.2.9 语言交互性

package main

/*
#include <stdio.h>
*/
import "C"
import "unsafe"

func main() {
    cstr := C.CString("Hello,World")
    C.puts(cstr)
    C.free(unsafe.Pointer(cstr))
}

cprint

　　1.3 第一个Go程序

package main

import "fmt"

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

Hello World

　　　　1.3.1 代码解读

　　　　1.3.2 编译环境准备

$go version

　　　　1.3.3 编译程序

　　1.4 开发工具选择

　　1.5 工程管理

package main

import "os"
import "fmt"
import "simplemath"
import "strconv"

var Usage = func() {
    fmt.Println("USAGE: calc command [arguments] ...")
    fmt.Println("
The commands are:
	add	Addition of two values.
	sqrt	Square
        root of a non-negative value.")
}

func main() {
    args := os.Args
    if args == nil || len(args) < 2 {
        Usage()
        return
    }
    
    switch args[0] {
        case "add":
            if len(args) != 3 {
                fmt.Println("USAGE: cacl add <integer1><integer2>")
                return
            }
            v1,err1 := strconv.Atoi(args[1])
            v2,err2 := strconv.Atoi(args[2])
            if err1 != nil || err2 != nil {
                fmt.Println("USAGE: calc add<integer1><integer2>")
                return
            }
            ret := simplemath.Add(v1,v2)
            fmt.Println("Result: ",ret)
        case "sqrt":
            if len(args) != 2 {
                fmt.Println("USAGE: calc sqrt <integer>")
                return
            }
            v,err := strconv.Atoi(args[1])
            if err != nil {
                fmt.Println("USAGE: calc sqrt <integer>")
                return
            }
            ret := simplemath.Sqrt(v)
            fmt.Println("Result: ",ret)
        default:
            Usage()
    }
}

calcl

package simplemath

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

add

package simplemath

import "testing"

func TestAdd1(t *testing.T) {
    r := Add(1,2)
    if r != 3 {
        t.Errorf("Add(1,2) failed.Got %d,expected 3.",r)
    }
}

add_test

package simplemath

import "math"

func Sqrt(i int) int {
    v := math.Sqrt(float64(i))
    return int(v)
}

sqrt

package simplemath

import "testing"

func TestSqrt1(t *testing.T) {
    v := Sqrt(16)
    if v != 4 {
        t.Errorf("Sqrt(16) failed.Got %v,expected 4.",v)
    }
}

sqrt_test

　　1.6 问题追踪和调试

　　　　1.6.1 打印日志

　　　　1.6.2 GDB调试

　　1.7 如何寻求帮助

　　　　1.7.1 邮件列表

　　　　1.7.2 网站资源

　　1.8 小结

第2章 顺序编程

　　2.1 变量

　　　　2.1.1 变量声明

　　　　2.1.2 变量初始化

　　　　2.1.3 变量赋值

　　　　2.1.4 匿名变量

　　2.2 常量

　　　　2.2.1 字面常量

　　　　2.2.2 常量定义

　　　　2.2.3 预定义常量

　　　　2.2.4 枚举

　　2.3 类型

　　　　2.3.1 布尔类型

　　　　2.3.2 整型

　　　　2.3.3 浮点型

　　　　2.3.4 复数类型

　　　　2.3.5 字符串

　　　　2.3.6 字符类型

　　　　2.3.7 数组

　　　　2.3.8 数组切片

　　　　2.3.9 map

　　2.4 流程控制

　　　　2.4.1 条件语句

　　　　2.4.2 选择语句

　　　　2.4.3 循环语句

　　　　2.4.4 跳转语句

　　2.5 函数

　　　　2.5.1 函数定义

　　　　2.5.2 函数调用

　　　　2.5.3 不定参数

　　　　2.5.4 多返回值

　　2.6 错误处理

　　　　2.6.1 error接口

　　　　2.6.2 defer

　　　　2.6.3 panic()和recover()

　　2.7 完整示例

　　　　2.7.1 程序结构

　　　　2.7.2 主程序

　　　　2.7.3 算法实现

　　　　2.7.4 主程序

　　　　2.7.5 构建与执行

　　2.8 小结

第3章 面向对象编程

　　3.1 类型系统

　　　　3.1.1 为类型添加方法

　　　　3.1.2 值语义和引用语义

　　　　3.1.3 结构体

　　3.2 初始化

　　3.3 匿名组合

　　3.4 可见性

　　3.5 接口

　　　　3.5.1 其他语言的接口

　　　　3.5.2 非侵入式接口

　　　　3.5.3 接口赋值

　　　　3.5.4 接口查询

　　　　3.5.5 类型查询

　　　　3.5.6 接口组合

　　　　3.5.7 Any类型

　　3.6 完整示例

　　　　3.6.1 音乐库

　　　　3.6.2 音乐播放

　　　　3.6.3 主程序

　　　　3.6.4 构建运行

　　　　3.6.5 遗留问题

　　3.7 小结

第4章 并发编程

　　4.1 并发基础

　　4.2 协程

　　4.3 goroutine

　　4.4 并发通信

　　4.5 channel

　　　　4.5.1 基本语法

　　　　4.5.2 select

　　　　4.5.3 缓冲机制

　　　　4.5.4 超时机制

　　　　4.5.5 channel的传递

　　　　4.5.6 单向channel

　　　　4.5.7 关闭channel

　　4.6 多核并行化

　　4.7 出让时间片

　　4.8 同步

　　　　4.8.1 同步锁

　　　　4.8.2 全局唯一性操作

　　4.9 完整示例

　　　　4.9.1 简单IPC框架

　　　　4.9.2 中央服务器

　　　　4.9.3 主程序

　　　　4.9.4 运行小程序

　　4.10 小结

第5章 网络编程

　　5.1 Socket编程

　　　　5.1.1 Dial()函数

　　　　5.1.2 ICMP示例程序

　　　　5.1.3 TCP示例程序

　　　　5.1.4 更丰富的网络通信

　　5.2 HTTP编程

　　　　5.2.1 HTTP客户端

　　　　5.2.2 HTTP服务端

　　5.3 RPC编程

　　　　5.3.1 Go语言中的RPC支持与处理

　　　　5.3.2 Gob简介

　　　　5.3.3 设计优雅的RPC接口

　　5.4 JSON处理

　　　　5.4.1 编码为JSON格式

　　　　5.4.2 解码JSON数据

　　　　5.4.3 解码未知结构的JSON数据

　　　　5.4.4 JSON的流式读写

　　5.5 网站开发

　　　　5.5.1 最简单的网站程序

　　　　5.5.2 net/http包简介

　　　　5.5.3 开发一个简单的相册网站

　　5.6 小结

第6章 安全编程

　　6.1 数据加密

　　6.2 数字签名

　　6.3 数字证书

　　6.4 PKI体系

　　6.5 Go语言的哈希函数

　　6.6 加密通道

　　　　6.6.1 加密通信流程

　　　　6.6.2 支持HTTPS的Web服务器

　　　　6.6.3 支持HTTPS的文件服务器

　　　　6.6.4 基于SSL/TLS的ECHO程序

　　6.7 小结

第7章 工程管理

　　7.1 Go命令行工具

　　7.2 代码风格

　　　　7.2.1 强制性编码规范

　　　　7.2.2 非强制性编码风格建议

　　7.3 远程import支持

　　7.4 工程组织

　　　　7.4.1 GOPATH

　　　　7.4.2 目录结构

　　7.5 文档管理

　　7.6 工程构建

　　7.7 跨平台开发

　　　　7.7.1 交叉编译

　　　　7.7.2 android支持

　　7.8 单元测试

　　7.9 打包分发

　　7.10 小结

第8章 开发工具

　　8.1 选择开发工具

　　8.2 gedit

　　　　8.2.1 语法高亮

　　　　8.2.2 编译环境

　　8.3 Vim

　　8.4 Eclipse

　　8.5 Notepad++

　　　　8.5.1 语法高亮

　　　　8.5.2 编译环境

　　8.6 LitelIDE

　　8.7 小结

第9章 进阶话题

　　9.1 反射

　　　　9.1.1 基本概念

　　　　9.1.2 基本用法

　　　　9.1.3 对结构的反射操作

　　9.2 语言交互性

　　　　9.2.1 类型映射

　　　　9.2.2 字符串映射

　　　　9.2.3 C程序

　　　　9.2.4 函数调用

　　　　9.2.5 编译Cgo

　　9.3 链接符号

　　9.4 goroutine机理

　　　　9.4.1 携程

　　　　9.4.2 携程的C语言实现

　　　　9.4.3 协程库概述

　　　　9.4.4 任务

　　　　9.4.5 任务调度

　　　　9.4.6 上下文切换

　　　　9.4.7 通信机制

　　9.5 接口机理

　　　　9.5.1 类型赋值给接口

　　　　9.5.2 接口查询

　　　　9.5.3 接口赋值