Go语言（或 Golang）起源于 2007 年，并在 2009 年正式对外发布。Go 是非常年轻的一门语言，它的主要目标是“兼具 Python 等动态语言的开发速度和 C/C++ 等编译型语言的性能与安全性”。Go语言是编程语言设计的又一次尝试，是对类C语言的重大改进，它不但能让你访问底层操作系统，还提供了强大的网络编程和并发编程支持。Go语言的用途众多，可以进行网络编程、系统编程、并发编程、分布式编程…一些碎碎念

模板代码

任何语言都需要一个hello world!

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}

变量、常量、全局变量

变量

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
33
34
35
36
37
package main

import "fmt"

func main() {
    // 单行注释
    /*
    *多行注释
    */
    // 变量声明一
    var name = "zhangsan"
    // 变量声明二
    var name string = "zhangsan"
    // 变量名 := 表达式
    // 在函数内部，可以使用更简略的 := 方式声明并初始化变量
    // 注意：短变量只能用于声明局部变量，不能用于全局变量声明

    //类型不同多个变量, 全局变量, 局部变量不能使用这种方式
    var (
        // 内部声明类型
        vname1 v_type1
        vname2 v_type2
    )

    // 优先声明类型
    var x, y int
    var (  
        a int
        b bool
    )

    //这种不带声明格式的只能在函数体中出现
    //g, h := 123, "hello"
    fmt.Println("自动换行")
    fmt.Print("不自动换行")
    fmt.Printf("%d\n", 123) // 格式化输出
}

变量一旦被声明之后就不能赋值为其他类型的数据

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

  • 显式类型定义： const b string = "abc"
  • 隐式类型定义： const b = "abc"
  • 多个相同类型： const c_name1, c_name2 = value1, value2
  • 枚举：
    1
    2
    3
    4
    5
    const (
        Unknown = 0
        Female = 1
        Male = 2
    )

全局变量

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

import "fmt"

/* 声明全局变量 */
var g int

func main() {

   /* 声明局部变量 */
   var a, b int

   /* 初始化参数 */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}

赋值

  • 变量一旦被声明就必须使用
  • 函数返回的多余变量可以用 _ 接收表示舍弃，这个符号被称为空白标识符
  • 变量类型被声明后不能赋值其他类型
  • 变量的使用必须严格按照作用域使用，局部优先级大于全局
  • 如果想要交换两个变量的值，则可以简单地使用 a, b = b, a

iota

iota是go语言的常量计数器，只能在常量的表达式中使用。使用iota时只需要记住以下两点

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

​ 使用iota能简化定义，在定义枚举时很有用。

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
33
const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)
const (
		n1 = iota //0
		n2        //1
		_		  //丢弃该值，常用在错误处理中
		n4        //3
	)
const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
const n5 = iota //0
const (
		_  = iota
		KB = 1 << (10 * iota) // <<移位操作，速度比乘除法快 
		MB = 1 << (10 * iota) // 1<<3 相当于1*2*2*2     0001 -> 1000
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)
const (
		a, b = iota + 1, iota + 2 //1,2
		c, d                      //2,3
		e, f                      //3,4
	)