网站建设谈单流程,推广计划英文,重庆seo网络推广平台,电子制作diy文章目录 基本语法变量常量函数import导包匿名导包 指针defer静态数组动态数组(slice)定义方式slice追加元素slice截取 map定义方式map使用方式 基本语法
go语言输出hello world的语法如下
package mainimport (fmttime
)func main() {fmt.Println(fmttime
)func main() {fmt.Println(hello world)time.Sleep(1 * time.Second)
}变量
go的变量定义语法共有四种。第一种是var [变量名] [变量类型] [变量值]如果不写变量值那么默认值就是0。
var a int
fmt.Println(a, a)
fmt.Printf(type of a%T\n, a)第二种是声明变量时指定值
var b int 100
fmt.Println(b, b)
fmt.Printf(type of b%T\n, b)第三种是声明一个变量省略数据类型由go自己判断
var c 100
fmt.Println(c, c)第四种是省略var自动匹配
e : 100
fmt.Println(e, e)
fmt.Printf(type of e%T\n, e)声明全局变量
package mainimport fmt// 声明全局变量 方法123是可以的
var gA int 100
var gB 200func main() {fmt.Println(gA, gA)
}在定义变量时还可以定义多个
var xx, yy int 100, 200
fmt.Println(xx, xx, yy, yy)var (vv int 100jj bool true
)
fmt.Println(vv, vv, jj, jj)常量
常量用const关键字来声明
const length int 10
fmt.Println(length, length)除此之外还能批量声明
const (BEIJING 1SHANGHAI 2SHENZHENG 3
)在go中有一个iota关键字可以用来自动赋值。可以在const()中添加关键字iota每行iota都会累加1第一行默认是0,只能在const中使用
package mainimport fmtconst (// 可以在const()中添加关键字iota每行iota都会累加1第一行默认是0,只能在const中使用BEIJING iota * 10SHANGHAISHENZHENG
)func main() {//常量只读const length int 10fmt.Println(length, length)fmt.Println(beijing, BEIJING) // 0fmt.Println(shanghai, SHANGHAI) // 10fmt.Println(shenzheng, SHENZHENG) // 20
}函数
go中函数定义
func foo1(a string, b int) int {fmt.Println(a, a)fmt.Println(b, b)c : 10return c
}如果函数有多个返回值时
func foo2(a string, b int) (int, int) {fmt.Println(a, a)fmt.Println(b, b)return 666, 777
}当返回多个有形参名的,如果类型相同可以省略一个且形参默认值为0
func foo3(a string, b int) (r1, r2 int) {r1 1000r2 2000return
}import导包
go中import导包的具体过程如下图所示 现在创建如下目录结构
./gostudy/5-init/
|____lib2
| |____lib2.go
|____lib1
| |____lib1.go
|____main.golib1/2.go内容
package lib1import fmt// 当前lib1提供的API
func Lib1Test() {fmt.Println(Lib1Test() ...)
}func init() {fmt.Println(lib1.init() ...)
}此时导包代码如下
package mainimport(gostudy/5-init/lib1gostudy/5-init/lib2
)func main() {lib1.Lib1Test()lib2.Lib2Test()
}匿名导包
在导入包后如果不使用它在编译时会直接报错想要解决就需要通过匿名导包即_ 包名
import (_ gostudy/5-init/lib1mylib2 gostudy/5-init/lib2 // 给包起别名
)指针
package mainimport fmtfunc changeValue(p *int) {*p 10
}func main() {var a int 1changeValue(a)fmt.Println(a)
}程序运行后a的值被改为10
defer
在 Go 语言中defer 关键字用于延迟执行一个函数调用通常被用于确保一些操作在函数执行结束时得以执行无论函数是通过正常返回还是发生了运行时恐慌panic。
defer 语句将函数调用推迟到包含 defer 语句的函数即将返回时执行。defer 语句经常用于资源清理、关闭文件、解锁资源等操作。 defer 语句的执行顺序是后进先出LIFO即最后一个 defer 语句最先执行。
package mainimport fmtfunc func1() {fmt.Println(A)
}func func2() {fmt.Println(B)
}func func3() {fmt.Println(C)
}func main() {defer func1()defer func2()defer func3()
}以上代码的最终执行结果为CBA
静态数组
定义固定长度的数组并遍历
package mainimport fmtfunc main() {//固定长度的数组var MyArray1 [10]intfor i : 0; i len(MyArray1); i {fmt.Println(MyArray1[i])}
}另一种定义和遍历方式
package mainimport fmtfunc main() {MyArray2 : [10]int{1, 2, 3, 4}for index, value : range MyArray2 {fmt.Println(index , index, ,value , value)}
}动态数组(slice)
go语言中动态数组是通过切片(slice)来实现的切片的长度可以动态增长或缩小这使得切片更加灵活可以根据实际需要动态调整大小。
定义方式
MyArray : []int{1, 2, 3, 4}往函数中传参并在函数中修改数组的第一个元素
package mainimport fmtfunc printArray(MyArray []int) {// _表示匿名变量for _, value : range MyArray {fmt.Println(value, value)}MyArray[0] 100
}func main() {MyArray : []int{1, 2, 3, 4}printArray(MyArray)fmt.Println()for _, value : range MyArray {fmt.Println(value, value)}
}
// value 1
// value 2
// value 3
// value 4// value 100
// value 2
// value 3
// value 4slice的定义方式共有四种方式一声明slice1是一个切片并且初始化默认值是123
slice1 : []int{1, 2, 3}方式二声明slice是切片但是没有分配空间。此时如果想要赋值会报错需要通过make来分配空间
var slice1 []int
slice1 make([]int, 3)方式三声明slice是切片同时给slice分配空间3个空间初始化为0
var slice1 []int make([]int, 3)方式四通过:推导出是一个slice
slice1 : make([]int, 3)想要判断一个切片是否被分配空间可以用nil来判断
package mainimport fmtfunc main() {var slice1 []intif slice1 nil {fmt.Println(slice未被初始化)} else {fmt.Println(slice有空间)}
}slice追加元素
定义如下slice创建了一个切片 numbers使用 make 函数初始化一个长度为 3、容量为 5 的整数切片。
长度 (len) 是切片当前包含的元素数量这里是 3。容量 (cap) 是切片底层数组的大小这里是 5。切片本身存储了一个指向底层数组的指针以及长度和容量的信息。
package mainimport fmtfunc main() {var numbers make([]int, 3, 5)fmt.Printf(len%d,cap%d,slice%v\n, len(numbers), cap(numbers), numbers)
}
// len3,cap5,slice[0 0 0]如下图所示 此时想用如下代码向slice中增加元素输出的结果为len4,cap5,slice[0 0 0 1]
numbers append(numbers, 1)
fmt.Printf(len%d,cap%d,slice%v\n, len(numbers), cap(numbers), numbers)当追加元素到超过数组的cap时由于容量不足底层数组扩展为新的容量原容量的两倍
package mainimport fmtfunc main() {var numbers make([]int, 3, 5)numbers append(numbers, 1)fmt.Printf(len%d,cap%d,slice%v\n, len(numbers), cap(numbers), numbers)numbers append(numbers, 2)fmt.Printf(len%d,cap%d,slice%v\n, len(numbers), cap(numbers), numbers)numbers append(numbers, 6)fmt.Printf(len%d,cap%d,slice%v\n, len(numbers), cap(numbers), numbers)
}
/* 输出结果
len4,cap5,slice[0 0 0 1]
len5,cap5,slice[0 0 0 1 2]
len6,cap10,slice[0 0 0 1 2 6]
*/以上代码的执行过程如下
初始时切片 numbers 的长度是 3容量是 5内容是 [0 0 0]。向切片追加元素 1长度变为 4容量仍然是 5内容变为 [0 0 0 1]。由于容量未超过预分配的容量底层数组未发生扩展。向切片追加元素 2长度变为 5容量仍然是 5内容变为 [0 0 0 1 2]。向切片追加元素 6由于容量不足底层数组扩展为新的容量原容量的两倍即 5*210。切片的长度变为 6容量变为 10内容变为 [0 0 0 1 2 6]。
slice截取
和Python类似
s : []int{1, 2, 3}
s1 : s[0:2] // [1,2]代码创建了一个切片 s 包含元素 [1, 2, 3]然后通过 s[0:2] 的切片操作创建了一个新的切片 s1该切片包含 s 的索引 0 到 1 的元素。这样的切片操作是左闭右开的所以 s1 将包含索引 0 和 1 对应的元素即 [1, 2]。
需要注意的是这个切片操作是基于原始切片 s 的所以对 s1 的修改也会反映在 s 中因为s和s1的指针指向的是同一个地址新切片和原始切片共享相同的底层数组。例如如果你修改了 s1 中的元素s 中对应的元素也会被修改。通过以下代码执行的结果可以看出。
package mainimport fmtfunc main() {s : []int{1, 2, 3}s1 : s[0:2] // [1,2]s1[0] 100fmt.Println(s)fmt.Println(s1)
}
/*输出结果
[100 2 3]
[100 2]
*/如果想把数组内容拷贝到另一个地址的数组中可以用copy来进行深拷贝。如果 s2 的长度小于 s 的长度copy 将只复制 s2 的长度个元素。
package mainimport fmtfunc main() {s : []int{1, 2, 3}s1 : s[0:2] // [1,2]s[0] 100//copy深拷贝s2 : make([]int, 3)copy(s2, s)s[0] 50fmt.Println(s)fmt.Println(s1)fmt.Println(s2)
}以上代码开辟了新的数组空间s2并把s数组copy到s2中即使把s中第一个元素的值改为50s2也不受影响而s1会跟随s也改为50。
map
在Go语言中map 是一种用于存储键值对的数据结构也被称为字典或关联数组。
定义方式
map的定义方式共有三种。
第一种声明MyMap1是一种map类型key和value都是string。在声明后使用make函数为MyMap1分配了空间并指定了容量为10。
var MyMap1 map[string]string
if MyMap1 nil {fmt.Println(MyMap1是一个空map)
}
// 分配空间
MyMap1 make(map[string]string, 10)MyMap1[one] java
MyMap1[two] c
MyMap1[three] gofmt.Println(MyMap1)
/*输出结果
map[one:java three:go two:c]
*/在最终输出时由于map是无序的键值对的顺序可能会不同。
第二种直接使用make为map创建空间
MyMap2 : make(map[int]string)
MyMap2[1] java
MyMap2[2] c
MyMap2[3] go
fmt.Println(MyMap2)
/*输出结果
map[1:java 2:c 3:go]
*/第三种在声明map时直接定义其中的键值对
MyMap3 : map[string]string{one: php,two: c,three: python,
}
fmt.Println(MyMap3)
/*输出结果
map[one:php three:python two:c]
*/map使用方式
map的增删改查实现如下
package mainimport fmtfunc main() {cityMap : make(map[string]string)//添加cityMap[China] beijingcityMap[Japan] TokyocityMap[USA] NewYork//遍历for key, value : range cityMap {fmt.Println(key , key)fmt.Println(value , value)}//删除delete(cityMap, China)//修改cityMap[USA] DCfmt.Println()for key, value : range cityMap {fmt.Println(key , key)fmt.Println(value , value)}
}
/*输出结果
key China
value beijing
key Japan
value Tokyo
key USA
value NewYorkkey Japan
value Tokyo
key USA
value DC
*/函数传参通过定义了一个名为 printMap 的函数该函数接受一个 map[string]string 类型的参数 cityMap并在循环中遍历该 map 输出每个键值对的键和值。以下代码的输出结果同上。
package mainimport fmtfunc printMap(cityMap map[string]string) {for key, value : range cityMap {fmt.Println(key , key)fmt.Println(value , value)}
}func main() {cityMap : make(map[string]string)//添加cityMap[China] beijingcityMap[Japan] TokyocityMap[USA] NewYorkprintMap(cityMap)//删除delete(cityMap, China)//修改cityMap[USA] DCfmt.Println()printMap(cityMap)
}需要注意的是向函数中传递的cityMap是一个引用传递因此两个map指向的是同一个地址空间在函数内对 map 的修改会影响到原始的 map。
package mainimport fmtfunc printMap(cityMap map[string]string) {for key, value : range cityMap {fmt.Println(key , key)fmt.Println(value , value)}
}func changeValue(cityMap map[string]string) {cityMap[UK] London
}func main() {cityMap : make(map[string]string)//添加cityMap[China] beijingcityMap[Japan] TokyocityMap[USA] NewYorkprintMap(cityMap)//删除delete(cityMap, China)//修改cityMap[USA] DCchangeValue(cityMap)fmt.Println()for key, value : range cityMap {fmt.Println(key , key)fmt.Println(value , value)}
}
/*输出结果
key USA
value NewYork
key China
value beijing
key Japan
value Tokyokey UK
value London
key Japan
value Tokyo
key USA
value DC
*/
