本篇文章为大家展示了如何入门Golang开发，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。

十年的东宁网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都营销网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整东宁建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联从事“东宁网站设计”,“东宁网站推广”以来，每个客户项目都认真落实执行。

1 流程控制

1.1 switch控制流程

1.1.1 基本语法

switch 表达式 {

case 表达式1, 表达式2.....：

语句块1

case 表达式3,表达式4.....：

语句块2

default:

语句块

}

1.1.2 注意细节

1）Golang 中switch的case后可以匹配多个表达式，用逗号间隔

2）Golang中case语句块后不需要break来显示跳出，程序在匹配到后执行完语句块会自动跳出switch

3）case后是一个表达式（即：常量、变量、一个有返回值的函数等）

4）case后面的表达式如果是常量，则要求不能重复

5）case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致

6）switch后可以不带表达式，类似if-else分支，如

7）switch后也可以直接声明/定义一个变量，分号结束，不推荐

8）switch穿透-fallthrough, 如果在case语句块后增加fallthrough，则会继续执行下一个case，这也叫switch穿透

9）Type switch：switch语句还可被用于Type-switch来判断某个interface变量中实际指向的变量类型，如下

1.2 for循环

1.2.1 注意细节

1）for循环的几种写法

func main() {
  for i := 0; i <= 10; i++ {
    fmt.Println("你好")
  }
}

func main() {
  var i int8 = 0
  for i <= 10 {
    fmt.Println("你好")
    i++
  }
}

func main() {
    //死循环，通常需要配合break一起使用
  for {
    fmt.Println("你好")
  }
}

2）Golang提供了for-range的方式，可以方便遍历字符串和数组，如

func main() {
  var str string = "hello北京"
  //使用传统的方式遍历字符串
  for i := 0; i < len(str); i++ {
    fmt.Printf("i:%d, val:%c\n", i, str[i])
  }
    
    fmt.Println("---------------------------")

  //使用for-range方式遍历字符串
  for index, val := range str {
    fmt.Printf("index:%d, val:%c\n", index, val)
  }
}

从输出结果来看，使用传统的方式遍历会包含中文的字符串会出现乱码，但是使用for-range的方式则正常

结论：传统for循环遍历字符串时，是按字节来遍历的，而for-range的方式是按字符来遍历的

3）Golang中没有while，do while语法

1.3 goto语句

go语言的goto语句可以直接跳转到程序中指定的行，一般不推荐使用goto语句，以免造成程序流程的混乱，使理解与调试程序都产生困难

func main() {
  fmt.Println("hello word1")
  goto label0
  fmt.Println("hello word2")
  fmt.Println("hello word3")
  label0:
  fmt.Println("hello word4")
}

2 函数

2.1 基本语法

func 函数名 （形参列表）（返回值类型列表）{

语句块

return 返回值列表

}

func cal(n1 float64, n2 float64, operation byte) float64 {
  var res float64
  switch operation {
    case '+':
      res = n1 + n2
    case '-':
      res = n1 - n2
    case '*':
      res = n1 * n2
    case '/':
      res = n1 / n2
    default:
      fmt.Println("输入错误")
    
  }
  return  res
}

func main() {
  var n1 float64 = 3.0
  var n2 float64 = 2.0
  var operation byte = '*'
  result := cal(n1, n2, operation)
  fmt.Println("result:", result)
}

2.2 包的使用

2.2.1 注意细节

1）导入包的两种方式

//方式1
import "fmt"

//方式2
import (
  "fmt"
  "project1/utils"
)

2）在访问其他包函数、变量时，其语法是 包名.函数名

import (
  "fmt"
  "project1/utils"
)

func main() {
  var n1 float64 = 3.0
  var n2 float64 = 2.0
  var operation byte = '+'
  result := utils.Cal(n1, n2, operation)
  fmt.Println("result:", result)
}

3）如果包名太长，go支持给包名取别名，但是取别名后，原来的包名就不能在用了

import (
  "fmt"
    //给包取别名
  util "project1/utils"
)

func main() {
  var n1 float64 = 3.0
  var n2 float64 = 2.0
  var operation byte = '+'
  result := util.Cal(n1, n2, operation)
  fmt.Println("result:", result)
}

4）在同一个包下不能有相同的函数名（也不能有相同的全局变量名），否则报重复定义

5）如果要编译成一个可执行的程序文件，就需要将这个包声明为main，即package main，如果你是写一个库，那么包名可以自定义

2.3 函数的注意细节

1）函数的形参列表可以是多个，返回值列表也可以是多个

2）如果返回值类型列表中只有一个，那么可以省略括号，如

func sum(n1 int, n2 int) int {
  return n1 + n2
}

3）如果返回多个值，在接收时，希望忽略某个返回值，则使用 _ 符号来时占位忽略，如

func main() {
  res1, _ := SumAndSub(1, 2)
  fmt.Printf("res1:%v", res1)
}

func SumAndSub(n1 int, n2 int) (int, int) {
  sum := n1 + n2
  sub := n1 - n2
  return sum, sub
}

4）形参列表与返回值列表的数据类型可以是基本类型与引用类型

5）函数名称的首字母如果大写表示是公开的，可以被其他包访问，如果首字母小写表示私有的，不能被其他包使用

6）函数中的变量是局部的，函数外不可用

7）基本数据类型与数组默认都是值传递的，即进行值拷贝，在函数内修改不会影响到原来的值

8）如果希望函数内的变量能够修改函数外的变量（这里的变量指的是基本数据类型），可以传入变量的地址&，然后在函数内通过指针的方式操作变量，从效果看这类似引用

9）go中函数不支持重载

10）在go中函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了，通过该变量可以对函数调用，如

11）函数既然是一种数据类型，因此在go中函数可以作为形参，并且调用

12）为了简化数据类型定义，Go支持自定义数据类型

基本语法：type 自定义数据类型名称 数据类型 //这相当于一个别名，如自定义一个int的数据类型

自定义上面sum函数的数据类型

13）支持函数返回值命名，如

14）Go支持可变参数，如

2.4 init函数

2.4.1 基本介绍

每一个源文件都可以包含一个init函数，该函数会在main函数执行前执行，被go框架调用，一般用来做初始化工作

2.4.2 注意细节

1）如果一个源码文件中包含全局变量定义、init函数和main函数，那么执行的顺序为：全局变量定义——>init函数——>main函数

2.5 匿名函数

Go支持匿明函数，如果某个函数希望只调用一次，可以考虑使用匿明函数

2.5.1 匿明函数的使用方式

1）方式1：在定义匿明函数时直接调用，如

2）方式2：将匿明函数赋给一个变量（函数变量），在通过该变量来调用匿明函数

3）全局匿明函数

将匿明函数赋给一个全局变量，那么这个匿明函数就成为了一个全局匿明函数

2.6 闭包

简单理解闭包就是能够读取其他函数内部变量的函数，即定义在一个函数内部的函数，如

2.7 defer的使用

在项目中经常需要创建资源（数据库连接、文件句柄、锁等），为了在函数执行完毕后，及时释放资源，go的设计者提供了defer（延时机制）

示例1

示例2，关闭文件资源

func main() {
    //关闭文件资源
    file = openfile(文件名)
    defer file.close()
    //其他语句
}

2.7.1 注意细节

在将defer语句放入到栈中时，也会将相关的值拷贝同时入栈，如下

2.8 函数参数传递的方式

1）值传递

2）引用传递

其实不管是值传递还是引用传递，传递给函数的都是变量的副本，不同的是，值传递是值的拷贝，引用传递是地址的拷贝，一般来说地址的拷贝效率高，因为数据量小，而值拷贝决定值的数据的大小，数据越大，效率越低

2.8.1 字符串函数

1）统计字符串长度，按字节统计使用内建函数len(str)

2）字符串遍历，同时处理包含中文的问题 r := []rune(str)

3）字符串转整数，使用strconv.Atoi函数

4）整数转字符串，使用strconv.Itoa函数

5）字符串转 []byte ，如 var b = []byte("hello")

6）[]byte转字符串，如 str := string([]byte{97,98,99})

7）将10进制转换为2、8、16进制的字符串使用strconv.FormatInt

8）判断字符串中是否包含子串，使用strings.Contains

9）返回字符串中有几个不重复的子串，如

10）判断字符串是否相等

2.9 日期函数

1）格式化日期，使用now.Format格式化日期，里面的日期规定必须是2006/01/02 15:04:05

2）格式化日期，使用fmt.Sprintf函数来格式化并返回一个字符串来实现

2.10 内置函数

1）new：用来分配内存，主要用来分配值类型，比如int、float32.....  返回的是指针

2）make：用来分配内存，主要用来分配引用类型，比如channel、map.....

2.11 异常处理机制

go语言追求简洁优雅，所以在Go语言中不支持传统的try...catch...finally这种处理，而是通过defer,panic,recover来处理异常，可以理解为go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后做相应处理

func test() {
  //使用defer + recover来捕获和处理异常
  defer func() {
        //使用recover来捕获异常
    err := recover()
    if err != nil {
      fmt.Println("出错了，cause is:", err)
    }
  }()
  i := 10
  j := 0
  fmt.Println(i/j)
}

func main() {
  test()
  fmt.Println("测试")
}

2.12 自定义错误

Go程序中也支持自定义错误，使用errors.New 和 panic内置函数

1）errors.New("错误信息")，会返回一个error类型的值，表示一个错误

2）panic内置函数，接收一个interface{}类型的值作为参数，可以接收error类型的变量，输出错误信息并退出。

上述内容就是如何入门Golang开发，你们学到知识或技能了吗？如果还想学到更多技能或者丰富自己的知识储备，欢迎关注创新互联行业资讯频道。

当前文章：如何入门Golang开发
当前URL：http://azwzsj.com/article/jsoejs.html