网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go语言简介

2020-06-10 04:06:13 admin 1313

1 基础知识

go语言有以下特点：

  • 编译型语言，编译速度快

  • 静态类型语言，拥有动态类型语言特点

  • 类c语法，简单易学

  • 支持gc

  • 语言层面支持并发

  • 跨平台编译

2 著名的go项目：

  • docker：开源的应用容器引擎

  • kubernetes：一个开源的，用于管理云平台中多个主机上的容器化的应用

  • etcd：用于可靠地存储集群的配置数据的一种持久性，轻量型的，分布式的键-值数据存储系统

  • gogs：一款极易搭建的自助git服务

  • beego：一个快速开发go应用的http框架

hellow world:

__

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println("Hello, world!")
  7. }

3 简单的go demo:

__

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func demo(i int) {
  9.     fmt.Printf("demo%d\n", (i))
  10. }
  12. func main() {
  13.     num := 1
  14.     fmt.Println(num)
  16.     str := "string"
  17.     fmt.Println(str)
  19.     str = "new string"
  20.     fmt.Println(str)
  22.     var foo int
  23.     foo = 123
  24.     var bar int = 456
  25.     fmt.Println(foo, bar)
  27.     if foo == 123 {
  28.         fmt.Println("foo is 123")
  29.     }
  31.     for i := 0; i< 3; i++ {
  32.         fmt.Println(i)
  33.     }
  35.     for i := 0; i < 5; i++ {
  36.         go demo(i)
  37.     }
  39.     time.Sleep(2 * time.Second)
  40. }

4 变量

  • 声明的变量必须使用（导入的包也必须使用）

  • 多个变量赋值

  • :=声明变量

__

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. var N int = 100
  9. // N := 100
  11. // var N int
  12. func main() {
  13.     a, b := 1, 2
  14.     fmt.Println(a, b)
  16.     var num int
  17.     num = 10
  18.     fmt.Println(num)
  20.     var test string = "test"
  21.     fmt.Println(test)
  23.     fmt.Println(N)
  24. }

5 函数

  • 支持多值返回，具名返回

  • 使用_丢弃返回值

  • 以大写字母开头包级别的函数供外部访问

__

  1. func log(message string) {
  2. }
  4. func add(a int, b int) (ret int) {
  5.     return ret
  6. }
  8. func power(name string) (int, bool) {
  9.     return 1, true
  10. }

6 结构体

  • 不支持重载

  • 通过组合实现继承

  • 没有构造函数

  • 可以匿名组合和具名组合

  • 使用new创建一个结构体指针

  • 大写字母开头的变量可以访问

__

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type Demo1 struct {
  8.     id   int
  9.     name string
  10. }
  12. type Demo struct {
  13.     id   int
  14.     name string
  15.     d1   Demo1
  16.     // Demo1
  17. }
  19. func (d *Demo) change(name string) {
  20.     d.name = name
  21. }
  23. func (d Demo) unchange(name string) {
  24.     d.name = name
  25. }
  27. func main() {
  28.     d := Demo{}
  29.     fmt.Println(d)
  30.     d.name = "demo1"
  31.     fmt.Println(d)
  32.     d.change("name2")
  33.     fmt.Println(d)
  34.     d.unchange("name3")
  35.     fmt.Println(d)
  37.     dptr := new(Demo)
  38.     // dptr :=&Demo{}
  40.     fmt.Println(dptr)
  41.     dptr.name = "demo1"
  42.     fmt.Println(dptr)
  43.     dptr.change("name2")
  44.     fmt.Println(dptr)
  45.     dptr.unchange("name3")
  46.     fmt.Println(dptr)
  48.     d1 := Demo{1, "test", Demo1{}}
  49.     fmt.Println(d1)
  50.     println(d1.name)
  51.     println(d1.d1.name)
  52. }

7 字典、数组和切片

  • 字典

__

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // d := make(map[string]int)
  7.     // d := map[string]int{"1": 1, "2": 2}
  8.     d := map[string]int{}
  9.     d["1"] = 1
  10.     d["2"] = 2
  11.     d["3"] = 3
  13.     for k, v := range d {
  14.         fmt.Println(k, v)
  15.     }
  17.     v, exists := d["3"]
  18.     fmt.Println(v, exists)
  19. }
  • 数组

__

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // s := [3]int{1, 2, 3}
  7.     // s := [...]int{1, 2, 3}
  8.     var s [3]int
  9.     fmt.Println(len(s))
  10.     fmt.Println(cap(s))
  12.     s[0] = 0
  13.     s[1] = 1
  14.     s[2] = 2
  15.     // s[3] = 4
  17.     for idx, v := range s {
  18.         fmt.Println(idx, v)
  19.     }
  20. }
  • 切片

__

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // s := []int{0, 1, 2}
  7.     var s []int
  8.     s = make([]int, 3, 4)
  9.     // s := make([]int, 3, 5)
  10.     fmt.Println(len(s))
  11.     fmt.Println(cap(s))
  13.     s[0] = 0
  14.     s[1] = 1
  15.     s[2] = 2
  17.     s = append(s, 3)
  19.     for idx, v := range s {
  20.         fmt.Println(idx, v)
  21.     }
  23.     fmt.Println(s[1:3])
  24. }

8 接口

  • 接口只声明，不实现

  • 实现多态

  • duck-typing：如果一个对象走路像鸭子，游泳也像鸭子，叫声也像鸭子，那么该对象就可以被称作为鸭子

__

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type Square struct {
  8.     a int
  9. }
  11. func (s *Square) Area() int {
  12.     return s.a * s.a
  13. }
  15. func (s *Square) Perimeter() int {
  16.     return s.a * 4
  17. }
  19. type Rectangle struct {
  20.     a int
  21.     b int
  22. }
  24. func (r *Rectangle) Area() int {
  25.     return r.a * r.b
  26. }
  28. func (r *Rectangle) Perimeter() int {
  29.     return (r.a + r.b) * 2
  30. }
  32. type Shaper interface {
  33.     Area() int
  34.     Perimeter() int
  35. }
  37. type AnyShape interface{}
  39. func main() {
  41.     square := new(Square)
  42.     square.a = 2
  44.     rectangle := new(Rectangle)
  45.     rectangle.a = 2
  46.     rectangle.b = 3
  48.     fmt.Println("(1) call struct method:")
  49.     fmt.Println("square area is: ", square.Area())
  50.     fmt.Println("rectangle area is: ", rectangle.Area())
  52.     fmt.Println("\n(2) via interface:")
  53.     var shape Shaper
  54.     shape = square
  55.     fmt.Println("square area is: ", shape.Area())
  56.     shape = rectangle
  57.     fmt.Println("rectangle area is: ", shape.Area())
  59.     fmt.Println("\n(3) via empty interface:")
  60.     var anyShape AnyShape
  61.     anyShape = square
  62.     fmt.Println("square area is: ", anyShape.(*Square).Area())
  63.     anyShape = rectangle
  64.     fmt.Println("rectangle area is: ", anyShape.(*Rectangle).Area())
  66.     fmt.Println("\n(4) type assertions via switch:")
  67.     switch shape := anyShape.(type) {
  68.     case *Rectangle:
  69.         fmt.Printf("shape type is: %T\n", shape)
  70.         fmt.Println("rectangle area is: ", shape.Area())
  71.     default:
  72.         fmt.Printf("unknown type %T\n", shape)
  73.     }
  75.     fmt.Println("\n(5) type assertions via comma, ok pattern:")
  76.     anyShape = rectangle
  77.     if shape, ok := anyShape.(*Rectangle); ok {
  78.         fmt.Printf("shape type is: %T\n", shape)
  79.         fmt.Println("rectangle area is: ", shape.Area())
  80.     } else {
  81.         fmt.Printf("unknown type %T\n", shape)
  82.     }
  83. }

9 包管理

  • go get: go get github.com/mattn/go-sqlite3

  • 大写字母开头的变量或者函数对外可见

  • 标准库结构

  • demo pkg

10 协程

一个简单的协程：

__

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6.     "time"
  7. )
  9. var (
  10.     counter = 0
  11.     lock    sync.Mutex
  12. )
  14. func main() {
  15.     for i := 0; i< 3; i++ {
  16.         go incr()
  17.     }
  18.     time.Sleep(time.Millisecond * 10)
  19. }
  21. func incr() {
  22.     lock.Lock()
  23.     defer lock.Unlock()
  24.     counter++
  25.     fmt.Println(counter)
  26. }

使用通道进行协程间通信：

  • 通道支持select

  • 通道有类型

  • 通道大小

  • go确保任意时刻只有一个协程可以访问数据

__

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func main() {
  9.     c := make(chan int)
  11.     for i := 0; i< 5; i++ {
  12.         worker := &Worker{id: i}
  13.         go worker.process(c)
  14.     }
  16.     for i := 0; i < 5; i++ {
  17.         c <- i
  18.         time.Sleep(time.Millisecond * 50)
  19.     }
  20. }
  22. type Worker struct {
  23.     id int
  24. }
  26. func (w *Worker) process(c chan int) {
  27.     for i := 0; i < 5; i++ {
  28.         data := <-c
  29.         fmt.Printf("worker %d got %d\n", w.id, data)
  30.     }
  31. }

next

  • python多进程之multiprocessing

  • python小技巧分享

转载文章，原文链接： go语言简介

关键字词go简介

分享到：

上一篇：有点不安全却又一亮的 Go unsafe.Pointer

下一篇：Golang学习笔记之WEB框架(gin)基本使用

如需留言，请 登录，没有账号？请 注册

0 条评论 0 人参与

顶部 底部