Go语言基础笔记

Go语言基础笔记

Go语言声明

    var（声明变量）, const（声明常量）, type（声明类型） ,func（声明函数）。

go使用package来定义模块，用来说明文件属于那个包，import 声明，再下来是类型，变量，常量，函数的声明。

Go工程

一个Go工程中主要包含以下三个目录：

• src：源代码文件
• ​ pkg：包文件
• ​ bin：相关bin文件

内置类型

值类型

 	bool
    int(32 or 64), int8, int16, int32, int64
    uint(32 or 64), uint8(byte), uint16, uint32, uint64
    float32, float64
    string
    complex64, complex128
    array    -- 固定长度的数组

引用类型：(指针类型)

   slice   -- 序列数组(最常用)
    map     -- 映射
    chan    -- 管道

内置函数

 append          -- 用来追加元素到数组、slice中,返回修改后的数组、slice
    close           -- 主要用来关闭channel
    delete            -- 从map中删除key对应的value
    panic            -- 停止常规的goroutine  （panic和recover：用来做错误处理）
    recover         -- 允许程序定义goroutine的panic动作
    real            -- 返回complex的实部   （complex、real imag：用于创建和操作复数）
    imag            -- 返回complex的虚部
    make            -- 用来分配内存，返回Type本身(只能应用于slice, map, channel)
    new                -- 用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
    cap                -- capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
    copy            -- 用于复制和连接slice，返回复制的数目
    len                -- 来求长度，比如string、array、slice、map、channel ，返回长度
    print、println     -- 底层打印函数，在部署环境中建议使用 fmt 包

init函数

go语言中init函数用于包(package)的初始化

每个包可以拥有多个init函数

init函数不能被其他函数调用，而是在main函数执行之前，自动被调用

【import _ 包路径】只是引用该包，仅仅是为了调用init()函数，所以无法通过包名来调用包中的其他函数。

main函数

 Go语言程序的默认入口函数(主函数)：func main()
    函数体用｛｝一对括号包裹。

    func main(){
        //函数体
    }

变量声明

 var 变量名 变量类型

批量声明

var (
        a string
        b int
        c bool
        d float32
    )

  var name, sex = "pprof.cn", 1

类型推导

将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

短变量声明

在函数内部，可以使用更简略的 := 方式声明并初始化变量。

package main

import (
    "fmt"
)
// 全局变量m
var m = 100

func main() {
    n := 10
    m := 200 // 此处声明局部变量m
    fmt.Println(m, n)
}

匿名变量

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示

函数外的每个语句都必须以关键字开始（var、const、func等）

:=不能使用在函数外。

_多用于占位，表示忽略值。

常量

const，常量在定义的时候必须赋值。

iota

iota是go语言的常量计数器，只能在常量的表达式中使用。 iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

 const (
            n1 = iota //0
            n2        //1
            n3        //2
            n4        //3
        )

 const (
            n1 = iota //0
            n2        //1
            _
            n4        //3
        )
 const (
            a, b = iota + 1, iota + 2 //1,2
            c, d                      //2,3
            e, f                      //3,4
        )
  const (
            n1 = iota //0
            n2 = 100  //100
            n3 = iota //2
            n4        //3
        )
    const n5 = iota //0

基本类型

整型

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64对应的无符号整型：uint8、uint16、uint32、uint64

uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型。

浮点型

Go语言支持两种浮点型数：float32和float64

复数

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。

注意：

布尔类型变量的默认值为false。

Go 语言中不允许将整型强制转换为布尔型.

布尔型无法参与数值运算，也无法与其他类型进行转换。

字符串

Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容。

s1 := "hello"
s2 := "你好"

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符。

   s1 := `第一行
    第二行
    第三行
    `
    fmt.Println(s1)

字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.Contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

byte和rune类型

字符用单引号（’）包裹起来

var a := '中'

 var b := 'x'

Go 语言的字符有以下两种：

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。

rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode的文本处理更为方便。

字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 ,字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。

修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

func changeString() {
        s1 := "hello"
        // 强制类型转换
        byteS1 := []byte(s1)
        byteS1[0] = 'H'
        fmt.Println(string(byteS1))

        s2 := "博客"
        runeS2 := []rune(s2)
        runeS2[0] = '狗'
        fmt.Println(string(runeS2))
    }

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。

强制类型转换的基本语法如下：

  T(表达式)

T表示要转换的类型（写类型名即可）。表达式包括变量、复杂算子和函数返回值等。