Go语言入门心法(一)
Go语言入门心法(二): 结构体
Go语言入门心法(三): 接口
一: go语言中变量认知
go语言中变量的定义: （要想飞|先会走）||（翻身仗|抹遗憾 ） |（二八定律）
(先量变)|(再质变)||（冰冻三尺非一日寒）|(扶贫之旅|继续裸奔)
(1)go语言中变量认知升维
(2)go语言中变量与强类型语言java类似,变量使用必须先声明后使用
(3)go语言中变量标准的声明使用var关键字进行声明: var 变量名 变量类型;变量声明后必须使用,否则编译器会报错
(4)go语言中变量声明时可以赋予初始值,如果不赋初始值,则默认为各变量的类型的默认值 var name string = "外卖小哥哥"
(5)go语言中变量如果声明的同时赋予初始值,则可以省略变量的类型: var age = 30
(6)go语言中变量什么并附初始值时可以使用简易默认,也是go语言中变量定义的常用方式: name := "boss";此时可以省略var关键字与数据类型
(7)go语言可以对多个变量同时进行块声明:
var (
personName := "张三"
personAge := 30
sex := 1
marry := false )
附录实例一:
package main
import (
"fmt"
"reflect"
)
/*
go语言中变量的定义域:
(1)go语言中变量认知升维
(2)go语言中变量与强类型语言java类似,变量使用必须先声明后使用
(3)go语言中变量标准的声明使用var关键字进行声明: var 变量名 变量类型;变量声明后必须使用,否则编译器会报错
(4)go语言中变量声明时可以赋予初始值,如果不赋初始值,则默认为各变量的类型的默认值 var name string = "外卖小哥哥"
(5)go语言中变量如果声明的同时赋予初始值,则可以省略变量的类型: var age = 30
(6)go语言中变量什么并附初始值时可以使用简易默认,也是go语言中变量定义的常用方式: name := "boss";此时可以省略var关键字与数据类型
(7)go语言可以对多个变量同时进行块声明:
var (
personName := "张三"
personAge := 30
sex := 1
marry := false
)
*/
func main() {
a := 1
b := "test"
c := true
fmt.Println("a变量类型： ", reflect.TypeOf(a))
fmt.Println("b变量类型： ", reflect.TypeOf(b))
fmt.Println("c变量类型： ", reflect.TypeOf(c))
fmt.Println("=========================变量类型转换===============================")
var d int16 = 97
fmt.Println("变量a的值为: ", d, " ,变量的类型为: ", reflect.TypeOf(d))
e := int32(d)
fmt.Println("变量e的值为: ", e, " ,变量的类型为: ", reflect.TypeOf(e))
fmt.Println("变量e的类型为字符串: ", string(e))
fmt.Println("变量e的类型为字符串string : ", reflect.TypeOf(string(e)))
desc := `再进行变量类型转换中
需要特别注意转换后的数值是否发生变化
`
fmt.Println("注意事项： ", desc)
var as int32 = 1234567891
fmt.Println("变量as的值：", as, " ,变量类型: ", reflect.TypeOf(as))
fmt.Println("转换as的类型为int16,变量as的值为: ", int16(as), " ,变量as类型: ", reflect.TypeOf(int16(as)))
}
实例运行效果：
GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_VariableParameterDifinition_go.exe D:\program_file\go_workspace\org.jd.data\VariableParameterDifinition.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_VariableParameterDifinition_go.exe
a变量类型： int
b变量类型： string
c变量类型： bool
=========================变量类型转换===============================
变量a的值为: 97 ,变量的类型为: int16
变量e的值为: 97 ,变量的类型为: int32
变量e的类型为字符串: a
变量e的类型为字符串string : string
注意事项： 再进行变量类型转换中
需要特别注意转换后的数值是否发生变化
变量as的值： 1234567891 ,变量类型: int32
转换as的类型为int16,变量as的值为: 723 ,变量as类型: int16
Process finished with the exit code 0
附录实例二:
package main
import (
"fmt"
"reflect"
)
/*
变量交换值,使用变量简短什么方式来声明及赋值
*/
func main() {
var name string
var age int
var salary float32
fmt.Println("变量a与b交换值:")
a := 1
b := 3
a, b = b, a
fmt.Println("a:", a)
fmt.Println("b:", b)
println("name变量的默认初始值: ", name)
println("age变量的初始值: ", age)
println("salary的默认初始值: ", salary)
/*
go语言中变量的定义与java中定义的变量类型,都需要先声明后使用的
(1)申明变量的语法:
var 变量名 类型
这样声明的变量,没有赋予初始值时,go会自动赋予该类型变量的默认初始值字符串默认初始值为空串
(2)定义变量的同时赋予初始值: 标准的声明变量赋值
var typeNum int = 0
(3)同时声明多个变量时,没有赋予初始值,则变量类型必须保留
var (
a string
b int
c string
d float
)
(4) 编译器推导类型格式
var num = 20
*/
var college string
println("变量college= ", college)
var typeNum int64
println("变量type= ", typeNum)
/*
(1)go语言可以批量声明变量,声明变量的同时可以赋予初始值
(2)go语言中变量声明后必须使用,但是常量声明后,不一定使用
*/
var (
// 赋值的变量,可以省略类型,go编译器会自动进行类型推断;为简介,通常附初始值的变量可以省略变量类型
tName string = "张三"
tAge int = 28
tSex bool
)
var numCount = 20
println("numCount type is ", reflect.TypeOf(numCount))
println("numCount = ", numCount)
str := "这是第一个go语言程序"
println("str=", str)
strNum := `
通过反引号可以定义字符串
多行字符串定义
`
println("多行字符串定义: strNum = ", strNum)
desc := `
(1) 在go语言中有两种类型
uint8：代表了 ASCII码的一个字符串
rune类型: 代表了UTF-8格式的一个字符(如中文,日文或者其他复合字符,本质就是int32类型)
`
println(desc)
english := 'a'
chinese := '我'
fmt.Println(english)
fmt.Println(chinese)
println("名称: ", tName, " ,年龄: ", tAge, " ,性别(true-男;false-女): ", tSex)
}
运行效果：
OOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ChangeParamaValue_go.exe D:\program_file\go_workspace\org.jd.data\ChangeParamaValue.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ChangeParamaValue_go.exe
变量a与b交换值:
a: 3
b: 1
name变量的默认初始值:
age变量的初始值: 0
salary的默认初始值: +0.000000e+000
变量college=
变量type= 0
numCount type is (0xed14a0,0xe9c920)
numCount = 20
str= 这是第一个go语言程序
多行字符串定义: strNum =
通过反引号可以定义字符串
多行字符串定义
(1) 在go语言中有两种类型
uint8：代表了 ASCII码的一个字符串
rune类型: 代表了UTF-8格式的一个字符(如中文,日文或者其他复合字符,本
质就是int32类型)
97
25105
名称: 张三 ,年龄: 28 ,性别(true-男;false-女): false
Process finished with the exit code 0
二: go语言常量认知
go语言中的常量的定义:
(1)使用关键字const定义常量;
(2)常量申明后可以不使用;不想变量那样,定义后必须使用,否则编译检查报错
(3)常量的值在初始化后,不能修改
(4)常量枚举: 针对一个有穷序列集合而言,一个集的枚举就是列出有穷序列集的所有成员
package main
import (
"fmt"
)
/*
go语言中的常量的定义:
(1)使用关键字const定义常量;
(2)常量申明后可以不使用;不想变量那样,定义后必须使用,否则编译检查报错
(3)常量的值在初始化后,不能修改
(4)常量枚举: 针对一个有穷序列集合而言,一个集的枚举就是列出有穷序列集的所有成员
*/
func main() {
fmt.Println("---------------循序渐进代码实操演示学习go编程语言--------------")
fmt.Println("-------------------------go语言中定义常量------------------------------")
const PersonName string = "GO语言实战系列"
println("第一个常量: ", PersonName)
const aa = 20
const bb int16 = 50
println("常量定义时,可以使用编译器进行类型推断,从而可以省略变量的类型")
println("常量[a] = ", aa)
println("常量[b]= ", bb)
println("常量与变量都可以批量定义:")
const (
personName string = "小张"
personAge int16 = 30
personAddress = "北京市海淀区马连洼街道120路105号"
)
println("使用批量定义的常量:")
println("名称: ", personName, " ,年龄: ", personAge, " ,上班等死地址: ", personAddress)
/*
go语言现阶段还没有枚举,但是可以通过使用一种特殊的常量“iota”类模拟枚举
iota在const关键字出现时被重置为0,const中的每新增一行常量申明,将使iota进行一次计数,
可以简单第将iota理解为const语句块中的行索引
*/
const (
a = iota
b
c = "你好呀,欢迎来到特工世界"
d
e = iota
)
println("a:", a)
println("b:", b)
println("c:", c)
println("d:", d)
println("e:", e)
}
实例运行效果:
GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ConstParameterDefinition_go.exe D:\program_file\go_workspace\org.jd.data\ConstParameterDefinition.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ConstParameterDefinition_go.exe
---------------循序渐进代码实操演示学习go编程语言--------------
-------------------------go语言中定义常量------------------------------
第一个常量: GO语言实战系列
常量定义时,可以使用编译器进行类型推断,从而可以省略变量的类型
常量[a] = 20
常量[b]= 50
常量与变量都可以批量定义:
使用批量定义的常量:
名称: 小张 ,年龄: 30 ,上班等死地址: 北京市海淀区马连洼街道120路105号
a: 0
b: 1
c: 你好呀,欢迎来到特工世界
d: 你好呀,欢迎来到特工世界
e: 4
Process finished with the exit code 0
三: go中各种运算符认知
package main
import "fmt"
func main() {
/*
go语言中的各种表达式:
(1)赋值表达式 = , +=,-+
(2)条件表达式 if 条件判断
(3)逻辑表达式 && || !
(4)算术表达式 + , - , * ,/
(5)位运算符
*/
fmt.Println("go语言中的各种表达式")
a := 1
b := 2
println("算术运算符: ")
println("a+b = ", a+b)
println("a-b = ", a-b)
println("a*b = ", a*b)
println("求商(a/b) = ", a/b)
println("求余数(a%b) = ", a%b)
println()
println("比较运算符：")
println("a==b：", a == b)
println("a>=b：", a >= b)
println("a<=b：", a <= b)
println("a<b：", a < b)
println("a>b：", a > b)
println("a!=b：", a != b)
println()
println("赋值运算符: ")
var d = 10
fmt.Println("变量d = ", d)
d += 2
fmt.Println("d+=2: ", d)
d -= 2
fmt.Println("d-=2: ", d)
d *= 2
fmt.Println("d*=2: ", d)
d /= 2
fmt.Println("d/=2: ", d)
d %= 2
fmt.Println("d%=2: ", d)
println()
println("位运算符: ")
c := 9
e := 13
fmt.Println("e&c = ", e&c)
fmt.Println("e|c = ", e|c)
fmt.Println("e^c = ", e^c)
fmt.Println("e<<c = ", e<<c)
fmt.Println("e>>c = ", e>>c)
println()
println("逻辑运算符: ")
f := true
g := false
fmt.Println("f&g = ", f && g)
fmt.Println("f||g = ", f || g)
fmt.Println("!f = ", !f)
}
运行效果:
GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ExpressionToGoGrammar_go.exe D:\program_file\go_workspace\org.jd.data\ExpressionToGoGrammar.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ExpressionToGoGrammar_go.exe
go语言中的各种表达式
算术运算符:
a+b = 3
a-b = -1
a*b = 2
求商(a/b) = 0
求余数(a%b) = 1
比较运算符：
a==b： false
a>=b： false
a<=b： true
a<b： true
a>b： false
a!=b： true
赋值运算符:
变量d = 10
d+=2: 12
d-=2: 10
d*=2: 20
d/=2: 10
d%=2: 0
位运算符:
e&c = 9
e|c = 13
e^c = 4
e<<c = 6656
e>>c = 0
逻辑运算符:
f&g = false
f||g = true
!f = false
Process finished with the exit code 0
四: 流程控制认知
package main
import (
"fmt"
"runtime"
)
/*
go语言流程控制:
go语言中,通过if 关键字构成的条件判断语句进行条件判断,格式如下:
if 条件表达式 {
分支一
}else if 条件表达式2 {
分支二
}else {
分支3
}
*/
func main() {
fmt.Println(`Go语言的编程者需要通过流程控制语句来控制程序的逻辑走向和执行顺序.
流程控制语句主要包括: 条件判断语句(if和switch),
循环控制语句(for,break,continue和跳转语句goto)
`)
a := 101
if a > 100 {
fmt.Println(a, " > 100")
} else if a == 100 {
fmt.Println(a, " = 100")
} else {
fmt.Println(a, " < 100")
}
println(`
if还有一种比较常见的写法,就是在if表达式前添加一个语句,使用变量接收语句返回的值，通过对该变量的判断在
选择执行的分支;这一点更python的 if条件判断类似,而java需要另外一个变量来接收
`)
if num := runtime.NumCPU(); num >= 1 {
println("程序使用的CPU核数为:", num)
}
println()
println(`
Go语言中的循环逻辑通过for关键字实现;不同于其他编程语言,Go语言没有while关键字,不存在while循环
for循环格式如下:
for 初始语句;条件表达式;赋值表达式 {
循环体
}
`)
println()
for i := 1; i < 10; i++ {
fmt.Println("循环的次数：", i)
}
println(`
break跳出循环：
break语言用来跳出for循环，而且可以在语句后面添加标签;表示退出标签对应的代码块逻辑;
注意: break语句如果不带标签,则默认跳出最内层的for循环
`)
i := 1
for {
for {
if i > 5 {
println("跳出内层for循环")
break
}
fmt.Println("循环次数: ", i)
i++
}
fmt.Println("跳出外层for循环")
break
}
println()
fmt.Println(`
使用带标签的break语句,直接跳出最外层的for循环:
`)
t := 1
OuterLoop:
for {
for {
if t > 5 {
println("break标签跳出最内层循环.....")
break OuterLoop // 跳出OuterLoop标签对应的循环体
}
fmt.Println("循环次数: ", t)
t++
}
}
println()
println(`
continue继续循环:
continue可以立即结束当前循环体中的逻辑,开始下一次循环;
与break语句类似,continue语句之后也可跟标签,表示循环开始标签所对应的循环
`)
OuterLoopContinue:
for i := 0; i < 5; i++ {
for j := 0; j < 6; j++ {
if j == 1 {
fmt.Println(i, j)
continue OuterLoopContinue
}
}
}
}
运行效果：
GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToGrammar_go.exe D:\program_file\go_workspace\org.jd.data\ControlFlowToGrammar.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToGrammar_go.exe
Go语言的编程者需要通过流程控制语句来控制程序的逻辑走向和执行顺序.
流程控制语句主要包括: 条件判断语句(if和switch),
循环控制语句(for,break,continue和跳转语句goto)
101 > 100
if还有一种比较常见的写法,就是在if表达式前添加一个语句,使用变量接收语句返回的值，通过对该变量的判断在
选择执行的分支;这一点更python的 if条件判断类似,而java需要另外一
个变量来接收
程序使用的CPU核数为: 20
Go语言中的循环逻辑通过for关键字实现;不同于其他编程语言,Go语言没有while关键字,不存在while循环
for循环格式如下:
for 初始语句;条件表达式;赋值表达式 {
循环体
}
循环的次数： 1
循环的次数： 2
循环的次数： 3
循环的次数： 4
循环的次数： 5
循环的次数： 6
循环的次数： 7
循环的次数： 8
循环的次数： 9
break跳出循环：
break语言用来跳出for循环，而且可以在语句后面添加标签;表示退出标签对应
应的代码块逻辑;
注意: break语句如果不带标签,则默认跳出最内层的for循环
循环次数: 1
循环次数: 2
循环次数: 3
循环次数: 4
循环次数: 5
跳出内层for循环
跳出外层for循环
使用带标签的break语句,直接跳出最外层的for循环:
循环次数: 1
循环次数: 2
循环次数: 3
循环次数: 4
循环次数: 5
break标签跳出最内层循环.....
continue继续循环:
continue可以立即结束当前循环体中的逻辑,开始下一次循环;
与break语句类似,continue语句之后也可跟标签,表示循环开始标签所对应的循
循环
0 1
1 1
2 1
3 1
4 1
Process finished with the exit code 0
五: swith语句匹配认知
go语言中switch匹配模式认知升维:
(1)switch语句可以根据不同的条件匹配,来执行不同的case分支;从而简化了if ....elseif.....else.....多层嵌套
(2)switch语句默认,没有匹配到任何条件时,默认执行default分支;switch语句的执行过程从上到下,直到找到匹配项,匹配项后面也不需要在加break;
(3)每一个switch语句只能包含一个可选的default分支;
(4)switch语法如下:
switch express {
case value1:
分支代码块1
case value2:
分支代码块2
default:
默认值执行代码块
}
(5)默认情况下,switch匹配成功后就不会继续匹配其后面的case,如果我们需要无条件强制执行后面的case,可以使用fallthrough关键字
package main
import "fmt"
func main() {
println("===============================================================================")
println(`
go语言中switch匹配模式认知升维:
(1)switch语句可以根据不同的条件匹配,来执行不同的case分支;从而简化了if ....elseif.....else.....多层嵌套
(2)switch语句默认,没有匹配到任何条件时,默认执行default分支;switch语句的执行过程从上到下,直到找到匹配项,匹配项后面也不需要在加break;
(3)每一个switch语句只能包含一个可选的default分支;
(4)switch语法如下:
switch express {
case value1:
分支代码块1
case value2:
分支代码块2
default:
默认值执行代码块
}
(5)默认情况下,switch匹配成功后就不会继续匹配其后面的case,如果我们需要无条件强制执行后面的case,可以使用fallthrough关键字
`)
println("===============================================================================")
println()
switch 1 + 1 {
case 1:
fmt.Println("匹配到该条件：", "1+1=1")
case 2:
fmt.Println("匹配到该条件：", "1+1=2")
fallthrough
case 3:
fmt.Println("匹配到该条件：", "1+1=3")
fallthrough
case 4:
fmt.Println("匹配到该条件：", "1+1=4")
default:
fmt.Println("匹配到该条件：", "1+1不等于1或者2,3,4")
}
println("=========================演示使用fallthrough关键字,无条件执行后面的case语句===========================")
println("省略了switch关键字后面的表达式时,默认为布尔值true")
println()
switch { // 省略了表达式,只能匹配false与true,default者三种情况
// false肯定不会执行
case false:
fmt.Println("case 1为false")
// true肯定会执行
case true:
fmt.Println("case 2为false")
fallthrough
// 由于fallthrough关键字,索引default一定会被执行
default:
fmt.Println("默认执行case语句代码块.......")
}
}
运行效果：
gram_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToSwitchGrammar_go.exe D:\program_file\go_workspace\org.jd.data\ControlFlowToSwitchGrammar.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToSwitchGrammar_go.exe
===============================================================================
go语言中switch匹配模式认知升维:(1)switch语句可以根据不同的条件匹配,来执行不同的case分支;从而简化了if ....elseif.....else.....多层嵌套
(2)switch语句默认,没有匹配到任何条件时,默认执行default分支;switch语句的执行过程从上到下,直到找到匹配项,匹配项后面也不需要在加break;
(3)每一个switch语句只能包含一个可选的default分支;
(4)switch语法如下:
switch express {
case value1:
分支代码块1
case value2:
分支代码块2
default:
默认值执行代码块}
(5)默认情况下,switch匹配成功后就不会继续匹配其后面的case,如
果我们需要无条件强制执行后面的case,可以使用fallthrough关键字===============================================================================
匹配到该条件： 1+1=2
匹配到该条件： 1+1=3
匹配到该条件： 1+1=4
=========================演示使用fallthrough关键字,无条件执行后面的case语句=====
=======================
省略了switch关键字后面的表达式时,默认为布尔值truecase 2为false
默认执行case语句代码块.......Process finished with the exit code 0
六: goto跳转认知
goto语言用于代码间的无条件跳转,格式如下:
goto 标签
一般情况下,在程序中不建议使用goto语句,过多的goto语句会破坏程序结构,使程序可读性变差..............
package main
import (
"fmt"
)
func main() {
println(`
goto语言用于代码间的无条件跳转,格式如下:
goto 标签
一般情况下,在程序中不建议使用goto语句,过多的goto语句会破坏程序结构,使程序可读性变差..............
`)
fmt.Println("=========================goto 标签 无条件跳转===========================")
goto sign
fmt.Println("无效代码,不会被执行....")
sign:
fmt.Println("跳过sign标签之间的代码,弯道超车 .................")
goto start
println("goto start标签会执行吗")
start:
println("=================跳过了start标签了吗=======================")
}
运行效果：
GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToGotoGrammar_go.exe D:\program_file\go_workspace\org.jd.data\ControlFlowToGotoGrammar.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToGotoGrammar_go.exe
goto语言用于代码间的无条件跳转,格式如下:
goto 标签
一般情况下,在程序中不建议使用goto语句,过多的goto语句会破坏程序结构,使程
序可读性变差..............=========================goto 标签 无条件跳转===========================
跳过sign标签之间的代码,弯道超车 .................
=================跳过了start标签了吗=======================Process finished with the exit code 0
