一、第一个程序

1.代码示例

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func main(){
  8.     fmt.Println("hello world")
  9. }

2.手动执行
go run xx.go
3.编译为可执行程序
go build -o xx.exe xx.go
4.代码格式调整
idea：Ctrl+Alt+L
命令行： gofmt -w xxx.go

注意：如果在windows开发后需要打包成在linux可执行程序每次都需执行以下三步
set ENABLECGO=0 //该配置不是必须，请根据实际配置
set GOARCH=amd64
set GOOS=linux
go build -o xxx xx.go

二、语法要求

1.命名规范
1) package 名称要与文件名相同
2) 变量、函数名 严格区分大小写，首字母大写为公有(public)，小写为私有(private)
3) _表示省略返回值

2.变量定义

  1. //局部变量定义必须被引用，否则程序会报错
  2. var a = 1
  3. var c int = 1
  4. //：只可定义局部变量，不可定义全局
  5. b := 1
  6. //批量定义
  7. var (
  8.   d = 1
  9.   f = 1
  10. )
  11. //常量定义，不可被改变
  12. const FIRST_NUM = 1
  13. //const结合iota
  14. const (
  15.   //iota默认为0，SECOND_NUM值为0
  16.   SECOND_NUM = iota  
  17.   //定义iota后，下面的变量可不主动赋值，默认会根据iota+=1进行赋值，THREE_NUM值为1
  18.   THREE_NUM  
  19.   //这里iota会遵从iota+=1的原则变为2，然后乘以10，最后赋值为20
  20.   FOUR_NUM = iota * 10  
  21.   /*这里iota的值增长规则不变，还是iota+=1，这里iota值为3，由于上一步附加了*10的规则，
  22.   这里FIVE_NUM值为30*/
  23.   FIVE_NUM      
  24. )

3.变量转换

  1. package main
  3. import (
  4.     "fmt"
  5.     "strconv"
  6. )
  8. func main(){
  9.     //类型转换需要进行显示的转换
  10.     var i  = 100
  11.     var fi = float32(i)
  12.     fmt.Println(fi)
  13.     fmt.Printf("fi的类型为：%T",fi)
  14.     fmt.Println()
  15.     //int转字符串，参数一表示要转换的值，参数2表示转换的结果为几进制
  16.     var strNum = strconv.FormatInt(10,10)
  17.     fmt.Println(strNum)
  18.     fmt.Printf("strNum的类型为：%T",strNum)
  19.     fmt.Println()
  20.     //字符转转int，参数一为要转换的值，参数二为转换的结果为几进制，
  21.     //参数三bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64
  22.     var intNum, _ = strconv.ParseInt(strNum,2,0)
  23.     fmt.Println(intNum)
  24.     fmt.Printf("strNum的类型为：%T",intNum)
  25.     fmt.Println()
  26. }

4.指针

  1. package main
  3. import "fmt"
  5. func changeValue1(p *int) {
  6.     //*p 指向地址存储的值
  7.     *p = 10
  8. }
  10. func changeValue2(p int) {
  11.     //p为局部变量，会创建新的地址
  12.     p = 100
  13. }
  14. func main() {
  15.     var a = 1
  16.     //&a 获取a变量的指针地址
  17.     changeValue1(&a)
  18.     changeValue2(a)
  19.     fmt.Println(a) //最终结果为10
  21.     //指针类型的变量同样有地址，因此出现多重指针
  22.     var pp = **int
  23.     var p = &a
  24.     pp = &p
  25. }
  27. //make和new的区别
  28. //make和new都是用来申请内存的
  29. //make是给map、slice、chan进行内存申请的，返回的是对象本身。
  30. //new是给string、int等基本数据类型进行内存申请的，返回的是对应的指针类型，很少用

5.函数返回值

  1. package main
  3. import (
  4.     "fmt"
  5. )
  6. //无参数返回
  7. func foo1(var1 int,var2 string)  {
  8.     fmt.Println("----foo1----")
  9.     fmt.Println(var1,var2)
  10. }
  11. //返回一个参数
  12. func foo2(var1 int,var2 string) int {
  13.     fmt.Println("----foo2----")
  14.     fmt.Println(var2)
  15.     return var1
  16. }
  17. //返回多个参数
  18. func foo3(var1 int,var2 string) (int,string) {
  19.     fmt.Println("----foo3----")
  20.     return var1,var2
  21. }
  22. //返回多个同类型参数,并对参数命名
  23. func foo4(var1,var2 int) (r1,r2 int) {
  24.     fmt.Println("----foo4----")
  25.     fmt.Println("r1=",r1,",r2=",r2)
  26.     //当给返回参数命名后，该返回结果会默认为整个函数的局部变量，并赋予默认值.
  27.     //若返回参数命名后可直接使用 return r1,r2，也可直接return
  28.     return var1,var2
  29. }
  30. func main(){
  31.     foo1(100,"无参数返回")
  32.     foo2Num := foo2(100,"返回一个参数")
  33.     fmt.Println(foo2Num)
  34.     foo3Num, foo3Str := foo3(100, "返回多个参数")
  35.     fmt.Println(foo3Num, foo3Str)
  36.     foo4Num1, foo4Num2 := foo4(1,2)
  37.     fmt.Println(foo4Num1, foo4Num2)
  38.     //_表示丢弃返回结果，直接垃圾回收
  39.     _,_ = foo4(1,2)
  40. }

6.init函数和import的导包流程
import->const->var->init->main
image.png
7.import 导包

  1. package main 
  2. //两个包不可相互依赖，例如：
  3. //A依赖B，B依赖A，如果出现该情况会报import cycle not allowed的错误
  5. import (
  6.     //正常导包
  7.     "fmt"
  8.     //匿名导包，只会默认调用包内的init函数，其他函数无法调用
  9.     _ "xxx"
  10.     //别名导包，可以使用别名进行保内的函数调用
  11.     mylib "xxx"
  12.     //本地导包，无需使用别名，直接使用函数名即可调用保内函数
  13.     . "xxxx"
  14. )

8.defer关键字 （最后执行）

  1. package main
  3. import "fmt"
  5. func return1() int {
  6.     fmt.Println("--------return 1----------")
  7.     return 1
  8. }
  10. func return2() int {
  11.     fmt.Println("--------return 2----------")
  12.     return 2
  13. }
  15. func execReturn() int {
  16.     defer return1()
  17.     //这里return 分为执行函数，返回结果两部，defer语句在这两步中间执行
  18.     return return2()
  19. }
  20. func main() {
  21.     defer fmt.Println("defer表示该语句最后执行，我相当于java的finally")
  22.     defer fmt.Println("我是第二个defer,defer是先进后出，因此我不能最后打印")
  23.     fmt.Println("我想最后执行")
  24.     fmt.Println(execReturn())
  25. }

9.数组以及slice(动态数组)

  1. package main
  3. import "fmt"
  5. //数组，值传递无法修改原数组的值
  6. func printArray1(array [4]int) {
  7.     fmt.Println("普通数组")
  8.     for index, value := range array {
  9.         fmt.Println("index=", index, "value=", value)
  10.     }
  11. }
  13. //slice（动态数组）,引用传递
  14. func printArray2(array []int) {
  15.     fmt.Println("slice-动态数组")
  16.     for index, value := range array {
  17.         fmt.Println("index=", index, "value=", value)
  18.     }
  19.     array[1]=1000
  20. }
  22. func main() {
  23.     //定义数组
  24.     var array1 [4]int
  25.     var array2 = [4]int{1, 2, 3, 4}
  26.     var array3 = []int{1, 2, 3, 4}
  27.     printArray1(array1)
  28.     printArray1(array2)
  29.     printArray2(array3)
  30.     fmt.Println("slice可以在函数中修改值")
  31.     for index, value := range array3 {
  32.         fmt.Println("index=", index, "value=", value)
  33.     }
  34. }

10.slice是使用注意事项

  1. package main
  3. import "fmt"
  5. func printArray(array []int) {
  6.     fmt.Println("-------------分割线------------")
  7.     for index, value := range array {
  8.         fmt.Println("index=", index, "value=", value)
  9.     }
  10. }
  12. func main() {
  13.     //slice声明的方式
  14.     //方式一:声明一个slice，并非配两个空间，值为1,2
  15.     array1 := []int{1, 2}
  16.     printArray(array1)
  17.     //方式二:声明一个slice，未分配空间,通过append分配空间并增加数值,默认值为nil
  18.     var array2 []int
  19.     printArray(array2)
  20.     //方式三:通过make创建一个slice为slice分配指定大小空间，并设置初始扩容的cap值为10
  21.     //如果不传入cap，初始cap与len相同
  22.     //当len的大小超过cap时，cap会进行2倍扩容，当cap的数字大于1024后每次扩容以1.25倍进行扩容
  23.     var array3 = make([]int, 1, 10)
  24.     printArray(array3)
  25.     if array3 == nil {
  26.         fmt.Println("slice为nil")
  27.     } else if len(array3) == 10 {
  28.         fmt.Println("slice长度为10")
  29.     } else {
  30.         fmt.Println("slice不为nil")
  31.     }
  33.     //slice的使用
  34.     //slice截取数组
  35.     array4 := make([]int, 0)
  36.     //追加数组元素
  37.     array4 = append(array4, 1)
  38.     array4 = append(array4, 2)
  39.     array4 = append(array4, 3)
  40.     array4 = append(array4, 4)
  41.     //删除数组元素，表示将下标为1的元素删除，然后用下表为2的元素进1
  42.     array4 = append(array4[:1], array4[2:]...)
  43.     fmt.Println(len(array4))
  44.     printArray(array4)
  45.     //通过截取数组进行赋值，传递的是值引用，不是值，这里与python的规则不同，python传递的是值
  46.     //如果想要值传递需要使用copy函数
  47.     //在截取数据时，会以cap的数量为限定进行截取，比如len为3，cap为6你可以截取6个元素而不是3个
  48.     //在截取数据前当原数组未进行删除时，大于len元素默认会赋值为0
  49.     //如果原数组有进行删除，大于len的元素会以原数组未删除前下标的元素进行赋值不在为0
  50.     fmt.Println(len(array4),cap(array4),&array4)
  51.     array5 := array4[0:4]
  52.     fmt.Println(len(array5),cap(array5),&array5)
  53.     array5[0] = 100
  54.     printArray(array4)
  55.     printArray(array5)
  56.     var array6 = make([]int,3)
  57.     //通过copy进行slice深拷贝时，array6必须已分配等同的空间，否则会报错
  58.     copy(array6, array4)
  59.     array6[1] = 200
  60.     printArray(array6)
  61. }

11.map使用

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. //遍历
  8. func printMap(myMap map[string]string) {
  9.     for key, value := range myMap {
  10.         fmt.Println("key=", key, ",value=", value)
  11.     }
  12. }
  14. //删除
  15. func deleteMap(myMap map[string]string, key string) {
  16.     delete(myMap, key)
  17. }
  18. //新增
  19. func addMap(myMap map[string]string, key string, value string) {
  20.     myMap[key] = value
  21. }
  22. //修改
  23. func updateMap(myMap map[string]string, key string, value string) {
  24.     myMap[key] = value
  25. }
  26. func main() {
  27.     //map的声明方式
  28.     //方式一
  29.     var map1 map[string]string
  30.     if map1 == nil {
  31.         fmt.Println("map为空")
  32.     }
  33.     //方式二
  34.     map2 := make(map[string]string, 10)
  35.     map2["one"] = "first"
  36.     //方式三
  37.     map3 := map[string]string{
  38.         "one": "first",
  39.         "two": "second",
  40.     }
  41.     deleteMap(map3,"one")
  42.     printMap(map1)
  43.     printMap(map2)
  44.     printMap(map3)
  45. }

12.struct(结构体)

  1. package main
  3. import "fmt"
  5. // User 自定义结构体
  6. type User struct {
  7.     name string
  8.     age  int
  9. }
  11. //结构提函数传递为值传递，因此需要设置指针专递才可修改结构体属性
  12. func changeUser(user *User) {
  13.     user.age = 100
  14. }
  16. //类比于上方法，区别在于该方法属于struct结构体的方法,结构液体传递在这里同意规范使用指针传递
  17. //如果值传递，方法内对该结构体值进行修改不可同步至方法外边指针
  18. func (u *User)ChangeUser(){
  19.     u.age=10
  20. }
  22. func main() {
  23.     //定义结构体方式
  24.     //方式一
  25.     var user User
  26.     user.name = "名字"
  27.     user.age = 24
  28.     //方式二
  29.     var user1 = User{name:"名字",age:24}
  30.     //方式三
  31.     var user2 = User{"名字",24}
  32.     fmt.Println(user)
  33.     fmt.Println(user1)
  34.     fmt.Println(user2)
  35.     changeUser(&user)
  36.     fmt.Println(user)
  37.     //匿名结构体定义
  38.     var  u struct{
  39.         Name string
  40.     }
  41.     u.Name="222"
  42.     fmt.Println(u)
  44. }

13.interface
interface更多使用，请参考面向对象多态

  1. package main
  3. import "fmt"
  5. //interface{}是万能数据类型
  6. func myFunc(arg interface{}) {
  7.     fmt.Println("arg =", arg)
  8.     //校验数据类型
  9.     value, result := arg.(string)
  10.     if result {
  11.         fmt.Println("是字符串", value)
  12.     } else {
  13.         fmt.Println("不是字符串", value)
  15.     }
  16. }
  18. func main() {
  19.     myFunc(100)
  20.     myFunc("string")
  21. }