go语言基础知识学习记录
go语言的基本语法：
注：参考 菜鸟教程 学习
- go run hello.go 直接运行，输出结果(原理也是编译后执行)
- go build hello.go 生成可执行程序，运行可执行程序，输出结果
- 注意 go语言中花括号不能单独占一行，否则会报错
package main import "fmt" func main(){ //go语言中此处的花括号不能单独占一行，否则会报错 fmt.Println("hello world") }
- go语言一条语句占一行，如果一行需要执行多个语句 使用 分号 隔开
- go语言的输出语句有3种方式
- import "fmt" 后适用fmt.Println(x) -- 输出
- println(x) -- 输出
- fmt.Printf("%d",x) -- 格式化输出
关键字
下面列举了 Go 代码中会使用到的 25 个关键字或保留字：
break |
default |
func |
interface |
select |
case |
defer |
go |
map |
struct |
chan |
else |
goto |
package |
switch |
const |
fallthrough |
if |
range |
type |
continue |
for |
import |
return |
var |
除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：
append |
bool |
byte |
cap |
close |
complex |
complex64 |
complex128 |
uint16 |
copy |
false |
float32 |
float64 |
imag |
int |
int8 |
int16 |
uint32 |
int32 |
int64 |
iota |
len |
make |
new |
nil |
panic |
uint64 |
println |
real |
recover |
string |
true |
uint |
uint8 |
uintptr |
字符串的拼接和变量的定义方式
定义变量的三种方式
- 正常使用var定义变量
- 使用var定义变量，但是不定义类型，通过赋初值的方式，go编译器自动识别
- 使用:=的方式来进行 新变量的定义，仅限于新变量 -- 适用于定义在函数内部
//字符串 可以使用+ 进行拼接 fmt.Println("this is my func") fmt.Println("hello ,wolrd" + "xiaozhuzhu") //定义变量 var name string="qqqq" var age,tail int=24,170 fmt.Println(name, age , tail) fmt.Println(name) fmt.Println(age) fmt.Println(tail) //定义变量的三种方式 //1 var a int = 1 fmt.Println(a) //2 使用var定义变量，但是不定义类型，通过赋初值的方式，go编译器自动识别 var b = "hello" fmt.Println(b) //3 使用:=的方式来进行 新变量的定义，仅限于新变量 //:= 左侧如果没有声明新的变量，就产生编译错误 c := 20 fmt.Println(c) //c:=30 //报错，因为c已经不是新变量的 c=30 //正确，是一个正常的赋值操作 fmt.Println(c) c,d:=40,90 //这样是合法的 fmt.Println(c,d)
因式分解的方式，仅仅适用于定义全局变量
//因式分解的方式，仅仅适用于定义全局变量 var ( g_a int = 1 g_b,g_c int=1,2 )
空白符
空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
//空白符 _,e := 2,3 fmt.Println(e)
const常量
- 定义const常量
//定义const常量 const width,height = 10,5 var area int=width*height fmt.Println("面积为", area) //50
- const常量用作枚举
const( unknow = 0 man = 1 woman = 2 ) println(unknow,man,woman) //0 1 2
- 常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：
const( a = "hello" b = len(a) c = unsafe.Sizeof(a) ) println(a,b,c) //hello 5 16
itoa的用法
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
iota 可以被用作枚举值：
//itoa的用法 const( g_a = iota g_b g_c g_d ) const( g_e = iota g_f = "hello" g_g g_h = iota g_i ) const( g_j = 1<<iota g_k g_l g_m ) println(g_a,g_b,g_c,g_d) println(g_e,g_f,g_g,g_h,g_i) println(g_j,g_k,g_l,g_m) //0 1 2 3 //0 hello hello 3 4 //1 2 4 8
运算符
go语言的运算符和C语言的运算符基本一致
Go 没有三目运算符，不能适用?:
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符
语言条件语句
- if xxx
if xxx { ... }
- if xxx {...} else{...}
if xxx{ ... }else{ ... }
- if xxx{ ... if xxx { ...}}
if xxx{ if xxx { ... } ... }
- switch
package main import "fmt" func main(){ grade:= 90 if grade >= 90{ println("优秀") }else if grade >=70 && grade <90{ println("良好") }else{ println("差") } var x interface{} //计算类型 switch i := x.(type){ case nil: fmt.Printf(" x 的类型 :%T\n",i) case int: fmt.Printf("x 是 int 型") default: println("未知") } }
- select
for循环的方式
- 三种方式
- 类似C语言中的for
- 类似C语言中的while
- 死循环
package main import "fmt" func main(){ //类似C语言中的for var sum int for i:=1;i<=10;i++{ sum +=i } fmt.Println(sum) //类似于while for sum >30{ sum -= 10 fmt.Println(sum) } //死循环 for { ... }
- For-each range 循环
//for-each range 循环的方式 for i,str:= range name{ fmt.Printf("%d -- %s\n",i,str) } //0 -- qqqq //1 -- yyyy
函数
go语言的函数，可以有多个返回值，其余和C语言没有什么区别
作用域
与C语言一致
- 局部变量
- 全局变量
- 函数形参
数组
思想和C语言一致，写法如下:
name := []string{"qqqqq","yyyyy"} nums :=[]int{1,2,3,4,5,6}
指针
var ptr1 *int
二级指针
var a int var ptr *int var pptr **int ptr = &a pptr = &ptr
指针数组
var ptr [5]*int
结构体
go语言中的结构体变量，和结构体指针，访问结构体成员的时候，都是使用 点(.)来进行访问，如下：
//定义一个结构体 type info struct{ name string age int height int } //使用 var stu info stu.name = "qqqq" stu.age = 24 stu.height = 170 fmt.Println(stu.name,stu.age,stu.height) var stu2 *info = &stu stu2.name = "yyyy" stu2.age = 24 stu2.height = 160 fmt.Println(stu2.name,stu2.age,stu2.height)
切片slice
Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
- 使用var定义
- 定义空slice
- 使用:=定义
- 使用make来定义 make([]type,len,cap)
- apend 和 copy的使用
package main /* author:qqqq file:slice function:study slice for golang */ import "fmt" func main(){ //定义切片的方式 //1、使用var定义 var s1 = []int{1,2,3}; printInfo(s1); //2、定义空slice var s2 []int printInfo(s2); //3、使用:=定义 ss := []int{3,4,5,6} printInfo(ss); //4、使用make来定义 make([]type,len,cap) s3 := make([]int,2,3) printInfo(s3); //复制操作 s3[0] = 3 printInfo(s3); //覆盖整个slice s1 = s3 printInfo(s1); //apend 和 copy的使用 s3 = append(s3,6,7,8,9) printInfo(s3); //扩容 s4 := make([]int,len(s3),cap(s3) * 3) copy(s4,s3) printInfo(s4); //s[2:] println(s4[1:]) println(s4[:4]) println(s4[1:3]) fmt.Printf("s4[1:] = %v \n",s4[1:]) fmt.Printf("s4[:4] = %v \n",s4[:4]) fmt.Printf("s4[1:3] = %v \n",s4[1:3]) } func printInfo(s[]int){ fmt.Printf("len = %d, cap = %d, slic = %v\n",len(s),cap(s),s); }
范围Range
Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。
在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。
- range 对于 数组、切片
- 对于字符串
- range对于map集合
- 占位符_
package main /* author:qqqq file:range function:study range for golang */ import "fmt" func main(){ //1、range 对于 数组、切片 s := []string{"apple","pen"} for i,value := range s{ fmt.Println(i,value) } //2、对于字符串 for i,value := range "hello"{ fmt.Println(i,value) } //3、range对于map集合 m := map[string]string{"name":"xiaopang","age":"25"} for i,value := range m{ fmt.Println(i,value) } //4、占位符_ sum := 0 nums := []int{1,2,3,4,5} for _,value := range nums{ sum += value } fmt.Println(sum) }
MAP集合
Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
//类似于key-value的形式 map[string]string m := map[string]string{"name":"xiaozhu","age":"15"} mm := make(map[string]string) countryCapitalMap [ "France" ] = "巴黎" countryCapitalMap [ "Italy" ] = "罗马" countryCapitalMap [ "Japan" ] = "东京" countryCapitalMap [ "India " ] = "新德里"
delete() 函数
delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key
delete(countryCapitalMap,"France")
递归函数
Go 语言支持递归。但我们在使用递归时，开发者需要设置退出条件，否则递归将陷入无限循环中。
递归函数对于解决数学上的问题是非常有用的，就像计算阶乘，生成斐波那契数列等。
递归算阶乘
package main import "fmt" func fabulaqi(n uint 64) (result uint64){ if n>0 { return fabulaqi(n-1)*n } return 1 } func main(){ fmt.Println("result : ",fabulaqi(15)) }
菲波拉契数列
func fabolaqi(n uint64)(result utin64){ if n<2{ return n }else{ return fabolaqi(n-2)+fabolaqi(n-1) } }
接口
Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口
package main import "fmt" //接口 type phone interface { call() show() } type xiaomi struct { name string ads string } type huawei struct { name string ads string } //接口实现 func (x xiaomi) call() { fmt.Println("phoneName :", x.name) } func (x xiaomi) show() { fmt.Println("advertisement :", x.ads) } func (h huawei) call() { fmt.Println("phoneName :", h.name) } func (h huawei) show() { fmt.Println("advertisement :", h.ads) } func main() { x := xiaomi{"mi note2", "for fire"} x.call() x.show() h := huawei{"hw p40", "your better phone"} h.call() h.show() }
错误
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。error类型是一个接口类型，这是它的定义：
package main import "fmt" //定义数据结构 type DivideError struct { devidee int devider int } //错误处理实现Error()接口 func (de *DivideError) Error() string { strdata := ` error,divide is zero dividee is %d divider is zero ` return fmt.Sprintf(strdata, de.devidee) } //实现功能接口 func Divide(dividee int, divider int) (result int, errMsg string) { if divider == 0 { data := DivideError{dividee, divider} errMsg = data.Error() return } else { return dividee / divider, "" } } func main() { a := 10 b := 0 result, err := Divide(a, b) if err != "" { fmt.Println(err) return } fmt.Printf("%d / %d == %d \n", a, b, result) }
go语言的并发
Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。goroutine 语法格式：
- go的并发也是线程不安全的，需要加锁才安全
package main import ( "fmt" "time" ) func say(s string) { var i int for i = 0; i < 5; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) } } var num int = 0 //goroutine 是线程不安全的 func countNum() { var i int for i = 0; i < 10; i++ { time.Sleep(5 * time.Millisecond) num++ } } func main() { //go say("hello") //say("world") go countNum() countNum() fmt.Println(num) }
通道（channel）
- 通道（channel）是用来传递数据的一个数据结构。通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。
- 注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。以下实例通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结果的和：
- 通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小
- Go 通过 range 关键字来实现遍历读取到的数据，类似于与数组或切片
package main import "fmt" //不带缓冲的 通道 func getSum(s []int, c chan int) { sum := 0 for _, value := range s { sum += value } c <- sum } func getSum2(c chan int, n int) { x, y := 0, 1 var i int for i = 0; i < n; i++ { c <- x x, y = y, x+y } close(c) //关闭通道 } func main() { //不带缓冲的 通道 // s := []int{3, 5, -2, 3, 4, 7, 1, 1, 1} // c := make(chan int) // go getSum(s[:3], c) // go getSum(s[3:6], c) // go getSum(s[6:], c) // x, y, z := <-c, <-c, <-c // fmt.Println(x, y, z, x+y+z) //带缓冲的通道 c := make(chan int, 10) go getSum2(c, cap(c)) for value := range c { fmt.Println(value) } }
自己调用别的包/自己的包
自己调用别人的包或者自己的包，如上目录结构
- 自己写的包名，要和目录名一样
mylib.go
package mylib func Add(a, b int) int { return a + b }
main.go
package main import ( "fmt" "mystudy.com/mylib" ) func main() { fmt.Println(mylib.Add(2, 3)) }
