golang(一)初识go

旧城等待， 2022-02-27 10:54 210阅读 0赞

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)适用于个人

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eWFuZzAzMDQ_size_16_color_FFFFFF_t_70][]

(2)适用于企业

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eWFuZzAzMDQ_size_16_color_FFFFFF_t_70 1][]

## 类型 ##

### 标识符与关键字 ###

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eWFuZzAzMDQ_size_16_color_FFFFFF_t_70 2][]

### 变量和常量 ###

**变量**

使用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. 小写意味着这个函数/变量是私有的，包外部不能访问

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eWFuZzAzMDQ_size_16_color_FFFFFF_t_70]: /images/20220227/2795779a219a4504ba5213e07cd9c8b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eWFuZzAzMDQ_size_16_color_FFFFFF_t_70 1]: /images/20220227/d393b2843d674ac4a882dc982a82cabc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eWFuZzAzMDQ_size_16_color_FFFFFF_t_70 2]: /images/20220227/c22e8dcbb8ba43b6b66f394abab874b3.png