计算机 类型
可以朗读 语音朗读
268千字 字数
2024-01-01 发行日期
展开全部

主编推荐语

一本全面而深入的Go语言学习手册。

内容简介

本书共20章。

第1章引导读者快速搭建开发环境，详细介绍Go语言的环境配置及编译运行的具体细节。

第2～5章详细讨论Go语言独特的变量、常量、常用数据类型和流程控制，并重点解析复杂类型的底层实现机制。

第6～8章讲解Go语言的函数及如何实现面向对象编程，打通Go语言面向过程和面向对象编程之间的桥梁。

第9～12章探讨Go语言的一些高级话题，包括并发、上下文、反射、泛型等。

第13～15章探讨Go语言的I/O、网络编程及RPC通信等编程场景。

第16～18章是Go语言的扩展话题，涵盖了内存管理、正则表达式和Go语言的汇编。

第19章和第20章重点探讨了Go语言在日常开发中的典型应用，主要介绍HTTP框架Gin的使用，以及如何利用Go语言开发一个综合项目。

目录

  • 版权信息
  • 作者简介
  • 内容简介
  • 前言
  • 第1章 第一个Go程序
  • 1.1 搭建开发环境
  • 1.2 一个简单的Go程序
  • 1.2.1 编写第一个Go程序
  • 1.2.2 运行第一个Go程序
  • 1.3 环境变量说明
  • 1.4 在IDE中运行Go语言程序
  • 1.4.1 创建项目
  • 1.4.2 创建Go程序文件
  • 1.4.3 运行.go文件
  • 1.5 Go语言如何实现跨平台
  • 1.5.1 跨平台的准备工作
  • 1.5.2 执行跨平台编译
  • 1.6 探寻Go语言程序的编译执行过程
  • 1.6.1 go build命令的选项
  • 1.6.2 查看编译的详细过程
  • 1.6.3 链接环节
  • 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.1.5 没有多余的局部变量
  • 2.1.6 全局变量
  • 2.1.7 全局变量与链接
  • 2.2 常量
  • 2.2.1 常量的声明
  • 2.2.2 常量块的使用
  • 2.2.3 常量可以声明而不使用
  • 2.3 iota与枚举
  • 2.3.1 iota实现自增
  • 2.3.2 iota计数不会中断
  • 2.3.3 iota的使用场景
  • 2.4 编程范例——iota的使用技巧
  • 2.5 本章小结
  • 第3章 简单数据类型
  • 3.1 整型
  • 3.1.1 声明整型变量
  • 3.1.2 int和uint的设计初衷
  • 3.2 浮点型
  • 3.2.1 声明浮点型变量
  • 3.2.2 浮点型会产生精度损失
  • 3.2.3 Go语言中没有float关键字的原因
  • 3.2.4 浮点型与类型推导
  • 3.2.5 浮点型的比较
  • 3.3 布尔类型
  • 3.4 字符型
  • 3.4.1 声明字符型变量
  • 3.4.2 转义字符
  • 3.5 字符串类型
  • 3.5.1 声明字符串变量
  • 3.5.2 字符串在磁盘中的存储
  • 3.5.3 字符串在内存中的存储
  • 3.5.4 利用rune类型处理文本
  • 3.5.5 rune类型与字符集的关系
  • 3.6 数组类型
  • 3.6.1 声明数组变量
  • 3.6.2 利用索引来访问数组元素
  • 3.6.3 数组大小不可变更
  • 3.6.4 数组作为函数参数
  • 3.7 编程范例——原义字符的使用
  • 3.8 本章小结
  • 第4章 复杂数据类型
  • 4.1 值类型和指针类型
  • 4.1.1 值类型和指针类型的存储结构
  • 4.1.2 为什么要区分值类型和指针类型
  • 4.1.3 关于引用类型
  • 4.2 slice（切片）的使用及实现原理
  • 4.2.1 切片如何实现大小可变
  • 4.2.2 切片的声明和定义
  • 4.2.3 切片长度的扩展
  • 4.2.4 切片容量的扩展
  • 4.2.5 切片参数的复制
  • 4.2.6 利用数组创建切片
  • 4.2.7 利用切片创建切片
  • 4.2.8 切片元素的修改
  • 4.2.9 切片的循环处理
  • 4.2.10 切片索引越界
  • 4.2.11 总结切片操作的底层原理
  • 4.3 map（映射）的使用及实现原理
  • 4.3.1 声明和创建map
  • 4.3.2 遍历map中的元素
  • 4.3.3 元素查找与避免二义性
  • 4.3.4 删除元素
  • 4.3.5 map的存储结构解析
  • 4.3.6 map元素的定位原理解析
  • 4.3.7 map的容量扩展原理解析
  • 4.4 channel（通道）的使用及实现原理
  • 4.4.1 channel的使用
  • 4.4.2 channel的实现原理
  • 4.4.3 channel与消息队列、协程通信的对比
  • 4.5 自定义结构体
  • 4.5.1 自定义数据类型和自定义结构体
  • 4.5.2 自定义结构体的使用
  • 4.5.3 利用new创建实例
  • 4.5.4 从自定义结构体看访问权限控制
  • 4.5.5 自描述的访问权限
  • 4.6 编程范例——结构体使用实例
  • 4.6.1 利用自定义结构体实现bitmap
  • 4.6.2 利用timer.Ticker实现定时任务
  • 4.7 本章小结
  • 第5章 流程控制
  • 5.1 分支控制
  • 5.1.1 if语句实现分支控制
  • 5.1.2 switch语句实现分支控制
  • 5.1.3 分支控制的本质是向下跳转
  • 5.1.4 避免多层if嵌套的技巧
  • 5.2 循环控制
  • 5.2.1 for循环
  • 5.2.2 for-range循环
  • 5.2.3 循环控制的本质是向上跳转
  • 5.2.4 循环和递归的区别
  • 5.3 跳转控制
  • 5.3.1 goto关键字的使用
  • 5.3.2 goto的本质是任意跳转
  • 5.4 编程范例——流程控制的灵活使用
  • 5.4.1 for循环的误区
  • 5.4.2 switch-case的灵活使用
  • 5.5 本章小结
  • 第6章 函数
  • 6.1 函数在Go语言中的地位
  • 6.1.1 Go语言中函数和方法的区别
  • 6.1.2 重新理解变量声明中数据类型出现的位置
  • 6.2 函数的定义
  • 6.2.1 函数的参数
  • 6.2.2 函数的返回值
  • 6.2.3 函数多返回值的实现原理
  • 6.3 函数的管理——模块和包
  • 6.3.1 函数管理形式
  • 6.3.2 模块与文件夹
  • 6.3.3 本地包管理
  • 6.3.4 模块名与文件夹名称
  • 6.3.5 代码规范的意义
  • 6.4 函数的调用和执行
  • 6.4.1 包的别名与函数调用
  • 6.4.2 init()函数与隐式执行顺序
  • 6.4.3 利用init()函数执行初始化
  • 6.4.4 利用匿名包实现函数导入
  • 6.5 将函数作为变量使用
  • 6.5.1 将函数赋值给变量
  • 6.5.2 函数赋值给变量的应用场景
  • 6.6 匿名函数和闭包
  • 6.6.1 为什么需要匿名函数
  • 6.6.2 闭包
  • 6.7 函数的强制转换
  • 6.7.1 从数据类型的定义到函数类型的定义
  • 6.7.2 从数据类型的强制转换到函数类型的强制转换
  • 6.7.3 函数类型及强制转换的意义
  • 6.7.4 利用强制转换为函数绑定方法
  • 6.8 编程范例——闭包的使用
  • 6.8.1 闭包封装变量的真正含义
  • 6.8.2 利用指针修改闭包外部的变量
  • 6.9 本章小结
  • 第7章 异常处理
  • 7.1 异常机制的意义
  • 7.2 Go语言中的异常
  • 7.2.1 创建异常
  • 7.2.2 抛出异常
  • 7.2.3 自定义异常
  • 7.3 异常捕获
  • 7.3.1 利用延迟执行机制来捕获异常
  • 7.3.2 在上层调用者中捕获异常
  • 7.3.3 异常捕获的限制条件
  • 7.4 异常捕获后的资源清理
  • 7.4.1 未正常释放锁对象带来的副作用
  • 7.4.2 确保锁对象释放的正确方式
  • 7.5 编程范例——异常的使用及误区
  • 7.5.1 利用结构体自定义异常
  • 7.5.2 未成功捕获异常，导致程序崩溃
  • 7.6 本章小结
  • 第8章 Go语言的面向对象编程
  • 8.1 面向对象编程的本质
  • 8.2 Go语言实现封装
  • 8.2.1 Go语言中字段和方法的封装
  • 8.2.2 为值类型和指针类型绑定方法的区别
  • 8.3 Go语言实现继承
  • 8.3.1 利用组合实现继承
  • 8.3.2 匿名字段的支持
  • 8.3.3 多继承
  • 8.4 Go语言实现多态
  • 8.5 面向接口编程
  • 8.5.1 Go语言中的接口
  • 8.5.2 Go语言中的接口实现
  • 8.5.3 利用面向接口编程实现方法多态
  • 8.6 编程范例——接口的典型应用
  • 8.6.1 接口嵌套实例
  • 8.6.2 伪继承与接口实现
  • 8.7 本章小结
  • 第9章 并发
  • 9.1 线程的概念
  • 9.2 线程模型
  • 9.3 协程的工作原理
  • 9.3.1 协程的使用
  • 9.3.2 GPM模型
  • 9.3.3 从3种线程模型看GOMAXPROCS参数
  • 9.4 Go语言中的协程同步
  • 9.4.1 独占锁——Mutex
  • 9.4.2 读写锁——RWMutex
  • 9.4.3 等待组——WaitGroup
  • 9.5 利用channel实现协程同步
  • 9.5.1 利用channel实现锁定
  • 9.5.2 利用channel实现等待组
  • 9.5.3 总结使用channel实现并发控制
  • 9.6 让出时间片
  • 9.6.1 time.Sleep()和runtime.Gosched()的本质区别
  • 9.6.2 runtime.Gosched()与多核CPU
  • 9.7 Go语言中的单例
  • 9.7.1 利用sync.Once实现单例
  • 9.7.2 sync.Once的实现原理
  • 9.8 编程范例——协程池及协程中断
  • 9.8.1 协程池的实现
  • 9.8.2 协程的中断执行
  • 9.9 本章小结
  • 第10章 上下文
  • 10.1 上下文和普通参数的区别
  • 10.2 上下文树
  • 10.2.1 上下文接口——Context
  • 10.2.2 利用context.emptyCtx创建树的根节点
  • 10.2.3 上下文树的构建
  • 10.3 利用valueCtx实现信息透传
  • 10.3.1 valueCtx用于参数传递
  • 10.3.2 从父节点获得透传值
  • 10.4 利用cancelCtx通知协程终止执行
  • 10.4.1 通知子协程终止执行
  • 10.4.2 通知子协程的实现过程
  • 10.4.3 为什么需要取消函数
  • 10.5 利用timerCtx实现定时取消
  • 10.5.1 调用context.WithDeadline()创建定时器上下文
  • 10.5.2 调用context.WithTimeout()创建定时器上下文
  • 10.6 编程范例——上下文的典型应用场景
  • 10.6.1 利用结构体传递参数
  • 10.6.2 valueContext为什么需要key
  • 10.6.3 利用cancelCtx同时取消多个子协程
  • 10.7 本章小结
  • 第11章 反射
  • 11.1 反射的意义
  • 11.2 反射的API
  • 11.2.1 利用reflect.TypeOf()来获得类型信息
  • 11.2.2 利用reflect.Type.Kind()方法来获取类型的具体分类
  • 11.2.3 利用reflect.Type.Element()方法来获取元素类型
  • 11.2.4 类型断言的用法与局限性
  • 11.3 值信息
  • 11.3.1 利用reflect.ValueOf()来获得值信息
  • 11.3.2 利用reflect.Value.Kind()来获得值的分类信息
  • 11.3.3 利用reflect.Value.Elem()来获得值的元素信息
  • 11.3.4 利用反射访问和修改值信息
  • 11.3.5 利用反射机制动态调用方法
  • 11.4 编程范例——动态方法调用
  • 11.5 本章小结
  • 第12章 泛型
  • 12.1 泛型的意义
  • 12.2 泛型应用到函数
  • 12.2.1 泛型函数的使用
  • 12.2.2 泛型中的隐含信息
  • 12.2.3 避免类型强制转换
  • 12.2.4 泛型类型的单独定义
  • 12.3 泛型导致接口定义的变化
  • 12.3.1 接口定义的变化
  • 12.3.2 空接口的二义性
  • 12.3.3 接口类型的限制
  • 12.4 泛型类型应用到receiver
  • 12.4.1 泛型类型不能直接用于定义receiver
  • 12.4.2 间接实现泛型定义receiver
  • 12.5 编程范例——自定义队列的实现
  • 12.6 本章小结
  • 第13章 I/O
  • 13.1 Reader和Writer
  • 13.1.1 理解Reader和Writer
  • 13.1.2 Reader和Writer接口
  • 13.1.3 Go语言的I/O API要解决的问题
  • 13.1.4 文件读取
  • 13.1.5 文件写入
  • 13.1.6 文件权限与umask
  • 13.1.7 一次性读写
  • 13.2 缓冲区读写
  • 13.2.1 bufio中的Reader和Writer
  • 13.2.2 利用bufio实现按行读取
  • 13.3 字符串数据源
  • 13.3.1 strings.Reader解析
  • 13.3.2 字节扫描器ByteScanner
  • 13.3.3 按Rune读取UTF-8字符
  • 13.4 bufio.Scanner的使用
  • 13.4.1 扫描过程及源码解析
  • 13.4.2 扫描时的最大支持
  • 13.4.3 扫描时的最小容忍
  • 13.5 编程范例——文件系统相关操作
  • 13.5.1 查看文件系统
  • 13.5.2 临时文件
  • 13.6 本章小结
  • 第14章 网络编程
  • 14.1 网络连接的本质
  • 14.2 利用TCP实现网络通信
  • 14.2.1 创建TCP连接
  • 14.2.2 利用TCP连接进行消息传递
  • 14.3 利用UDP实现网络通信
  • 14.3.1 监听模式
  • 14.3.2 拨号模式
  • 14.3.3 总结监听模式和拨号模式
  • 14.4 HTTP的相关操作
  • 14.4.1 客户端发送HTTP请求
  • 14.4.2 服务端处理HTTP请求
  • 14.4.3 HTTP请求源码解析
  • 14.4.4 提炼思考
  • 14.5 数据传输过程
  • 14.5.1 本地处理阶段
  • 14.5.2 路由器处理阶段
  • 14.5.3 目标主机处理阶段
  • 14.5.4 网络地址转换（NAT）所扮演的角色
  • 14.5.5 总结数据传输
  • 14.6 编程范例——常见网络错误的产生及解决方案
  • 14.6.1 模拟CLOSE_WAIT
  • 14.6.2 模拟I/O timeout
  • 14.6.3 模拟read: connection reset by peer异常
  • 14.6.4 模拟TIME_WAIT
  • 14.7 本章小结
  • 第15章 RPC通信
  • 15.1 如何理解RPC通信
  • 15.2 Gob格式——利用HTTP和TCP实现RPC通信
  • 15.2.1 利用HTTP实现RPC通信
  • 15.2.2 HTTP实现RPC通信的原理
  • 15.2.3 利用TCP实现RPC通信
  • 15.2.4 利用HTTP和TCP实现RPC的区别
  • 15.3 JSON格式——利用jsonrpc实现RPC通信
  • 15.4 gRPC格式——利用gRPC实现RPC通信
  • 15.4.1 生成RPC支持文件
  • 15.4.2 gRPC调用过程
  • 15.5 编程范例——基于Wireshark理解RPC通信
  • 15.6 本章小结
  • 第16章 内存管理
  • 16.1 内存对齐
  • 16.1.1 内存空隙
  • 16.1.2 内存对齐和对齐边界
  • 16.1.3 结构体的内存对齐
  • 16.2 内存分级管理
  • 16.2.1 分级管理的本质
  • 16.2.2 Go语言内存管理的基本单位——Span
  • 16.2.3 线程级别维护Span——mcache
  • 16.2.4 进程级别维护Span——mcentral
  • 16.2.5 堆级别维护Span——mheap
  • 16.3 Go语言的垃圾回收
  • 16.3.1 内存标记——双色标记法
  • 16.3.2 内存标记——三色标记法
  • 16.3.3 三色标记法与写屏障
  • 16.3.4 垃圾回收
  • 16.3.5 垃圾回收的时机
  • 16.4 编程范例——unsafe包的使用
  • 16.4.1 利用unsafe修改结构体字段
  • 16.4.2 内存地址强制转换为结构体
  • 16.4.3 并非所有内存均可修改
  • 16.5 本章小结
  • 第17章 Go语言中的正则表达式
  • 17.1 正则表达式基础
  • 17.1.1 正则表达式与通配符
  • 17.1.2 元字符和普通字符
  • 17.1.3 字符转义与字符类
  • 17.1.4 字符组的使用
  • 17.2 Go语言中的正则表达式
  • 17.2.1 ASCII字符类
  • 17.2.2 语言文字字符类
  • 17.2.3 Unicode编码方式
  • 17.3 Go语言中的正则表达式函数
  • 17.3.1 正则表达式函数
  • 17.3.2 正则表达式结构体RegExp
  • 17.4 编程范例——判断行为序列
  • 17.5 本章小结
  • 第18章 深入理解Go——Plan 9汇编
  • 18.1 Go汇编简介
  • 18.1.1 为什么需要Go汇编
  • 18.1.2 汇编文件——.s文件
  • 18.1.3 .s文件的命名
  • 18.1.4 .go文件和.s文件的编译
  • 18.2 从内存角度看函数的调用过程
  • 18.2.1 内存布局
  • 18.2.2 函数执行过程
  • 18.2.3 栈顶和栈底
  • 18.2.4 栈内存分配与内存变量读取
  • 18.3 寄存器与内存布局
  • 18.3.1 通用寄存器
  • 18.3.2 伪寄存器
  • 18.3.3 自动分配的内存
  • 18.3.4 区分通用寄存器和伪寄存器
  • 18.3.5 栈帧的大小由什么决定
  • 18.4 第一个Go汇编程序Go汇编语言的一大特点就是能够与.go文件结合使用。下面通过一个实例来演示如何利用
  • 18.4.1 利用汇编文件修改变量的值
  • 18.4.2 跨包引用变量
  • 18.5 利用Go汇编定义变量
  • 18.5.1 全局变量和局部变量
  • 18.5.2 字面量和表达式
  • 18.5.3 定义字符串型变量
  • 18.5.4 定义布尔型变量
  • 18.5.5 定义整型变量
  • 18.5.6 定义切片变量
  • 18.5.7 总结变量定义
  • 18.6 利用Go汇编定义函数
  • 18.6.1 Go中调用汇编函数
  • 18.6.2 汇编中调用Go函数
  • 18.7 Go汇编中的流程控制
  • 18.7.1 Go汇编中的if条件控制
  • 18.7.2 Go汇编中的for循环
  • 18.8 重新理解多返回值
  • 18.9 编程范例——理解常用寄存器
  • 18.9.1 真、伪寄存器的对比使用
  • 18.9.2 验证伪寄存器SP和FP值的差异
  • 18.10 本章小结
  • 第19章 Gin处理HTTP请求及响应
  • 19.1 Gin框架简介
  • 19.2 Gin框架与HTTP请求
  • 19.2.1 安装Gin框架
  • 19.2.2 利用Gin框架开发第一个HTTP接口程序
  • 19.3 Gin框架处理参数
  • 19.3.1 获得URL查询参数
  • 19.3.2 获得表单参数
  • 19.3.3 获得URL路径参数
  • 19.3.4 将JSON格式的参数解析为结构体
  • 19.3.5 将表单参数解析为结构体
  • 19.3.6 接收和处理上传文件
  • 19.4 Gin框架处理响应
  • 19.4.1 返回JSON格式的响应
  • 19.4.2 返回XML格式的响应
  • 19.4.3 返回HTML格式的响应
  • 19.4.4 文件下载
  • 19.4.5 自定义响应
  • 19.5 Gin框架的路由处理
  • 19.5.1 单个路由
  • 19.5.2 路由组
  • 19.5.3 Any方法
  • 19.5.4 NoRoute和NoMethod方法
  • 19.6 Gin框架的中间件
  • 19.6.1 内置中间件
  • 19.6.2 自定义中间件
  • 19.7 编程范例——实现登录认证
  • 19.8 本章小结
  • 第20章 Go语言实现MVC项目
  • 20.1 项目背景
  • 20.1.1 业务背景概述
  • 20.1.2 技术背景概述
  • 20.1.3 项目代码结构
  • 20.2 利用gorm生成MySQL数据表
  • 20.2.1 定义结构体及表结构
  • 20.2.2 从结构体到数据表
  • 20.3 实现用户注册
  • 20.4 实现用户登录
  • 20.5 实现用户查询
  • 20.6 实现用户删除
  • 20.7 本章小结
展开全部

评分及书评

尚无评分
目前还没人评分

出版方

清华大学出版社

清华大学出版社成立于1980年6月，是由教育部主管、清华大学主办的综合出版单位。植根于“清华”这座久负盛名的高等学府，秉承清华人“自强不息，厚德载物”的人文精神，清华大学出版社在短短二十多年的时间里，迅速成长起来。清华大学出版社始终坚持弘扬科技文化产业、服务科教兴国战略的出版方向，把出版高等学校教学用书和科技图书作为主要任务，并为促进学术交流、繁荣出版事业设立了多项出版基金，逐渐形成了以出版高水平的教材和学术专著为主的鲜明特色，在教育出版领域树立了强势品牌。