2-1 go发展历程、企业应用、语言特性
go编程语言特性:
自动垃圾回收、函数多返回值、错误处理、闭包与匿名函数、接口与类型、并发编程、反射、内置丰富类型
Mac下go安装与环境变量设置:
在网站 https://golang.google.cn/dl/ 下载 .pkg 安装
GOROOT=/usr/local/go #默认的golang安装路径
GOPATH=$HOME/gopath #默认安装包的路径(源码包, 进行业务的开发, 把源码放到gopath当中, 以及第三方库或从第三方网站下载的库也会安装到默认的gopath当中)
cd $GOPATH目录下有三个文件bin、pkg、src
bin: 用于生成可执行文件.(存放一些之前安装到这里的项目)
pkg: 用于生成的第三方扩展库(.a文件)
src: 存放的源码文件(自己的项目、第三方库项目)
GOBIN=$GOPATH/bin #是我们go执行go install编译之后存在的一个路径, 一般是放在$GOPATH下的bin目录下
PATH=$PATH:$GOROOT/bin:$GOPATH/bin # PATH是系统内建的, 被称为系统的环境变量. 比如去执行安装软件它的一个可执行程序, 当我们设置了PATH, 比如说将对应的GOBIN把它环境变量配置PATH当中, 我们无论在哪个路径下面都会执行.
GOPATH把它加入到我们的环境变量当中,然后保存. 执行$ source ~/.bash_profile 命令, 让它重新生效.
通过命令 $ go env #来查看本机go语言的安装情况
3-1 变量概述、变量格式化输出
///格式化输出的所有格式:
//通用:
%v 值的默认格式表示
%+v 类似%v, 但输出结构体时会添加字段名
%#v 值的go语法表示
%T 值的类型的Go语法表示
%% 百分号
//布尔值:
%t 单词true或false
//进制数:
%b 表示二进制
%c 该值对应的Unicode码值
%d 表示十进制
%o 表示为8进制
%q 该值对应的单引号括起来的go语法字符串面值, 必要时会采用安全的转义表示
%x 表示为十六进制, 使用a-f
%X 表示为十六进制, 使用A-F
%U 表示为Unicode格式, 比如U+1234,等价于"U+%04X"
//浮点数与复数的两个组分:
%b 无小数部分、二进制指数的科学计数法, 如-123456p-78; 参见strconv.FormatFloat
%e 科学计数法, 如-1234.456e+78
%E 科学计数法, 如-1234.456E+78
%f 有小数部分但无指数部分, 如123.456
%F 等价于%f
%g 根据实际情况采用%e或%f格式(以获得更简洁、准确的输出)
%G 根据实际情况采用%E或%F格式(以获得更简洁、准确的输出)
//字符串和[]byte:
%s 直接输出字符串或者[]byte
%q 该值对应的双引号括起来的go语法字符串字面值, 必要时会采用安全的转义表示
%x 每个字节用两个字符十六进制数表示(使用a-f)
%X 每个字节用两个字符十六进制数表示(使用A-F)
//指针:
%p 表示为十六进制, 并加上前导的0x
3-2 变量的使用、变量的内存布局
package main
import "fmt"
///声明多个全局变量
var (
variablesx int
slicex []int
interfacex interface{}
)
func main() {
/// 局部变量的方法:
//方式一
var variables1 int
//方式二: 简短声明. 只能在函数内部这样声明, 在函数外部无法这样声明使用.
variables2 := "我是老大"
//方式三:
var variables3 = 100
//方式四: 一次性申请多个变量
var variables4,variables5,variables6,variables7 = 1,"我是土豆",3.14,true
fmt.Println(variables1,variables2,variables3,variables4,variables5,variables6,variables7)
//简单的变量值交换
var i = 100
var j = 200
i,j = j,i
fmt.Println(i,j)
// _, x := 22, 100 //_声明的变量, 会被丢弃.
//定义变量注意事项:
//go语言当中大写开头的变量, 是可以被其他包读取的使用的, 相当于其他语言的public权限; 变量小写表示只能被本包使用.
var Varaibles = 19
}
3-3 常量概述、常量的使用、常量的应用场景
func main() {
// 常量 const
const constVariables1 float64 = 3.1415926
const constVariables2, constVariables3 = 100, "你好少年"
fmt.Println(constVariables1,constVariables2,constVariables3)
// iota比较特殊, 编译器会修改它的值, 它会在每个const关键字出现时重置为零, 在下一个const出现之前, 每个iota+1
const (
iotaVariables1 = iota //0
iotaVariables2 = iota //1
iotaVariables3 = iota //2
)
const iotaVariables = iota //0
fmt.Println(iotaVariables1,iotaVariables2,iotaVariables3, iotaVariables)
//常量的应用场景:
//比如用const和iota来代替枚举做声明, 表示一周
const (
Monday = iota
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday
)
fmt.Println(Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday)//0 1 2 3 4 5 6
const (
iotaVariables8,iotaVariables9,iotaVariables10 = iota,iota,iota// 0 0 0
)
const (
iotaVariables11 = iota //0
iotaVariables12 = "Bobo" //Bobo
iotaVariables13 = iota //2
)
fmt.Println(iotaVariables8,iotaVariables9,iotaVariables10,iotaVariables11,iotaVariables12,iotaVariables13)//0 0 0 0 Bobo 2
}
4-1 数值类型概述、不同数值类型表示范围、数据类型的使用
package main
import (
"fmt"
"unsafe"
)
func main() {
/* 有符号位
int8 占1个字节 数值范围-2^7到2^7-1
int16 占2个字节 -2^15到2^15-1
int32 占4个字节 -2^31到2^31-1
int64 占8个字节 -2^63到2^63-1
*/
/* 无符号位
uint8 占1个字节 数值范围0到2^8-1
uint16 占2个字节 0到2^16-1
uint32 占4个字节 0到2^32-1
uint64 占8个字节 0到2^64-1
*/
var intVariables1 = 100 //int
intVariables2 := 200 //int
fmt.Printf("intVariables1=%T,intVariables2=%T\n",intVariables1,intVariables2)//intVariables1=int,intVariables2=int
var intVariables3 int32 //int32
intVariables := 126 //int
intVariables3 = int32(intVariables)// int转换为int32
fmt.Printf("intVariables3=%T\n",intVariables3)//intVariables3=int32
//查看占用空间大小(字节数)
var intVariables4 int64 = 123456789
fmt.Println(unsafe.Sizeof(intVariables4)) // 8 (占用8个字节)
}
/// ctrl + R 运行程序
4-2 浮点概述、浮点类型的使用、复数的使用
package main
import (
"fmt"
"unsafe"
)
func main() {
/* 有符号位
float32 占4个字节
float64 占8个字节 (默认类型)
*/
//1.以十进制的形式来展示
var floatVariables1 = 3.141592653
fmt.Printf("floatVariables1的类型=%T, 占用的字节大小=%d \n", floatVariables1,unsafe.Sizeof(floatVariables1))//floatVariables1的类型=float64, 占用的字节大小=8
//2.以科学计数法来展示
floatVariables3 := 3.1415926e2 // 表示3.1415926乘以10的2次方
floatVariables4 := 3.1415926e-2 // 表示3.1415926乘以10的-2次方
fmt.Println(floatVariables3,floatVariables4)//314.15926 0.031415926
///复数: 主要由浮点型表示. 实数"+"虚数i
/*
complex64 由32位实数+32位虚数组成, i是虚数的单位
complex128 由64位实数+64位虚数组成, i是虚数的单位 (默认类型)
*/
//复数定义:
var complexVariables1 complex64
complexVariables1 = 3.14+12i//复数的应用场景: 一元二次方程
complexVariables2 := complex(3.14,12)//实数部分是3.14, 虚数部分是12
fmt.Printf("complexVariables1的类型=%T,值=%v\n",complexVariables1,complexVariables1)//complexVariables1的类型=complex64,值=(3.14+12i)
fmt.Printf("complexVariables2的类型=%T,值=%v\n",complexVariables2,complexVariables2)//complexVariables2的类型=complex128,值=(3.14+12i)
//分别打印实数部分和虚数部分
fmt.Println(real(complexVariables1),imag(complexVariables1))//3.14 12
}
4-3 字符概述、使用
package main
import "fmt"
func main() {
/*
字符:
byte(uint8) //占用一个字节, 无符号, 代表一个utf-8的无符号字节值
rune 代表Unicode字符 //rune实质上是int32的别名, 代表utf-8的一个字符
字符转换成-->ASCII码值-->再转换成二进制
二进制-> ASCII码值-->字符
字符可以参与运算
*/
var charVariables1 byte = '0'
charVariables2 := '铁'
fmt.Printf("charVariables2=%c, charVariables2的类型:%T\n",charVariables2, charVariables2)//charVariables2=铁, charVariables2的类型:int32
fmt.Printf("charVariables1 = %d, charVariables2=%d\n",charVariables1,charVariables2)//charVariables1 = 48, charVariables2=38081
variables := 'a' //对应的编码值
fmt.Printf("加和=%d,a的编码值=%d\n",100+variables,variables)//加和=197,a的编码值=97
}
4-4 字符串概述、字符串使用、字符串遍历、中文字符串的处理
package main
import "fmt"
func main() {
/*
字符串:string, 采用的是utf-8编码
*/
var stringVariables1 string
stringVariables1 = "hello 拿小铁\n"
var stringVariables2 = `
a
aa
aaa
`
fmt.Printf("stringVariables1=%T,stringVariables2=%T\n",stringVariables1,stringVariables2)//stringVariables1=string,stringVariables2=string
fmt.Printf("stringVariables1=%v,stringVariables2=%v",stringVariables1,stringVariables2)
//打印字符串长度
fmt.Println(len(stringVariables2))//10
//字符串拼接
fmt.Println("hello"+"拿小铁")
//遍历字符串(以字节的方式遍历)
var stringVariables3 = "hello dbc, 我是拿小铁"
stringVariables3Len := len(stringVariables3)
for index := 0; index <stringVariables3Len; index++ {
fmt.Printf("%s--编码码=%d, 值=%c\n",stringVariables3,stringVariables3[index],stringVariables3[index])
}
///中文字符串的处理
// 遍历字符串:
for _, value := range stringVariables3{
// 此时的value是rune int32
fmt.Printf("%s--编码码=%d, 值=%c, 类型=%T\n",stringVariables3,value,value,value)
}
}
4-5 布尔类型概述、使用
package main
import "fmt"
func main() {
/*
bool true false
*/
var boolVaraibles1 bool
boolVaraibles1 = true
boolVaraibles2 := (true==false)
fmt.Println(boolVaraibles1,boolVaraibles2)
//bool 类型不接受其他类型的赋值, 不支持自定义类型转换
if 3==4 {
fmt.Println("false")
}else {
fmt.Println("true")
}
fmt.Println(!true,!false,!!true)// false true true
/// go语言不支持 ===
}
5-1 指针概述、指针使用、指针内存布局分析
package main
import "fmt"
func main() {
/*指针:
指针主要用于管理内存.
如果内存管理不当就会出现指针的混乱传递, 比如某一个内存空间已经释放了, 而另一个程序还在使用这个内存, 就会导致内存泄漏. 也野指针.
指针也是一个变量, 存储的是另一个变量的内存地址.
指针变量的值是一个地址
*/
/// 指针的使用与内存布局
var intVariables int = 100
//打印指针
fmt.Printf("intVariables的值=%d,地址=%v\n",intVariables,&intVariables)
//定义指针, 取内存地址
var pointerVariables *int = &intVariables
fmt.Printf("pointerVariables的值=%v,地址=%v\n",pointerVariables,&pointerVariables)
/*
变量名 变量值 内存地址
intVariables 100 0xc00001c090
pointerVariables 0xc00001c090 0xc00000e030
*/
}
5-2 指针内存布局分析、指针作用、指针运算与多级指针
package main
import "fmt"
func main() {
/*指针的作用:
一、节省内存空间, 提高程序执行效率
二、间接访问与修改变量的值
*/
/// 指针的使用与内存布局
var intVariables int = 100
//定义指针, 取内存地址
var pointerVariables *int = &intVariables
//获取到指针指向的值, 并修改
fmt.Println(intVariables)
*pointerVariables = 200
fmt.Println(intVariables)
// 通过指针获取变量的值
var variables2 int = 123 // 定义变量
var pointerVariables2 *int = &variables2 //获取指针(内存地址)
fmt.Println(*pointerVariables2,variables2)
/*
值类型: 整形, 浮点型, bool, array, string. 值类型一般在栈中分配内存
引用类型: 指针, slice, map, chan, interface. 引用类型一般在堆中分配内存
*/
//指针可以指向另一个指针, 不推荐这样做
//当我们定义一个指针的时候, 并没有分配任何变量, 那么它的值默认为nil
var pointer1 *int
*pointer1 = 100 //报错: 无效的内存地址
}
5-3 数组概述、内存布局分析、数组的使用
package main
import "fmt"
func main() {
/*数组
数组的下标, 从0开始, 数组的长度通过len()获取
数组是长度固定的数据类型, 元素的类型都是一样的, 数组在内存当中是连续的存储空间, 可以有效的提升CPU的执行效率
变量或数组在定义时, 如果没有赋值, 会有默认值(零值)
整形: 默认值0
字符串: 默认值""
bool: 默认值false
*/
// 数组的定义方式一:
var arrayVariables [10]int
arrayVariables[0] = 100
arrayVariables[3] = 200
fmt.Println(arrayVariables)//[100 0 0 200 0 0 0 0 0 0]
// 数组在内存当中是连续的存储空间
var arrayVariables2 [5] int = [5]int{1,2,3,4,5}
var length = len(arrayVariables2)
for i:=0; i<length; i++ {
fmt.Printf("arrayVariables2[%d]=%d,地址=%p\n",i,arrayVariables2[i],&arrayVariables2[i])
}
/// 数组定义方式2
// 注意:在go语言中 [10]int 与 [5]int 被认为是不同的类型
// 数组的长度是数组的组成部分
arrayVariables3 := [...]int{1,2,3,4,5}
fmt.Println(arrayVariables3,len(arrayVariables3))
//数组的定义方式3: 指定下标的值
arrayVariables4 := [...]int{100:200,300:500}
fmt.Println(len(arrayVariables4))// 301
}
5-4 数组的使用、数组作为函数参数意义、二维数组与多维数组
package main
import "fmt"
func main() {
//在go语言中数组是值类型
arrayVariables5 := [10]int{1,2,3}
fmt.Println(arrayVariables5)
changeArr(arrayVariables5)
fmt.Println(arrayVariables5)
// 通过指针的方式来改变数组的元素
changeArrByPointer(&arrayVariables5)
fmt.Println(arrayVariables5)
//二维数组
var arrayVariables8 [4][2]int //数组中有4个数组元素, 每个数组元素包含两个int元素
fmt.Println(arrayVariables8) //[[0 0] [0 0] [0 0] [0 0]]
//使用字面量进行初始化二维数组
arrayVariables9 := [4][2]int{{1,2},{3,4},{5,6},{7,8}}
fmt.Println(arrayVariables9)// [[1 2] [3 4] [5 6] [7 8]]
//指定下标初始化二维数组
arrayVariables10 := [4][2]int{1:{10,9}}
fmt.Println(arrayVariables10)// [[0 0] [10 9] [0 0] [0 0]]
//多维数组
var arrayVariables11 [4][3][2]int = [4][3][2]int{}
fmt.Println(arrayVariables11)
}
// 成功的改变了数组的值✅
func changeArrByPointer(arr *[10]int) {
(*arr)[0] = 100
}
// 这样并不会改变数组的内容❌
func changeArr(arr [10]int) {
arr[0] = 100
}
5-5 切片概述、切片使用、切片与数组内存布局分析
/*切片是什么?
一种数据结构, 便于使用与管理我们的数据集合.
按需自动增长, 动态数组(通过append来完成)
底层指向的是数组
内存当中是连续的存储空间, 可以有效的提升CPU的执行效率
引用类型
*/
package main
import "fmt"
func main() {
/*切片 slice
切片又被称为动态数组, 切片长度是可以改变的
切片由三个部分组成: 指向底层数组的指针, 切片的元素个数(长度len), 切片的容量cap.
切片是引用类型
遍历方式和数组类似, 都是通过for, for range
*/
//切片的定义
var sliceVariables []int
//定义一个数组
arrayVariables := [...]int{12,21,23,55,98,2}
for i := 0; i < len(arrayVariables); i++ {
fmt.Printf("arrayVariables[%d]=%d, 地址=%p\n",i,arrayVariables[i],&arrayVariables[i])
}
//通过切片去引用数组
sliceVariables = arrayVariables[:]
for i := 0; i < len(sliceVariables); i++ {
fmt.Printf("sliceVariables[%d]=%d, 地址=%p\n",i,sliceVariables[i],&sliceVariables[i])
}// 切片元素中元素的地址值 与 数组中元素的地址值一直
//切片指向的是底层数组
var sliceVariables2 []int
sliceVariables2 = arrayVariables[1:3] //引用数组的第2-4个元素
fmt.Println(sliceVariables2)// [21 23]
for i := 0; i < len(sliceVariables2); i++ {
fmt.Printf("sliceVariables2[%d]=%d, 地址=%p\n",i,sliceVariables2[i],&sliceVariables2[i])
}
//通过切片改变对应的值
sliceVariables2[0] = 100 //切片对应的是底层数组, 改变的是底层数组的元素的值
fmt.Println(sliceVariables)// [12 100 23 55 98 2]
fmt.Println(sliceVariables2)// [100 23]
}
5-6 切片作为函数参数
package main
import "fmt"
func main() {
//切片的第二种定义方式: make
var sliceVariable3 []int = make([]int,5,6)//长度是5, 容量为6
fmt.Printf("sliceVariables3的长度=%d,容量=%d,切片指向的底层数组的地址=%p,切片自己的地址=%p\n",len(sliceVariable3),cap(sliceVariable3),sliceVariable3,&sliceVariable3)//sliceVariables3的长度=5,容量=6,切片指向的底层数组的地址=0xc00010c060,切片自己的地址=0xc000120048
//切片的追加: append
sliceVariable3 = append(sliceVariable3, 7)
fmt.Printf("第一次追加sliceVariables3的长度=%d,容量=%d,切片指向的底层数组的地址=%p,切片自己的地址=%p\n",len(sliceVariable3),cap(sliceVariable3),sliceVariable3,&sliceVariable3)
sliceVariable3 = append(sliceVariable3, 8)
fmt.Printf("第二次追加sliceVariables3的长度=%d,容量=%d,切片指向的底层数组的地址=%p,切片自己的地址=%p\n",len(sliceVariable3),cap(sliceVariable3),sliceVariable3,&sliceVariable3)
//切片的copy
sliceVariable4 := []int{1,2,3,4,5}
sliceVariables5 := make([]int, 10)
fmt.Println(sliceVariable4)// [1 2 3 4 5]
fmt.Println(sliceVariables5)// [0 0 0 0 0 0 0 0 0 0]
copy(sliceVariables5,sliceVariable4)//将sliceVariables4 的内容拷贝到 sliceVariables5当中
fmt.Println(sliceVariable4)// [1 2 3 4 5]
fmt.Println(sliceVariables5)// [1 2 3 4 5 0 0 0 0 0]
sliceVariables6 := make([]int,1)
copy(sliceVariables6,sliceVariable4)
fmt.Println(sliceVariable4)// [1 2 3 4 5]
fmt.Println(sliceVariables6)// [1]
/// 切片是引用类型
fmt.Println(sliceVariables5)// [1 2 3 4 5 0 0 0 0 0]
changeSlice(sliceVariables5)
fmt.Println(sliceVariables5)// [100 2 3 4 5 0 0 0 0 0]
}
func changeSlice(slice []int) {
slice[0] = 100
}
5-7 map概述、定义与使用方式、map内存布局分析
package main
import "fmt"
func main() {
/*
map 也被称为集合, 这种数据类型是一个无序的键值对
键值对: map[key] = value
通过散列表函数对我们的map进行存储
*/
// 1.map的声明
var mapVariabels1 map[string]string
// 2.map的定义--make
mapVariabels1 = make(map[string]string)
mapVariabels1["Monday"] = "周一"
mapVariabels1["Tuesday"] = "周二"
fmt.Println(mapVariabels1)//map[Mondy:周一 Tuesday:周二]
// map这里的key是唯一的, 不能重复
mapVariabels1["Monday"] = "大周一"
fmt.Println(mapVariabels1)// map[Monday:大周一 Tuesday:周二]
// map len
fmt.Println(len(mapVariabels1)) //2
// 声明的时候同时赋值
var mapVariable2 = map[string]int{
"Monday":1,"Tuesday":2,
}
fmt.Println(mapVariable2)// map[Monday:1 Tuesday:2]
// 通过 := 和make 来声明map
mapVariables3 := make(map[string]int)
mapVariables3["Monday"] = 100
fmt.Println(mapVariables3) //map[Monday:100]
}
5-8 map的使用方式、遍历、有序输出
package main
import (
"fmt"
"sort"
)
func main() {
//切片和函数不可以作为map的key
//mapVariables4 := map[[]string]int{}
mapVariables5 := map[int][]string{}
var sliceString []string
sliceString = make([]string,3)
sliceString[0] = "拿小铁"
sliceString[1] = "golang"
sliceString[2] = "go瑜伽课"
mapVariables5[0] = sliceString
fmt.Println(mapVariables5)//map[0:[拿小铁 golang go瑜伽课]]
//⚠️只声明没有make, 报错
//var mapVariables6 map[string]string
//mapVariables6["hello"] = "拿小铁"
//fmt.Println(mapVariables6)// panic: assignment to entry in nil map
//map是一个引用类型
fmt.Printf("mapVariables3['Monday']在函数调用之前的值:%v\n",mapVariables3["Monday"])
changeMap(mapVariables3)
fmt.Printf("mapVariables3['Monday']在函数调用之后的值:%v\n",mapVariables3["Monday"])
// 如何来对map的key进行顺序输出, for range
var sortKeys []string //sp1.定义切片
for key,_ := range mapVariables3{
sortKeys = append(sortKeys, key)//sp2.把map的key保存到切片中
}
fmt.Printf("排序前sortkeys的值=%v\n",sortKeys)
// sort: 将一个切片进行排序, 按照增长的方式
sort.Strings(sortKeys)//sp3.按照ASSIC码值进行排序
fmt.Printf("排序后sortkeys的值=%v\n",sortKeys)
for i := 0; i < len(sortKeys); i++ {
fmt.Printf("mapVairables3[%s]=%d\n",sortKeys[i],mapVariables3[sortKeys[i]])
}
}
func changeMap(mapVariables map[string]int) {
mapVariables["Monday"] = 888
}
5-9 结构体作为map的值、map切片
package main
import (
"fmt"
"sort"
)
func main() {
//结构体和C语言的类似, 需求: 定一个结构体, 作为map的值
type course struct {
courseName string //课程名称
courseTime float32 //课程时长 单位分钟
courseTeacher string //课程讲师
}
//定义结构体变量
course1 := course{
"go瑜伽课",300.3,"拿小铁",
}
course2 := course{
courseTeacher: "胡歌",
courseTime: 100.2,
courseName: "如何变帅?",
}
courser := make(map[string]course)
courser["go"] = course1
courser["美容"] = course2
fmt.Println(courser)//map[go:{go瑜伽课 300.3 拿小铁} 美容:{如何变帅? 100.2 胡歌}]
/// 判断一个key在我们的map当中是否存在?
//方式一:
value,ok := courser["go"]
if ok {
fmt.Println(value)
}else {
fmt.Println("no value")
}
//方式二:
if value,ok := courser["go"];ok{
fmt.Println(value)
}
///map切片(map+切片): 切片也可以把map作为值来使用, 长度是可以动态改变的
//interface{} 可以把它当做万能类型
var mapVariables6 []map[string]interface{} // 可以把整型、浮点型、字符串等赋值给interface{}
mapVariables6 = make([]map[string]interface{},2)//定义切片, 含两个map
mapVariables6[0] = make(map[string]interface{},2)//定义map1
mapVariables6[0]["name"] = "拿小铁"
mapVariables6[0]["age"] = 18
mapVariables6[1] = make(map[string]interface{},2)//定义map2
mapVariables6[1]["name"] = "胡歌"
mapVariables6[1]["age"] = 16
fmt.Println(mapVariables6)
}
