devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

一文详述Golang入门_一文golang语言

作者：不正经 | 2024-05-16 03:10:02

赞

踩

一文golang语言

目录

1、HelloWorld初识

2、Go 语言变量

3、数组和切片

切片截取

4、make

4.1、创建数组切片

4.2、创建map

5、数据类型

5.1、map:

6、常量

6.1、iota

7、for循环

8、函数

8.1、defer

9、指针

10、结构体

11、interface

12、go并发

12.1、通道（channel）

12.2、通道缓冲区

12.3、遍历通道与关闭通道

13、闭包

1、HelloWorld初识

环境安装好了之后我们先写一个HelloWorld。

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main() {
  6.    /* 这是我的第一个简单的程序 */
  7.    fmt.Println("Hello, World!")
  8. }

让我们来看下以上程序的各个部分：

  1. 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

  2. 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

  3. 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

  4. 下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。

  5. 下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
    使用 fmt.Print("hello, world\n") 可以得到相同的结果。
    Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。

  6. 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

需要注意的是 { 不能单独放在一行，所以以下代码在运行时会产生错误：

2、Go 语言变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字

  1. var identifier type
  2. var identifier1, identifier2 type

 

  1. package main
  2. import "fmt"
  3. func main() {
  4.     var a string = "Runoob"
  5.     fmt.Println(a)
  6.  
  7.     var b, c int = 1, 2
  8.     fmt.Println(b, c)
  9. }

3、数组和切片

数组长度不确定的时候可以使用 [...]或者[]，编译器会根据元素个数自行推断数组的长度：

  1. var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
  2. var balance2 = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}
  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main() {
  6. 	//数组
  7.     var arr1 [3]int
  8.     var arr2 [3]int = [3]int{1, 2, 3}
  9.     fmt.Println(arr1,arr2)
  10.  
  11. 	//切片，可以理解为动态数组
  12. 	var slice []int = []int{0, 1}
  13. 	fmt.Println(slice)
  14. 	slice = append(slice, 2, 3, 4, 5, 6)
  15. 	fmt.Println(slice)
  16.  
  17. 	//数组的=是拷贝
  18. 	var arr3 [3]int = arr2
  19. 	arr3[0] = 666
  20. 	fmt.Println(arr1,arr3)
  21.  
  22. 	//切片的=是引用
  23. 	var slice2 []int = slice
  24.     fmt.Println(slice, slice2)
  25.     slice2[0] = 666
  26.     fmt.Println(slice, slice2)
  27. }

除了make可以创建切片之外，未设置长度的数组也可以创建切片。

切片截取

可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound]，实例如下：

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main() {
  6.    /* 创建切片 */
  7.    numbers := []int{0,1,2,3,4,5,6,7,8}  
  8.    printSlice(numbers)
  9.  
  10.    /* 打印原始切片 */
  11.    fmt.Println("numbers ==", numbers)
  12.  
  13.    /* 打印子切片从索引1(包含) 到索引4(不包含)*/
  14.    fmt.Println("numbers[1:4] ==", numbers[1:4])
  15.  
  16.    /* 默认下限为 0*/
  17.    fmt.Println("numbers[:3] ==", numbers[:3])
  18.  
  19.    /* 默认上限为 len(s)*/
  20.    fmt.Println("numbers[4:] ==", numbers[4:])
  21.  
  22.    numbers1 := make([]int,0,5)
  23.    printSlice(numbers1)
  24.  
  25.    /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
  26.    number2 := numbers[:2]
  27.    printSlice(number2)
  28.  
  29.    /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
  30.    number3 := numbers[2:5]
  31.    printSlice(number3)
  32.  
  33. }
  34.  
  35. func printSlice(x []int){
  36.    fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
  37. }

4、make

4.1、创建数组切片

Go语言提供的内置函数make()可以用于灵活地创建数组切片。
创建一个初始元素个数为5的数组切片，元素初始值为0：

mySlice1 := make([]int, 5)

创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：

mySlice2 := make([]int, 5, 10) 

4.2、创建map

创建了一个键类型为string、值类型为PersonInfo的map

myMap = make(map[string] PersonInfo)

也可以选择是否在创建时指定该map的初始存储能力，创建了一个初始存储能力为100的map

myMap = make(map[string] PersonInfo, 100)

创建并初始化map的代码

  1. myMap = map[string] PersonInfo{ 
  2.   "1234": PersonInfo{"1", "Jack", "Room 101,..."}, 
  3. }

5、数据类型

5.1、map:

  1. package main
  2.  
  3. func main(){
  4. 	// 先声明map
  5. 	var m1 map[string]string
  6. 	// 再使用make函数创建一个非nil的map，nil map不能赋值
  7. 	m1 = make(map[string]string)
  8. 	// 最后给已声明的map赋值
  9. 	m1["a"] = "aa"
  10. 	m1["b"] = "bb"
  11.  
  12. 	// 直接创建
  13. 	m2 := make(map[string]int)
  14. 	// 然后赋值
  15. 	m2["1"] = 1
  16. 	m2["2"] = 2	
  17. }

注意：省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误。

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     mySlice := make([]int, 5, 10)  
  7.  
  8.     fmt.Println("len(mySlice):", len(mySlice)) 
  9.     fmt.Println("cap(mySlice):", cap(mySlice)) 
  10. }

cap()函数返回的是数组切片分配的空间大小

6、常量

  1. package main
  2.  
  3. import "unsafe"
  4. const (
  5.     a = "abc"
  6.     b = len(a)
  7.     c = unsafe.Sizeof(a)
  8. )
  9.  
  10. func main(){
  11.     println(a, b, c)
  12. }

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

6.1、iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

  1. const (
  2.     a = iota
  3.     b = iota
  4.     c = iota
  5. )

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

  1. const (
  2.     a = iota
  3.     b
  4.     c
  5. )

看一个简单的实例

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main() {
  6.     const (
  7.             a = iota   //0
  8.             b          //1
  9.             c          //2
  10.             d = "ha"   //独立值，iota += 1
  11.             e          //"ha"   iota += 1
  12.             f = 100    //iota +=1
  13.             g          //100  iota +=1
  14.             h = iota   //7,恢复计数
  15.             i          //8
  16.     )
  17.     fmt.Println(a,b,c,d,e,f,g,h,i)
  18. }

7、for循环

Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

比如遍历map

  1. for key, value := range oldMap {
  2.     newMap[key] = value
  3. }

for循环说完了，我们来看一下switch中的一个关键字fallthrough，Go默认switch的每个case都有一个break，如果需要去掉某个case的break，则需要添加fallthrough。

8、函数

  1. func function_name( [parameter list] ) [return_types] {
  2.    函数体
  3. }

注意，Go 函数可以返回多个值

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func swap(x, y string) (string, string) {
  6.    return y, x
  7. }
  8.  
  9. func main() {
  10.    a, b := swap("Google", "baidu")
  11.    fmt.Println(a, b)
  12. }

8.1、defer

defer指定了在函数退出时必须执行的语句

  1. //1、关闭文件句柄
  2. func read(){
  3.     file := open(filename);
  4.     defer file.close();
  5.  
  6.     //文件操作
  7. }
  8.  
  9. //2、锁资源释放
  10. func read(){
  11.     mc.lock();
  12.     defer mc.unlock();
  13.  
  14.     //其他操作
  15. }
  16.  
  17. //3、数据库连接释放
  18. func read(){
  19.     conn := openDatabase();
  20.     defer conn.close();
  21.  
  22.     //其他操作
  23. }

如果同一个函数中有多个defer，执行顺序为先进后出，类似于栈。 

  1. package main
  2.  
  3. import (
  4. 	"fmt"
  5. )
  6.  
  7. func main(){
  8. 	defer fmt.Println("1");
  9. 	defer fmt.Println("2");
  10. 	defer fmt.Println("3");
  11. 	defer fmt.Println("4");
  12. 	defer fmt.Println("5");
  13. }

9、指针

  1. var ip *int        /* 指向整型*/
  2. var fp *float32    /* 指向浮点型 */

golang也有野指针问题，要注意。

10、结构体

结构体中的小写的函数和变量在包之外无法调用，golang的大写类似c++ public，小写类似c++ private

  1. type struct_variable_type struct {
  2.    member definition
  3.    member definition
  4.    ...
  5.    member definition
  6. }
  1. package main
  2.  
  3. import "fmt"
  4.  
  5. type Books struct {
  6.    title string
  7.    author string
  8.    subject string
  9.    book_id int
  10. }
  11.  
  12. func main() {
  13.    var Book1 Books        /* 声明 Book1 为 Books 类型 */
  14.    var Book2 Books        /* 声明 Book2 为 Books 类型 */
  15.  
  16.    /* book 1 描述 */
  17.    Book1.title = "Go 语言"
  18.    Book1.author = "www.runoob.com"
  19.    Book1.subject = "Go 语言教程"
  20.    Book1.book_id = 6495407
  21.  
  22.    /* book 2 描述 */
  23.    Book2.title = "Python 教程"
  24.    Book2.author = "www.runoob.com"
  25.    Book2.subject = "Python 语言教程"
  26.    Book2.book_id = 6495700
  27.  
  28.    /* 打印 Book1 信息 */
  29.    fmt.Printf( "Book 1 title : %s\n", Book1.title)
  30.    fmt.Printf( "Book 1 author : %s\n", Book1.author)
  31.    fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
  32.    fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)
  33.  
  34.    /* 打印 Book2 信息 */
  35.    fmt.Printf( "Book 2 title : %s\n", Book2.title)
  36.    fmt.Printf( "Book 2 author : %s\n", Book2.author)
  37.    fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
  38.    fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
  39. }

11、interface

  1. /* 定义接口 */
  2. type interface_name interface {
  3.    method_name1 [return_type]
  4.    method_name2 [return_type]
  5.    method_name3 [return_type]
  6.    ...
  7.    method_namen [return_type]
  8. }
  9.  
  10. /* 定义结构体 */
  11. type struct_name struct {
  12.    /* variables */
  13. }
  14.  
  15. /* 实现接口方法 */
  16. func (struct_name_variable struct_name) method_name1() [return_type] {
  17.    /* 方法实现 */
  18. }
  19. ...
  20. func (struct_name_variable struct_name) method_namen() [return_type] {
  21.    /* 方法实现*/
  22. }
  1. package main
  2.  
  3. import (
  4. 	"fmt"
  5. )
  6.  
  7. // Shaper 接口类型
  8. type Shaper interface {
  9. 	Area() float64
  10. }
  11.  
  12. // Circle struct类型
  13. type Circle struct {
  14. 	radius float64
  15. }
  16.  
  17. // Circle类型实现Shaper中的方法Area()
  18. func (c *Circle) Area() float64 {
  19. 	return 3.14 * c.radius * c.radius
  20. }
  21.  
  22. // Square struct类型
  23. type Square struct {
  24. 	length float64
  25. }
  26.  
  27. // Square类型实现Shaper中的方法Area()
  28. func (s *Square) Area() float64 {
  29. 	return s.length * s.length
  30. }
  31.  
  32. func main() {
  33. 	// Circle类型的指针类型实例
  34. 	c := new(Circle)
  35. 	c.radius = 2.5
  36.  
  37. 	// Square类型的值类型实例
  38. 	s := Square{3.2}
  39.  
  40. 	// Sharpe接口实例ins1，它自身是指针类型的
  41. 	var ins1 Shaper
  42. 	// 将Circle实例c赋值给接口实例ins1
  43. 	// 那么ins1中就保存了实例c
  44. 	ins1 = c
  45. 	fmt.Println(ins1)
  46. 	fmt.Println(ins1.Area())
  47.  
  48. 	// 使用类型推断将Square实例s赋值给接口实例
  49. 	ins2 := s
  50. 	fmt.Println(ins2)
  51. 	fmt.Println(ins2.Area())
  52. }

12、go并发

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。

goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

goroutine 语法格式：

go 函数名( 参数列表 )

例如：

go f(x, y, z)

开启一个新的 goroutine:

f(x, y, z)

Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。

  1. package main
  2.  
  3. import (
  4.         "fmt"
  5.         "time"
  6. )
  7.  
  8. func say(s string) {
  9.         for i := 0; i < 5; i++ {
  10.                 time.Sleep(100 * time.Millisecond)
  11.                 fmt.Println(s)
  12.         }
  13. }
  14.  
  15. func main() {
  16.         go say("world")
  17.         say("hello")
  18. }

12.1、通道（channel）

通道（channel）是用来传递数据的一个数据结构。

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

  1. ch <- v    // 把 v 发送到通道 ch
  2. v := <-ch  // 从 ch 接收数据，并把值赋给 v

声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

以下实例通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结果的和：

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func sum(s []int, c chan int) {
  6.         sum := 0
  7.         for _, v := range s {
  8.                 sum += v
  9.         }
  10.         c <- sum // 把 sum 发送到通道 c
  11. }
  12.  
  13. func main() {
  14.         s := []int{7, 2, 8, -9, 4, 0}
  15.  
  16.         c := make(chan int)
  17.         go sum(s[:len(s)/2], c)
  18.         go sum(s[len(s)/2:], c)
  19.         x, y := <-c, <-c // 从通道 c 中接收
  20.  
  21.         fmt.Println(x, y, x+y)
  22. }

12.2、通道缓冲区

通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：

ch := make(chan int, 100)

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main() {
  6.     // 这里我们定义了一个可以存储整数类型的带缓冲通道
  7.         // 缓冲区大小为2
  8.         ch := make(chan int, 2)
  9.  
  10.         // 因为 ch 是带缓冲的通道，我们可以同时发送两个数据
  11.         // 而不用立刻需要去同步读取数据
  12.         ch <- 1
  13.         ch <- 2
  14.  
  15.         // 获取这两个数据
  16.         fmt.Println(<-ch)
  17.         fmt.Println(<-ch)
  18. }

12.3、遍历通道与关闭通道

Go 通过 range 关键字来实现遍历读取到的数据，类似于与数组或切片。格式如下：

v, ok := <-ch

如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。

  1. package main
  2.  
  3. import (
  4.         "fmt"
  5. )
  6.  
  7. func fibonacci(n int, c chan int) {
  8.         x, y := 0, 1
  9.         for i := 0; i < n; i++ {
  10.                 c <- x
  11.                 x, y = y, x+y
  12.         }
  13.         close(c)
  14. }
  15.  
  16. func main() {
  17.         c := make(chan int, 10)
  18.         go fibonacci(cap(c), c)
  19.         // range 函数遍历每个从通道接收到的数据，因为 c 在发送完 10 个
  20.         // 数据之后就关闭了通道，所以这里我们 range 函数在接收到 10 个数据
  21.         // 之后就结束了。如果上面的 c 通道不关闭，那么 range 函数就不
  22.         // 会结束，从而在接收第 11 个数据的时候就阻塞了。
  23.         for i := range c {
  24.                 fmt.Println(i)
  25.         }
  26. }

13、闭包

Go 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

以下实例中，我们创建了函数 getSequence() ，返回另外一个函数。该函数的目的是在闭包中递增 i 变量，代码如下：

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func getSequence() func() int {
  6.    i:=0
  7.    return func() int {
  8.       i+=1
  9.      return i  
  10.    }
  11. }
  12.  
  13. func main(){
  14.    /* nextNumber 为一个函数，函数 i 为 0 */
  15.    nextNumber := getSequence()  
  16.  
  17.    /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
  18.    fmt.Println(nextNumber())
  19.    fmt.Println(nextNumber())
  20.    fmt.Println(nextNumber())
  21.    
  22.    /* 创建新的函数 nextNumber1，并查看结果 */
  23.    nextNumber1 := getSequence()  
  24.    fmt.Println(nextNumber1())
  25.    fmt.Println(nextNumber1())
  26. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/576533
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号