Go 基础知识

发表于 | 更新于 | 分类于

值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
func main() {  
    // 字符串可以通过 + 连接。
    fmt.Println("go" + "lang")

    // 整数和浮点数
    fmt.Println("1+1 =", 1+1)
    fmt.Println("7.0/3.0 =", 7.0/3.0)

    // 布尔型，还有你想要的逻辑运算符。
    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}
1
2
3
4
5
6
golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false

变量

var声明1个或多个变量

1
2
var a string = "initial"
var b, c int = 1, 2

自动推断已经初始化的变量类型 var b = true
声明变量初始值为零值
:= 为初始化变量的简写

常量

const用于声明一个常量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Go 支持字符、字符串、布尔和数值 _常量_ 。
package main

import "fmt"
import "math"

// `const` 用于声明一个常量。
const s string = "constant"

func main() {
    fmt.Println(s)

    // `const` 语句可以出现在任何 `var` 语句可以出现
    // 的地方
    const n = 500000000

    // 常数表达式可以执行任意精度的运算
    const d = 3e20 / n
    fmt.Println(d)

    // 数值型常量是没有确定的类型的，直到它们被给定了一个
    // 类型，比如说一次显示的类型转化。
    fmt.Println(int64(d))

    // 当上下文需要时，一个数可以被给定一个类型，比如
    // 变量赋值或者函数调用。举个例子，这里的 `math.Sin`
    // 函数需要一个 `float64` 的参数。
    fmt.Println(math.Sin(n))
}
1
2
3
4
constant
6e+11
600000000000
-0.28470407323754404
  • 类型转换
1
2
3
4
var a = "12112133.5123123"
var b, _ = strconv.ParseFloat(a, 64)
var c = "123123"
var d, _ = strconv.ParseInt(a, 10, 64)

循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// `for` 是 Go 中唯一的循环结构。这里有 `for` 循环
// 的三个基本使用方式。

package main

import "fmt"

func main() {

    // 最常用的方式，带单个循环条件。
    i := 1
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }

    // 经典的初始化/条件/后续形式 `for` 循环。
    for j := 7; j <= 9; j++ {
        fmt.Println(j)
    }

    // 不带条件的 `for` 循环将一直执行，直到在循环体内使用
    // 了 `break` 或者 `return` 来跳出循环。
    for {
        fmt.Println("loop")
        break
    }
}

if/else 分支

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// `if` 和 `else` 分支结构在 Go 中当然是直接了当的了。

package main

import "fmt"

func main() {

    // 这里是一个基本的例子。
    if 7%2 == 0 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }

    // 你可以不要 `else` 只用 `if` 语句。
    if 8%4 == 0 {
        fmt.Println("8 is divisible by 4")
    }

    // 在条件语句之前可以有一个语句；任何在这里声明的变量
    // 都可以在所有的条件分支中使用。
    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }
}

// 注意，在 Go 中，你可以不适用圆括号，但是花括号是需要的。

分支结构 switch

一个case中可以用逗号分隔多个表达式

1
2
3
4
5
6
switch time.Now().Weekday() {
  case time.Saturday, time.Sunday:
      fmt.Println("it's the weekend")
  default:
      fmt.Println("it's a weekday")
  }

可以不带表达式

1
2
3
4
5
6
7
t := time.Now()
switch {
  case t.Hour() < 12:
  fmt.Println("it's before noon")
  default:
  fmt.Println("it's after noon")
}

数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import "fmt"
func mann(){
  //默认值都为0，长度为5的数组
  var a [5]int
  fmt.Println("emp:", a)
     a[4] = 100
  fmt.Println("set:", a)
  fmt.Println("get:", a[4])
  //内置函数返回数组长度
  fmt.Println("len:", len(a))
  b := [5]int{1,2,3,4,5}
  fmt.Println("dcl:", b)
  var twoD [2][3]int
  for i := 0; i < 2; i++ {
    for j:= 0; j < 3; j++ {
      twoD[i][j] = i + j
    }
  }
  fmt.Println("2d: ", twoD)
}

切片

关联数组

  • 运行：go run 编译：go build

网络框架: gin