本人专科!在太原干了一年了,想从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 mainimport "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 = 40a = 30fmt.Println("a = ", a)
//c :=30 == var a int = 40 常用c := 30fmt.Printf("param type is %T\n", c)

2.1.2 两个变量互换位置

 i, j := 10, 20i, j = j, ifmt.Printf("i= %d,j = %d\n", i, j)

2.1.3 匿名函数互换位置

//匿名函数 _函数配合函数 返回值使用q, w := 10, 20q, _ = w, qfmt.Printf("q= %d\n", q)

2.1.4 函数调用

//go函数可以返回多个值
func test() (a, b, c int) {return 1, 2, 3
}
//调用函数var c, d, e intc, d, e = test() //return 1,2,3

2.1.5 匿名函数调用

 //匿名函数_, d, _ = test() //return 1,2,3fmt.Printf("c =%d ， d =%d ,e =%d\n", c, d, e)

2.1.6 常量关键字 const

 const a int = 10fmt.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 //0b = iota //1c = iota //2)fmt.Printf("a =%d,b =%d ,c =%d", a, b, c)

2.1.7.3 iota遇到const，重置为0

//3.iota遇到const，重置为0const d = iota //0fmt.Printf("d =%d\n", d)

2.1.8 字符串

 package mainimport "fmt"func main() {var str1 stringstr1 = "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.14ifmt.Println("t =", t)//自动推导类型t2 := 3.3 + 4.4ifmt.Printf("t2 type is %T\n", t2)//通过内建函数，取实部和虚部fmt.Println("real t2 = ", real(t2))

2.1.10 类型别名

 type bigint int64var a biginttype (long int64char byte)var b long = 11var 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类型

 //Endfmt.Println("1111")goto Endfmt.Println("222")
End:fmt.Println("333")

##2.2

2.2.1函数定义(无返回值)

func Myfunc() {a := 111fmt.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 = amix = breturn //有返回值的函数,必须通过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 intvar TestF = FuncTypeTestF = minFresult = 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 := 10b := 20//1.定义匿名函数f1 := func() {fmt.Println("a = ", a)fmt.Println("b = ", b)}//2.匿名函数类型type FuncType1 func()var f2 FuncType1f2 = f1f2()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 = imin = jreturn  }(10,20)}

2.2.5闭包匿名函数变量

func test2() func() int {var x int //没有初始化,值为0return func() int {x++return x * x}
}func main() {f := test2()//闭包-不关心变量和常量是否已经超出作用于//只要闭包还在使用它,这些变量就还存在fmt.Println(f()) //1fmt.Println(f()) //4fmt.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 成 exelist := os.Argsn := 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 = 10fmt.Printf("a = %d\n ", num)fmt.Printf("a = %v\n ", &num)//保存变量的地址 需要指针类型var p *intp = &numfmt.Printf("p = %v\n ,&a = %v\n ", p, &num)

2.3.2默认值 nil new函数

 var p *intp = nilfmt.Println("平= ", p)//p := new(int)*p = 777

2.3.3数组定义赋值

func main() {var arr [20]intfor i := 0; i < len(arr); i++ {arr[i] = i + 1fmt.Printf("arr[%d] = %d\n", i, arr[i])}//数组定义 置值,其他值为0arr1 := [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)) //长度 3fmt.Println("s cap =", cap(s)) //容量 5//创建切片b := []int{}//给切片追加一个成员b=append(b,11)//不写默认0 从0开始取3个元素.容量为 5-0s := 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)
}//创建mapvar map1 map[int]stringfmt.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所对应的valuevalue, ok := m[1]if ok == true {fmt.Printf("m[1] =", value)} else {fmt.Printf("key不存在")}

2.3.8 结构体

type Student struct {id   intname stringsex  byteage  intaddr 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.Studentfmt.Println(s4)//&{1 make 109 20 背景}//先定义在赋值var stu1 Studentstu1.id = 1stu1.name = "mike"stu1.sex = '5'fmt.Println(stu1) //{1 mike 53 0 }//new申请stu2 := new(Student)stu2.id = 1stu2.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 指针，十六进制方式显示

专科 java转go 翱翔之路(一)基础语法:变量声明,匿名函数,结构体,函数,map相关推荐

专科 java转go 翱翔之路(二)基础语法:匿名组合,方法,接口,map,json,异常处理,channel管道,select用法
2.4 面向对象编程 2.4.1匿名组合 type Person struct {id intname stringage int }type Student struct {Person //只有类 ...
专科 java转go 翱翔之路(四)协议通信锁，互斥锁读写锁条件变量锁连接mysql 查询
2.7.5 2.7.5.1 协议通信过程应用层 hello 传输层(udp tcp) 源port 目的端口 hello 网络层(ip) 源ip 目的ip 源port 目的端口 hello 链路层(m ...
专科 java转go 翱翔之路(三)开发工具:goland2019.1安装一键到2089年试用期
goland 2020年版本不行,最多到2019版本可用 1.下载goland2019.1 https://www.jetbrains.com/go/download/other.html 2.下载补 ...
第三次学JAVA再学不好就吃翔(part4)--基础语法之变量
学习笔记,仅供参考文章目录 JAVA基础语法变量数据类型 JAVA基础语法变量什么是变量在程序执行的过程中,在某个范围内其值可以发生改变的量变量的定义格式数据类型变量名 = 变量值; ...
PHP从入门到跑路(二),基础语法，数据库操作
基础语法前言一, 变量定义及使用二,数据库操作三, php开发细节躺坑前言博主不会php, 是从JAVA转过来的, PHP教程总结实际开发使用, 更加偏向于实际, 理论比较薄弱, 一直想总 ...
第三次学JAVA再学不好就吃翔(part15)--基础语法之控制跳转语句
学习笔记,仅供参考文章目录 JAVA基础语法 break语句 continue语句标号 return语句 JAVA基础语法 break语句应用场景只能在switch和循环中使用举个例子 cl ...
第三次学JAVA再学不好就吃翔(part14)--基础语法之循环语句注意事项
学习笔记,仅供参考文章目录 JAVA基础语法 for, while, do...while的区别死循环循环嵌套 JAVA基础语法 for, while, do-while的区别 do-while ...
第三次学JAVA再学不好就吃翔(part13)--基础语法之while循环语句
学习笔记,仅供参考文章目录 JAVA基础语法 while语句 do...while语句 JAVA基础语法 while语句格式初始化语句; while(判断条件语句) {循环体语句;控制条件语句; ...
第三次学JAVA再学不好就吃翔(part12)--基础语法之for循环语句
学习笔记,仅供参考 JAVA基础语法 for循环语句格式 for(初始化表达式;条件表达式;循环后的操作表达式) {循环体;} 执行流程 ①执行初始化表达式: ②执行条件表达式,看其返回值是true ...

专科 java转go 翱翔之路(一)基础语法:变量声明,匿名函数,结构体,函数,map

本人专科!在太原干了一年了,想从java转go,上班中自学go,明年找go语言相关的工作 立帖为证! 待羽翼丰满,大风到来,便是我翱翔之时!!!