03.golang入门

golang入门

1.常用命令

• Go命令

在命令行或终端输入go即可查看所有支持的命令

• Go常用命令简介

go get：获取远程包（需提前安装 git或hg）
go run：直接运行程序
go build：测试编译，检查是否有编译错误
go fmt：格式化源码（部分IDE在保存时自动调用）
go install：编译包文件并编译整个程序
go test：运行测试文件
go doc：查看文档

• 查看本地文档

godoc -http=:8080

浏览器输入http://127.0.0.1:8080/即可访问本地文档

2.注释

//      ：单行注释
/* */   ：多行注释

3.内置关键字（25个均为小写）

关键字不能用于自定义名字，只能在特定语法结构中使用。

break      default       func     interface   select
case       defer         go       map         struct
chan       else          goto     package     switch
const      fallthrough   if       range       type
continue   for           import   return      var

此外，还有大约30多个预定义的名字，比如int和true等，主要对应内建的常量、类型和函数。

内建常量: true false iota nil

内建类型: int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

内建函数: make len cap new append copy close delete
          complex real imag
          panic recover

4.package别名

当使用第三方包时，包名可能会非常接近或者相同，此时就可以使用别名来进行区别和调用。

package main

import (
    io "fmt"
)

func main() {
    // 使用别名调用包
    io.Println("Hello World!")
}

省略调用:

不建议使用，易混淆

不可以和别名同时使用

package main

import (
    . "fmt"
)

func main() {
    // 使用别名调用包
    Println("Hello World!")
}

5.可见性规则

Go语言中，使用 大小写 来决定该 常量、变量、类型、接口、结构或函数 是否可以被外部包所调用，根据约定：

函数名首字母 小写 即为private；

函数名首字母 大写 即为public

6.变量

• 单个变量的声明与赋值

  变量的声明格式：var <变量名称> <变量类型>

  变量的赋值格式：<变量名称> = <表达式>

  声明的同时赋值：var <变量名称> [变量类型] = <表达式>

package main

import (
    "fmt"
)

var a int

func main() {
    var b int = 1
    var c = 2

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

• 多个变量的声明与赋值

全局变量的声明可使用 var() 的方式进行简写

全局变量的声明不可以省略 var，但可使用并行方式

所有变量都可以使用类型推断

局部变量不可以使用 var() 的方式简写，只能使用并行方式

package main

import (
    "fmt"
)

var (
    a = 1
    b = 2
    c = 3
)

func main() {

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

7.变量的类型转换

Go中不存在隐式转换，所有类型转换必须显式声明

转换只能发生在两种相互兼容的类型之间

类型转换的格式： [:]= ()

package main

import (
    "fmt"
)

func main() {
    var a int = 65
    b := string(a)
    fmt.Println(b)
}

输出结果：A

string() 表示将数据转换成文本格式，因为计算机中存储的任何东西
本质上都是数字，因此此函数自然地认为我们需要的是用数字65表示
的文本 A 

如果需要输出转换后为字符串65可以使用strconv包的Itoa()方法

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var a int = 65
    b := string(a)
    c := strconv.Itoa(a)
    d, _ := strconv.Atoi(c)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}

输出：

A
65
65

8.常量

• 常量的定义

常量的值在编译时就已经确定

常量的定义格式与变量基本相同

等号右侧必须是常量或者常量表达式

常量表达式中的函数必须是内置函数

• 常量的初始化规则与枚举

在定义常量组时，如果不提供初始值，则表示将使用上行的表达式

使用相同的表达式不代表具有相同的值

iota是常量的计数器，从0开始，组中每定义1个常量自动递增1

通过初始化规则与iota可以达到枚举的效果

每遇到一个const关键字，iota就会重置为0

package main

import (
    "fmt"
)

const (
    A = 'A'
    B
    C  = iota
    D  = 100
    E  = iota
)

func main() {
    fmt.Println(A)
    fmt.Println(B)
    fmt.Println(C)
    fmt.Println(D)
    fmt.Println(E)
}

输出：

65
65
2
100
4

• 示例：结合常量的iota与<<运算符实现计算机存储单位的枚举

package main

import (
    "fmt"
)

const (
    B  float64 = 1 << (iota * 10)
    KB 
    MB 
    GB 
    TB 
    PB 
)

func main() {
    fmt.Println(B)
    fmt.Println(KB)
    fmt.Println(MB)
    fmt.Println(GB)
    fmt.Println(TB)
    fmt.Println(PB)
}

9.运算符

• Go中的运算符均是从左至右结合

  优先级（从高到低）

^      !                                               （一元运算符）
*       /    %    <<    >>    &      &^
+      -     |      ^                                （二元运算符）
==   !=   <    <=    >=    >
<-                                              （专门用于channel）
&&
||

• 位运算符

 6:0110
11:1011

&  按位与
|  按位或
^  按位异或
&^ 按位取反
<< 左移 
>> 右移

package main

import (
    "fmt"
)

/*
 6:0110
11:1011
------------------
&: 按位与：两个都是1才是1，否则就是0                                               二进制：0010 十进制：2
|: 按位或：如果有一个是1就是1，否则就是0                                             二进制：1111 十进制：1+2+4+8=15
^: 按位异或：只有一个是1的时候才是1，否则为0                                       二进制：1101 十进制：1+0+4+8=13
&^:按位取反：第二个数的位上是1把第一个数的同位改为0，否则为第一个数的位上的数       二进制：0100 十进制：0+0+4+0=4
*/

func main() {
    fmt.Println(6 & 11)
    fmt.Println(6 | 11)
    fmt.Println(6 ^ 11)
    fmt.Println(6 &^ 11)
}

10.控制语句

10.1判断语句if

• 条件表达式没有括号
• 支持一个初始化表达式（可以是并行方式）
• 左大括号必须和条件语句或else在同一行
• 支持单行模式
• 初始化语句中的变量为block级别，同时隐藏外部同名变量

package main

import "fmt"

func main() {
    a := 3
    if a < 1 {
        fmt.Println("a小于1")
    } else {
        fmt.Println("a不小于1")
    }
}

10.2循环语句for

• Go只有for一个循环语句关键字，但支持3种形式
• 初始化和步进表达式可以是多个值

• 条件语句每次循环都会被重新检查，因此不建议在条件语句中使用函数，尽量提前计算好条件并以变量或常量代替

• 左大括号必须和条件语句在同一行

package main

import "fmt"

func main() {
    /*for 循环第一种形式*/
    a := 1
    for {
        if a > 3 {
            break
        }
        a ++
        fmt.Println(a)
    }
    fmt.Println("========================================")

    /*for循环第二种形式*/
    b := 1
    for b < 3 {
        fmt.Println(b)
        b++
    }
    fmt.Println("========================================")

    /*for循环的第三种形式*/
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }

}

10.3选择语句switch

• 可以使用任何类型或表达式作为条件语句
• 不需要写break，一旦条件符合自动终止
• 如希望继续执行下一个case，需使用fallthrough语句
• 支持一个初始化表达式（可以是并行方式），右侧需跟分号
• 左大括号必须和条件语句在同一行

package main

import "fmt"

func main() {
    switch age := 20; {
    case age >= 18:
        fmt.Println("大于等于18岁")
        fallthrough
    case age >= 19:
        fmt.Println("大于等于19岁")
        fallthrough
    case age >= 20:
        fmt.Println("大于等于20岁")
    }
}

10.4跳转语句goto, break, continue

• 三个语法都可以配合标签使用
• 标签名区分大小写，若不使用会造成编译错误
• Break与continue配合标签可用于多层循环的跳出
• Goto是调整执行位置，与其它2个语句配合标签的结果并不相同

package main

import (
    "fmt"
)

func main() {
No1:
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if i == 5 && j == 5 {
                fmt.Println("i等于5并且j等于5")
                break No1
            }
        }
    }
}