golang(一)初识go

go简介

go语言诞生自2006年，于2009年发布并开源，2012年出现了第一个正式版本。近些年招聘中，go语言算是个小众岗位，只有少数大厂有招聘需求，如阿里，百度，京东等，由于它的特性，一般是高并发项目的优先选择。

go语言特性:

1. 垃圾回收
a. 内存自动回收，再也不需要开发人员管理内存
b. 开发人员专注业务实现，降低了负担
c. 只需要new分配内存，不需要释放

2. 天然并发
a. 从语言层支持并发，非常简单。只需要go一下
b. goroutine，轻量级线程，创建成千上万个goroute成为可能

3. channel
a. 管道，类似unix/linux中的pipe
b. 多个goroute之间通过channel进行通信
c. 支持任何类型

4. 多返回值
a. 一个函数返回多个值

5.编译型语言
a. 性能只比C语⾔差10%，但是语法上部分与C不同，如先写变量名，再写函数名
b. 开发效率和python、php差不多

包

1. 和python一样，把相同功能的代码放到一个目录，称之为包
2. 包可以被其他包引用
3. main包是用来生成可执行文件，每个程序只有一个main包
4. 包的主要用途是提⾼代码的可复用性

基本命令

1. 基本命令
a. go run 快速执行go文件，就像执行脚本一样
b. go build 编译程序，生成二进制可执行文件
c. go install 安装可执行文件到bin目录
d. go test 执行单元测试或压力测试
e. go env 显示go相关的环境变量
f. go fmt 格式化源代码

2.Go程序结构
a. 一个可执行程序只有⼀个main包和⼀个main函数
b. main函数是程序的执行入口
c. go源码按package进行组织，并且package要放到非注释的第⼀行

3. 注释（与JAVA相同）
b. 多行注释  /* */
a. 单行注释  //

环境搭建

1. Go安装
a. 打开Golang官⽹, https://golang.org/dl/
b. 选择系统对应的安装包进行下载
c. 双击安装

2. IDE搭建（以vscode为例)
a. 打开网址：https://code.visualstudio.com/
b. 根据操作系统选择对应的安装包
c. 点击安装包进行安装（linux直接解压）
d. 选择查看-》扩展-》搜索go，安装第⼆个

3. GOPATH设置
a. GOPATH是一个环境变量，用来表明go项目的存放路径
b. GOPATH路径最好只设置一个，所有的项目都放到GOPATH的src目录下
c. GOPATH的目录结构介绍

(1)适用于个人

(2)适用于企业

类型

标识符与关键字

1. 标识符是⽤用来表示Go中的变量名或者函数名，以字母或_开头。后面跟着字⺟、_或数字

A. 88ab B. _ab28 C. ab_28
2. 关键字
关键字是Go语⾔言预先定义好的，有特殊含义的标识符。

变量和常量

变量

使用var关键字定义，类型放在变量名后，var identifier type。

var a int    //自动初始化为0
var b string  //自动初始化为”“
var c bool    //自动初始化为bool
var d int = 8
var e string = “hello”
var f = false   //自动推断为bool类型

也可以一次定义多个变量，包括用不同初始值定义不同类型

var x, y int
var a, s = 100, "abc"   //不同类型初始值

推荐使用组的方式进行多变量定义

var (
a int //0
b string //“”
c bool //false
d int = 8 // 8
e string = “hello” //hello
)

除了var，还可以使用简短模式 :=

func main() {
    x := 100
    a, s := 10, "abc"

简短模式定义变量，同时显示初始化；不能提供数据类型；只能用在函数内部。因此，比较适用于多返回值，if/for/switch等语句中定义局部变量。

常量

1. 常量使用const 修饰，代表永远是只读的，不能修改。
2. 语法：const identifier [type] = value，其中type可以省略。

const b string = “hello world”
const b = “hello world”
const Pi = 3.1414926
const a = 9/3

与变量相同，推荐使用组的方式:

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

由于go没有明确意义上的enum定义，可以借助iota标识符实现自增常量来实现枚举类型。

const (
a = iota  //0
b         //1
c         //2
)

const (
a = 1 << iota   // 1 << 0
b               // 1 << 1
c               // 1 << 2
)

const (
a = iota        // 0
b               // 1
c = 100         // 100
d               // 100
e = iota        // 4(恢复iota自增，计数包括c、d)
f               // 5
)

实际编码中，建议使用自定义类型实现用途明确的枚举类型，如：

type color byte
const (
    black color = iota   //制定常量类型
    red
    blue
)

func test(c color) {
    println(c)
}

func main() {
    test(red)
    test(100)   //100没有超出color/type类型取值范围
    x := 2
    test(x)     //error:cannot use x(type int) as type color in argument to test
}

ps：Go中存在一个空标识符"_"，通常作为忽略占位符使用，可以当作表达式左面的值，不能读取内容。

数据类型

布尔类型

a. var b bool 和 var b bool = true 和 var b = false
b. 操作符 == 和 !=
c. 取反操作符： !b
d. && 和 || 操作符   与java、c相同
e. 格式化输出占位符: %t
整数和浮点数类型

a. int8、int16、int32、int64
b. uint8、uint16、uint32、uint64
c. int 和 uint，和操作系统平台相关
d. float32 和 float64浮点类型
e. 所有整数初始化为0，所有浮点数初始化为0.0，布尔类型初始化为false
f. Go是强类型语⾔，不同类型相加以及赋值是不允许的
g. Go强制要求使用显示类型转换，不同类型相加可使用，隐式转换最好别用。
h. 输出占位符：整数%d，%x十六进制，%f浮点数

ps：go中有2个别名，byte <=> uint8     rune <=> int32 类型无须转换，可直接赋值

a := 10
b := byte(a)
c := a + int(b)

字符串类型

a. var str string
b. var str string = “hello world”
c. 字符串输出占位符%s
d. 万能输出占位符: %v

字符串有2种表示形式:

a. 双引号， “”，可以包含控制字符
b. 反引号， ``，所有字符都是原样输出

var str = “hello world\n\n”
var str2 = `hello \n \n \n`

字符串常用操作：

a. 长度：len(str)
b. 拼接：+，fmt.Sprintf
c. 分割：strings.Split
d. 包含： strings.Contains
e. 前缀或后缀判断：strings.HasPrefix, strings.HasSuffix
f. 子串出现的位置: strings.Index(), strings.LastIndex()
g. join操作： strings.Join(a[]string, sep string)

引用类型

引用数据类型特指slice、map、channel三种预定义类型。引用数据类型必须使用make函数创建，编译器会将make转换为目标类型专用的创建函数，确保完成全部内存分配和相关属性初始化。

func mkslice() []int {
    s := make([]int, 0, 10)
    s = append(s, 100)
    return s
}
func mkmap() map[string]int {
    m := make(map[string]int)
    m["a"] = 1
    return m
}
func main() {
    m := mkmap()
    println(m["a"])
    s := mkslice()
    println(s[0])
}

操作符

a. 逻辑操作符， == 、 != 、<、<=、>=
b. 算数操作符， +、-、*、/、%

程序基本结构

package main
import “fmt”
func main() {
    fmt.Println(“hello, world”)
}

1. 任何⼀个代码文件隶属于⼀个包
2. import 关键字，引用其他包：
import(“fmt”)
import(“os”)
通常习惯写成：
import (
“fmt”
“os”
)
3. 开发可执行程序，package main，并且有且只有⼀个main入口函数
4. 包中函数调用：
a. 同⼀个包中函数，直接用函数名调用
b. 不同包中函数，通过包名+点+函数名进行调用
5. 包访问控制规则：
a. 大写意味着这个函数/变量是可导出的      b. 小写意味着这个函数/变量是私有的，包外部不能访问