来学点新语言

00_Golang开发

前言

Go语言优势

可直接编译成机器码，不依赖其他库，glibc的版本有一定要求，部署就是扔一个文件上去就完成了。
静态类型语言，但是有动态语言的感觉，静态类型的语言就是可以在编译的时候检查出来隐藏的大多数问题，动态语言的感觉就是有很多的包可以使用，写起来的效率很高。
语言层面支持并发，这个就是Go最大的特色，天生的支持并发。Go就是基因里面支持的并发，可以充分的利用多核，很容易的使用并发。
内置runtime，支持垃圾回收，这属于动态语言的特性之一吧，虽然目前来说GC（内存垃圾回收机制）不算完美，但是足以应付我们所能遇到的大多数情况，特别是Go1.1之后的GC。
简单易学，Go 语言的作者都有C的基因，那么Go自然而然就有了C的基因，那么Go关键字是25个，但是表达能力很强大，几乎支持大多数你在其他语言见过的特性:继承、重载、对象等。
丰富的标准库，Go目前已经内置了大量的库，特别是网络库非常强大。
内置强大的工具，Go语言里面内置了很多工具链，最好的应该是gofmt工具，自动化格式化代码，能够让团队review变得如此的简单，代码格式一模一样，想不一样都很困难。
跨平台编译，如果你写的Go代码不包含cgo，那么就可以做到window系统编译linux的应用，如何做到的呢？Go引用了plan9的代码，这就是不依赖系统的信息。
内嵌C支持，Go里面也可以直接包含C代码，利用现有的丰富的C库。

Go适用领域

服务器编程，以前你如果使用 C 或者 C++做的那些事情，用 Go 来做很合适，例如处理日志、数据打包、虚拟机处理、文件系统等。
分布式系统，数据库代理器等。
网络编程，这一块目前应用最广，包括 Web 应用、API 应用、下载应用。
内存数据库，如 google 开发的 groupcache，couchbase 的部分组建。
云平台。

Golang环境搭建

地址

https://go.dev/dl/

Windows 下可以使用 .msi 后缀(在下载列表中可以找到该文件，如go1.4.2.windows-amd64.msi)的安装包来安装。

默认情况下 .msi 文件会安装在 c:Go 目录下。你可以将 c:Gobin 目录添加到 Path 环境变量中。添加后你需要重启命令窗口才能生效。

安装测试

创建工作目录 C:>Go_WorkSpace。

test.go 文件代码

package main

import "fmt"

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

使用 go 命令执行以上代码输出结果如下：

Goland下载

https://www.jetbrains.com/go/download/#section=windows

测试

Hello World

注：左括号必须和函数名同行。
注：go语言语句结尾是没有分号
go语言以包作为管理单位。
每个 Go 源代码文件的开头都是一个 package 声明，表示该 Go 代码所属的包。
包是 Go 语言里最基本的分发单位，也是工程管理中依赖关系的体现。
要生成 Go 可执行程序，必须建立一个名字为 main 的包，并且在该包中包含一个叫 main() 的函数（该函数是 Go 可执行程序的执行起点）。
Go 语言的main()函数不能带参数，也不能定义返回值。
在包声明之后，是一系列的 import 语句，用于导入该程序所依赖的包。由于本示例程序用到了 Println()函数，所以需要导入该函数所属的 fmt 包。

package main

import "fmt"

func main() {   //左括号必须和函数名同行
  fmt.Println("Hello, World!") // go语言语句结尾是没有分号
}

命令行运行程序

go build  //编译代码

go run  //运行代码

基础类型（常量和变量）

命名

命名规则：一个名字必须以一个字母（Unicode 字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。
大写字母和小写字母是不同的：heapSort 和 Heapsort 是两个不同的名字。
Go 语言中类似 if 和 switch 的关键字有 25 个(均为小写)。
关键字不能用于自定义名字，只能在特定语法结构中使用。
还有大约 30 多个预定义的名字，比如 int 和 true 等，主要对应内建的常量、类型和函数。

变量

变量是程序运行期间可以改变的量。
从根本上说，变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。

变量声明

对于纯粹的变量声明， Go 语言引入了关键字 var，而类型信息放在变量名之后。

示例

package main

import "fmt"

func main() {

    var v1 int
    fmt.Println("v1=", v1)
    var v2 int = 10
    fmt.Println("v2=", v2)

    //一次定义多个变量
    var v3, v4 int

    var (
        v5 int
        v6 int
    )

}

变量初始化

对于声明变量时需要进行初始化的场景， var 关键字可以保留，但不再是必要的元素。
出现在 := 左侧的变量不应该是已经被声明过，:=定义时必须初始化。

package main

import (
    "fmt"
    "reflect"
)

func main() {

    var v1 int
    fmt.Println("v1=", v1)
    var v2 = 10
    fmt.Println("v2=", v2)

    ///出现在 := 左侧的变量不应该是已经被声明过，:=定义时必须初始化
    v0 := 20
    fmt.Println("v3=", reflect.TypeOf(v0))

    //一次定义多个变量
    var v3, v4 int

    var (
        v5 int
        v6 int
    )

}

变量赋值

package main

import (
    "fmt"
    "reflect"
)

func main() {

    var v1 int
    fmt.Println("v1=", v1)
    var v2 = 10
    fmt.Println("v2=", v2)

    ///出现在 := 左侧的变量不应该是已经被声明过，:=定义时必须初始化
    v0 := 20
    fmt.Println("v3=", reflect.TypeOf(v0))

    //一次定义多个变量
    var v3, v4 int
    v3, v4 = 1, 9
    fmt.Println("v3=", v3)
    fmt.Println("v4=", v4)

    //交换2个变量的值
    i := 10
    j := 20
    i, j = j, i //多重赋值

    var (
        v5 int
        v6 int
    )

}

匿名变量

_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃。

_,i,_, j := 1,2,3,4
func test(int, string) {
    return 250, "sb"

}
_, str := test()

常量

常量是指编译期间就已知且不可改变的值。
常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

字面常量（常量值）

谓字面常量（literal），是指程序中硬编码的常量。

常量定义

package main

func main() {
    const pi float64 = 3.14156926
    const zero = 0 // 浮点常量, 自动推导类型
    const (        // 常量组
        size int64 = 1024
        eof        = -1 // 整型常量, 自动推导类型
    )

    const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值
    const a, b, c = 3, 4, "foo"
    // a = 3, b = 4, c = "foo" //err, 常量不能修改
}

iota枚举

常量声明可以使用 iota 常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。
在一个 const 声明语句中，在第一个声明的常量所在的行，iota 将会被置为 0，然后在每一个有常量声明的行加一。

//iota枚举
    //常量声明可以使用 iota 常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是
    //不用每行都写一遍初始化表达式。
    //在一个 const 声明语句中，在第一个声明的常量所在的行，iota 将会被置为 0，然后在每一
    //个有常量声明的行加一。
    const (
        x = iota // x == 0
        y = iota // y == 1
        z = iota // z == 2
        w        // 这里隐式地说 w = iota，因此 w == 3。其实上面 y 和 z 可同样不用"= iota"

    )

    const v4 = iota // 每遇到一个 const 关键字，iota 就会重置，此时 v == 0

    const (
        h, i, j = iota, iota, iota //h=0,i=0,j=0 iota 在同一行值相同
    )

    const (
        a1         = iota //a=0
        b1         = "B"
        c1         = iota             //c1=2
        d1, e1, f1 = iota, iota, iota //d1=3,e1=3,f1=3
        g1         = iota             //g1 = 4
    )

    const (
        x1 = iota * 10 // x1 == 0
        y1 = iota * 10 // y1 == 10
        z1 = iota * 10 // z1 == 20
    )

基础数据类型

布尔类型

布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换

package main

func main() {
    var v1 bool
    v1 = true
    v2 := (1 == 2) // v2 也会被推导为 bool 类型

    //布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换
    var b bool
    b = 1       // err, 编译错误
    b = bool(1) // err, 编译错误

}

整型

    //整型
    var v1 int32
    v1 = 123
    v2 := 64 // v1 将会被自动推导为 int 类型

浮点型

//浮点型
    var f1 float32
    f1 = 12
    f2 := 12.0 // 如果不加小数点， fvalue2 会被推导为整型而不是浮点型，float64

字符类型

Go 语言中支持两个字符类型，一个是 byte（实际上是 uint8 的别名），代表 utf-8 字符串的单个字节的值；
另一个是 rune，代表单个 unicode 字符。

    //字符类型
    var ch1, ch2, ch3 byte
    ch1 = 'a'  //字符赋值
    ch2 = 97   //字符的 ascii 码赋值
    ch3 = '\n' //转义字符
    fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3)

字符串

字符串也是一种基本类型

//字符串
    var str string                                    // 声明一个字符串变量
    str = "abc"                                       // 字符串赋值
    ch := str[0]                                      // 取字符串的第一个字符
    fmt.Printf("str = %s, len = %d\n", str, len(str)) //内置的函数 len() 来取字符串的长度
    fmt.Printf("str[0] = %c, ch = %c\n", str[0], ch)
    //`(反引号)括起的字符串为 Raw 字符串，即字符串在代码中的形式就是打印时的形式，
    //它没有字符转义，换行也将原样输出。
    str2 := `hello mike \n \r 测试`
    fmt.Println("str2 = ", str2)
    /*
       str2 = hello
        mike \n \r 测试
    */

复数类型

复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。

    //复数类型
    var v1 complex64 // 由 2 个 float32 构成的复数类型
    v1 = 3.2 + 12i
    v2 := 3.2 + 12i        // v2 是 complex128 类型
    v3 := complex(3.2, 12) // v3 结果同 v2
    fmt.Println(v1, v2, v3)
    //内置函数 real(v1)获得该复数的实部
    //通过 imag(v1)获得该复数的虚部
    fmt.Println(real(v1), imag(v1))

fmt包的格式化输出输入

格式说明

输出

package main

import "fmt"

func main() {
    //整型
    a := 15
    fmt.Printf("a = %b\n", a) //a = 1111
    fmt.Printf("%%\n")        //只输出一个%
    //字符
    ch := 'a'
    fmt.Printf("ch = %c, %c\n", ch, 97) //a, a
    //浮点型
    f := 3.14
    fmt.Printf("f = %f, %g\n", f, f) //f = 3.140000, 3.14
    fmt.Printf("f type = %T\n", f)   //f type = float64
    //复数类型
    v := complex(3.2, 12)
    fmt.Printf("v = %f, %g\n", v, v) //v = (3.200000+12.000000i), (3.2 + 12i)
    fmt.Printf("v type = %T\n", v) //v type = complex128
    //布尔类型
    fmt.Printf("%t, %t\n", true, false) //true, false

    //字符串
    str := "hello go"
    fmt.Printf("str = %s\n", str) //str = hello go
}

输入

package main

import "fmt"

func main() {
    var v int
    fmt.Println("请输入一个整型：")
    fmt.Scanf("%d", &v)
    //fmt.Scan(&v)
    fmt.Println("v = ", v)
}

类型转换

Go 语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。

package main

func main() {
    var ch byte = 100
    
    var a int = int(ch)
}

类型别名

    //类型别名
    type bigint int64 //int64 类型改名为 bigint
    var x bigint = 10
    type (
        myint int    //int 改名为 myint
        mystr string //string 改名为 mystr
    )

运算符

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

其他运算符

运算符优先级

一元运算符拥有最高的优先级，二元运算符的运算方向均是从左至右。
下表由上至下代表优先级由高到低：

流程控制

Go 语言支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构。
顺序结构：程序按顺序执行，不发生跳转。
选择结构：依据是否满足条件，有选择的执行相应功能。
循环结构：依据条件是否满足，循环多次执行某段代码。

选择结构

if语句

package main

import "fmt"

func main() {
    //if
    var a int = 3
    if a == 3 {
        fmt.Println("a==3")
    }

    //支持一个初始化表达式, 初始化字句和条件表达式直接需要用分号分隔
    if b := 3; b == 3 {
        fmt.Println("b==3")
    }

}

if..else

//if else
    if a := 3; a == 4 {
        fmt.Println("a==4")
    } else { //左大括号必须和条件语句或 else 在同一行
        fmt.Println("a!=4")

    }

if ... else if ... else

    //if ... else if ... else
    if a := 3; a > 3 {
        fmt.Println("a>3")
    } else if a < 3 {
        fmt.Println("a<3")
    } else if a == 3 {
        fmt.Println("a==3")
    } else {
        fmt.Println("error")
    }

switch语句

Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个 switch, 但是可以使用 fallthrough 强制执行后面的 case 代码。

    //Switch
    //Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，
    //而是跳出整个 switch, 但是可以使用 fallthrough 强制执行后面的 case 代码：
    var score int = 90
    switch score {
    case 90:
        fmt.Println("优秀")
        //fallthrough
    case 80:
        fmt.Println("良好")
        //fallthrough
    case 70:
        fmt.Println("一般")
        //fallthrough
    case 60:
        fmt.Println("及格")
        //fallthrough
    default:
        fmt.Println("差")
    }

可以使用任何类型或表达式作为条件语句：

//可以使用任何类型或表达式作为条件语句：
    //1
    switch s1 := 90; s1 {
    case 90:
        fmt.Println("优秀")
        //fallthrough
    case 80:
        fmt.Println("良好")
        //fallthrough
    case 70:
        fmt.Println("一般")
        //fallthrough
    case 60:
        fmt.Println("及格")
        //fallthrough
    default:
        fmt.Println("差")
    }

    //2
    var s2 int = 90
    switch { //这里没有写条件
    case s2 >= 90: //这里写判断语句
        fmt.Println("优秀")
    case s2 >= 80:
        fmt.Println("良好")
    default:
        fmt.Println("一般")
    }

    //3
    switch s3 := 90; { //只有初始化语句，没有条件
    case s3 >= 90: //这里写判断语句
        fmt.Println("优秀")
    case s3 >= 80:
        fmt.Println("良好")
    default:
        fmt.Println("一般")
    }

循环语句

for

package main

import "fmt"

func main() {
    var i, sum int
    for i = 1; i <= 100; i++ {
        sum += i
    }
    fmt.Println("sum=", sum) //sum= 5050
}

range

    //range
    //关键字 range 会返回两个值，第一个返回值是元素的数组下标，第二个返回值是元素的值：
    s := "abc"
    for i := range s { //支持 string/array/slice/map。
        fmt.Printf("%c\n", s[i])
    }

    for _, c := range s { // 忽略 index
        fmt.Printf("%c\n", c)
    }
    for i, c := range s {
        fmt.Printf("%d, %c\n", i, c)
    }

跳转语句

break和continue

在循环里面有两个关键操作 break 和 continue。
break 操作是跳出当前循环，continue是跳过本次循环。
注意：break 可⽤于 for、switch、select，⽽continue 仅能⽤于 for 循环。

package main

import "fmt"

func main() {
    //注意：break 可⽤于 for、switch、select，⽽continue 仅能⽤于 for 循环。
    for i := 0; i < 5; i++ {
        if 2 == i {
            //break //break 操作是跳出当前循环
            continue //continue 是跳过本次循环
        }
        fmt.Println(i)
    }
}

goto

用 goto 跳转到必须在当前函数内定义的标签。

    //goto
    for i := 0; i < 5; i++ {
        for {
            fmt.Println(i)
            goto LABEL //跳转到标签 LABEL，从标签处，执行代码
        }
    }
    fmt.Println("this is test")

LABEL:
    fmt.Println("it is over")