专科 java转go 翱翔之路(一)基础语法:变量声明,匿名函数,结构体,函数,map
本人专科!在太原干了一年了,想从java转go,上班中自学go,明年找go语言相关的工作 立帖为证! 待羽翼丰满,大风到来,便是我翱翔之时!!!
1.Go语言
1.命令
1.1 查看版本号
go version
1.2 查看安装信息
go env
2.资料
2.1 官方文档
https://studygolang.com/pkgdoc
2.2 md 语法
https://www.appinn.com/markdown/
2.3 go环境的安装
官网安装包下载地址为：https://golang.org/dl/
如果打不开可以使用这个地址：https://golang.google.cn/dl/
2.4注意事项
1.把liteIDEA放到go安装的根目录下
2.ctrl+F7 编译运行
3.helloWorld函数
package main
import "fmt"
func main() {
fmt.Println("hello go")
}
2.语法
2.1
2.1声明变量
var a int
fmt.Println("a = ",a)
2.1.1 声明变量特殊语法（常用）
var a int = 40
a = 30
fmt.Println("a = ", a)
//c :=30 == var a int = 40 常用
c := 30
fmt.Printf("param type is %T\n", c)
2.1.2 两个变量互换位置
i, j := 10, 20
i, j = j, i
fmt.Printf("i= %d,j = %d\n", i, j)
2.1.3 匿名函数互换位置
//匿名函数 _函数配合函数 返回值使用
q, w := 10, 20
q, _ = w, q
fmt.Printf("q= %d\n", q)
2.1.4 函数调用
//go函数可以返回多个值
func test() (a, b, c int) {
return 1, 2, 3
}
//调用函数
var c, d, e int
c, d, e = test() //return 1,2,3
2.1.5 匿名函数调用
//匿名函数
_, d, _ = test() //return 1,2,3
fmt.Printf("c =%d ， d =%d ,e =%d\n", c, d, e)
2.1.6 常量关键字 const
const a int = 10
fmt.Printf("a =%d", a)
const b = 11.2
2.1.7 枚举iota
2.1.7.1 iota常量自动生成器，每个一行，自动累加1
2.1.7.2 iota给常量赋值使用
//1.iota常量自动生成器，每个一行，自动累加1
//2.iota给常量赋值使用
const (
a = iota //0
b = iota //1
c = iota //2
)
fmt.Printf("a =%d,b =%d ,c =%d", a, b, c)
2.1.7.3 iota遇到const，重置为0
//3.iota遇到const，重置为0
const d = iota //0
fmt.Printf("d =%d\n", d)
2.1.8 字符串
package main
import "fmt"
func main() {
var str1 string
str1 = "abc"
fmt.Println("str1 = ", str1)
//自动推导类型
str2 := "make"
fmt.Println("str2 =", str2)
//内建函数 长度
fmt.Println("len(str2) =", len(str2))
}
2.1.9 复数
var t complex128 //声明
t = 2.1 + 3.14i
fmt.Println("t =", t)
//自动推导类型
t2 := 3.3 + 4.4i
fmt.Printf("t2 type is %T\n", t2)
//通过内建函数，取实部和虚部
fmt.Println("real t2 = ", real(t2))
2.1.10 类型别名
type bigint int64
var a bigint
type (
long int64
char byte
)
var b long = 11
var ch char = 'a'
fmt.Printf("b = %d, ch = %c\n", b, ch)
2.1.11 if类型
//if类型 初始化变量 当a=10时,跳转到括号
if a := 10; a == 10 {
fmt.Println("a =", 10)
}
2.1.11 range类型(迭代)
for i := 0; i < len(str); i++ {
fmt.Printf("str[%d] = %c\n", i, str[i])
}
fmt.Println("------")
//i是下标
for i, data := range str {
fmt.Printf("str[%d]=%c\n", i, data)
}
fmt.Println("------")
for i := range str {
fmt.Printf("str[%d]=%c\n", i, str[i])
}
for i, _ := range str {
fmt.Printf("str[%d]=%c\n", i, str[i])
}
2.1.12 goto类型
//End
fmt.Println("1111")
goto End
fmt.Println("222")
End:
fmt.Println("333")
##2.2
2.2.1函数定义(无返回值)
func Myfunc() {
a := 111
fmt.Println("无参= ", a)
}
func Myfunc1(a int) {
fmt.Println("有参= ", a)
}
func Myfunc2(a int, b int) {
fmt.Printf("a = %d,b=%d\n", a, b)
}
func Myfunc3(a string, b int, c float32) {
fmt.Printf("a = %d,b=%d,c = %d \n,", a, b, c)
}
func main() {
Myfunc()
Myfunc1(222)
Myfunc2(333, 444)
Myfunc3("555", 666, 777.1)
}
2.2.2函数定义(有返回值)
//有返回值
func Myfunc2(a int, b int) (max int, mix int) {
max = a
mix = b
return //有返回值的函数,必须通过return返回
}
func main() {
var a int
_, a = Myfunc2(333, 444)
fmt.Println("a=", a)
}
2.2.3函数类型
func addF(a int, b int) int {
return a + b
}
func minF(a int, b int) int {
return a - b
}
//定义函数类型
//FuncType是一个函数类型
type FuncType func(int, int) int //没有函数名字 没有{}
func main() {
var result int
var TestF = FuncType
TestF = minF
result = TestF(20, 10)
fmt.Println("a=", result)
}
2.2.4函数类型(回调函数,多态)
func add(a int, b int) int {
return a + b
}
//
func addF(a int, b int, dtest FuncType) (result int) {
result = dtest(a, b)
return
}
//定义函数类型
//FuncType是一个函数类型
type FuncType func(int, int) int //没有函数名字 没有{}
func main() {
a := addF(1, 1, add)
fmt.Println("a =", a)
}
2.2.5匿名函数+闭包
func main() {
a := 10
b := 20
//1.定义匿名函数
f1 := func() {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
}
//2.匿名函数类型
type FuncType1 func()
var f2 FuncType1
f2 = f1
f2()
fmt.Println("a =", a)
//3.定义匿名函数
func() {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
}()//()表示调用此函数
//4 有参匿名函数
f4 := func(a,b int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
}
f4(4,5)
//5.无名匿名带参数
func(a,b int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
}(5,6)//()表示调用此函数
//6.匿名函数有参有返回值
x,y = func(i,j int)(max,min int){
max = i
min = j
return
}(10,20)
}
2.2.5闭包 匿名函数 变量
func test2() func() int {
var x int //没有初始化,值为0
return func() int {
x++
return x * x
}
}
func main() {
f := test2()
//闭包-不关心变量和常量是否已经超出作用于
//只要闭包还在使用它,这些变量就还存在
fmt.Println(f()) //1
fmt.Println(f()) //4
fmt.Println(f()) //9
}
2.2.6 defer的使用
//defer延迟调用 main函数结束前调用
defer fmt.Println("bbb")
fmt.Println("aaaaa")
//有多个defer语句,则是 先进后出 哪怕函数出错 依旧会执行
defer fmt.Println("111")
defer fmt.Println("222")
defer fmt.Println("333")
//匿名函数表示,把变量赋值过去 但是没有调用
defer func(a,b int){
fmt.Printf("a = %d ,b = %c\n",a,b)
}(10,20)
2.2.7 获取命令行参数
func main() {
//要先go build 成 exe
list := os.Args
n := len(list)
fmt.Println("n =", n)
for i := 0; i < n; i++ {
fmt.Printf("list[%d] = %s\n", i, list[i])
}
for i, data := range list {
fmt.Printf("list[%d] = %s\n", i, data)
}
}
2.2.8 变量
1.不同作用域可以有同名变量
2.使用变量的原则,就近原则
2.2.9 导入导出包
//给包起别名
import io "fmt"
io.Println("起别名")
//忽略包
import _ "fmt"
2.2.10 init函数
先执行 init函数 在执行main函数
2.3 复合类型
2.3.1声明变量 指针类型
//变量两含义 1内存 2地址
var num int = 10
fmt.Printf("a = %d\n ", num)
fmt.Printf("a = %v\n ", &num)
//保存变量的地址 需要指针类型
var p *int
p = &num
fmt.Printf("p = %v\n ,&a = %v\n ", p, &num)
2.3.2默认值 nil new函数
var p *int
p = nil
fmt.Println("平= ", p)
//
p := new(int)
*p = 777
2.3.3数组定义赋值
func main() {
var arr [20]int
for i := 0; i < len(arr); i++ {
arr[i] = i + 1
fmt.Printf("arr[%d] = %d\n", i, arr[i])
}
//数组定义 置值,其他值为0
arr1 := [5]int{1, 2, 3}
//指定位置赋值
arr2 := [5]int{2: 1, 3: 4}
fmt.Println(arr2)
}
2.3.4 随机数
import "fmt"
import "time"
import "math/rand"
func main() {
//设置随机数种子
rand.Seed(time.Now().UnixNano()) //当前的系统执行时间
for i := 0; i < 5; i++ {
fmt.Println("rand =", rand.Intn(100))
}
}
2.3.5数组指针
import "fmt"
import "time"
import "math/rand"
//数组指针
//*p 代表指针所指向的内存,就是实参
func modify(p *[5]int) {
//p[0] = 66
(*p)[0] = 666
}
2.3.6切片spilt
func main() {
a := []int{1, 2, 3, 54, 5, 7, 89, 6}
//[low:high:max]
//下标起点 下标终点 (左闭右开) 容量(max-low)
s := a[0:3:5]
fmt.Println("s = ", s) //[1 2 3]
fmt.Println("s len =", len(s)) //长度 3
fmt.Println("s cap =", cap(s)) //容量 5
//创建切片
b := []int{}
//给切片追加一个成员
b=append(b,11)
//不写默认0 从0开始取3个元素.容量为 5-0
s := a[:3:5]
}
2.3.6切片切切片
//切片切切片
a := []int{1, 2, 3, 4, 5, 7, 8, 9}
s1 := a[1:3] //[2,3]
fmt.Println("s1 =", s1)
s2 := s1[1:5] //[3,4,5,7]
fmt.Println("s1 =", s2)
2.3.7 copy函数
a := []int{1, 2, 3, 4, 5}
b := []int{6, 7, 8, 9, 10, 11}
copy(a, b)
fmt.Println("a =", a) //{6, 7, 8, 9, 10}
fmt.Println("b =", b) //{6, 7, 8, 9, 10,11}
2.3.7 map
2.3.7.1 map的定义
func deleMap(mapV map[int]string) {
delete(mapV, 1)
}
//创建map
var map1 map[int]string
fmt.Println("a =", map1) //{6, 7, 8, 9, 10}
//通过make创建
map2 := make(map[int]string)
map2[1] = "make"
map2[2] = "sss"
//定义初始化
map3 := map[int]string{1: "a", 2: 'b'}
//删除
delete(map3, 1)
fmt.Println(map3)
//定义函数
deleMap(map3)
2.3.7.2 map的循环
//定义初始化
map3 := map[int]string{1: "a", 2: "b"}
//循环
for key, value := range map3 {
fmt.Printf("%d =====>%s\n", key, value)
}
//判断一个Key值是否存在
//第一个返回值为key所对应的value
value, ok := m[1]
if ok == true {
fmt.Printf("m[1] =", value)
} else {
fmt.Printf("key不存在")
}
2.3.8 结构体
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
var s1 Student = Student{1, "make", 'm', 20, "背景"}
fmt.Println(s1)//{1 make 109 20 背景}
//指定声明
s2 := Student{name: "make", addr: "背景"}
fmt.Println(s2)//{0 make 0 0 背景}
//声明指针变量
s3 := &Student{name: "make", addr: "背景"}
fmt.Println(s3)//&{0 make 0 0 背景}
var s4 *Student = &Student{1, "make", 'm', 20, "背景"}
fmt.Printf("s4 type= %T\n", s4)//s4 type= *main.Student
fmt.Println(s4)//&{1 make 109 20 背景}
//先定义在赋值
var stu1 Student
stu1.id = 1
stu1.name = "mike"
stu1.sex = '5'
fmt.Println(stu1) //{1 mike 53 0 }
//new申请
stu2 := new(Student)
stu2.id = 1
stu2.name = "mike"
stu2.sex = '5'
fmt.Println(stu2) //&{1 mike 53 0 }
}
2.3.9 可见性
如果想使用别的包的函数,结构体类型,结构体成员,函数名,类型名,结构体成员变量名
首字母必须大写,可见
如果首字母小写,只能能在同一个包里使用
通用
1.fmt.Sprintf (格式化输出)
%v 按值的本来值输出
%+v 在 %v 的基础上，对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%T 输出 Go 语言语法格式的类型和值
%% 输出 %% 本体
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以 十六进制显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%f 浮点数
%p 指针，十六进制方式显示
53 0 }
}
### 2.3.9 可见性
如果想使用别的包的函数,结构体类型,结构体成员,函数名,类型名,结构体成员变量名
**首字母必须大写,可见**
如果首字母小写,只能能在**同一个包里使用**
# 通用
## 1.fmt.Sprintf (格式化输出)
%v 按值的本来值输出
%+v 在 %v 的基础上，对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%T 输出 Go 语言语法格式的类型和值
%% 输出 %% 本体
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以 十六进制显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%f 浮点数
%p 指针，十六进制方式显示