本文已参与「新人创作礼」活动，一起开启掘金创作之路。

GO语言学习笔记

1.简介

1.1 什么是GO语言

GO语言是google开源的编译型语言，也被称作是21世纪的C语言。它能让构造简单、可靠且高效的软件变得容易。
相较于解释型语言(Python/JavaScript / Perl /Shell)，编译型语言(C/C++/GO)更快。
GO语言是为现代工程而生的语言

1.2 GO语言特色

有趣、开源、并行
快捷、简洁、安全
内存管理、数组安全、编译迅速

1.3 GO语言环境搭建

官方网站：Go Programming Language

下载地址：Download

下载并安装GO语言
控制台输入 go version 显示版本则成功

Microsoft Windows [版本 10.0.22000.100]
(c) Microsoft Corporation。保留所有权利。

C:\Users\hy>go version
go version go1.16.6 windows/amd64

配置GOPATH系统变量

GOPATH：是一个环境变量，用来存放GO项目的工作目录，最好只设置一个。即所有的代码都放在 GOPATH 的 src 目录下。

变量名：GOPATH

变量值：你的工作目录

2.语法基础

2.1 helloword

package main

import "fmt"

func main() {
    fmt.Println("helloword")
}

2.2 变量声明

/*
变量声明
注意：变量声明后必须使用，而且不能隐式改变类型(int转float)
*/
package main

import "fmt"

/*
	1.函数外声明全局变量
*/
var (
    a1 = 1
    a2 = "a2"
    a3 = true
)
var a4 = "a4"

func main() {
    /*
		2.一次声明一个变量(三种声明方式)
	*/
    var a int = 100 //var 变量名 类型 = 值
    var b = 1.2     //var 变量名 = 值
    str := "abc"    //变量名 := 值(类型自动推导)

    /*
		3.一次声明多个变量  变量名与值一一对应（两种声明方式）
	*/
    var u, v, w = 1, "test1", true
    x, y, z := 2, "test2", false
    fmt.Println(a1, a2, a3, a4)
    fmt.Println(a, b, str)
    fmt.Println("u=", u, "v=", v, "w=", w, "x=", x, "y=", y, "z=", z)
}

2.3 常量声明

/*
常量声明
注意：
	1.常量必须赋初值，且不可更改
	2.常量只能修饰布尔、数值、字符串类型
*/
package main

import "fmt"

const flag = true
const num int = 10
const name = "zhangsan"

/*
也可以直接在函数中声明
*/
const (
    a = iota
    b = 45
    c = 14
)

func main() {
    fmt.Println(flag, num, name)
    fmt.Println(a, b, c)
}

2.4 数据类型

基本数据类型

数值型

整数类型(int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 byte)
浮点类型(float32 float64)
复数(complex64 complex128)

字符型：使用 byte 保存单个字母字符没有专门的字符型

复杂数据类型

指针 数组 结构体 管道 函数 切片 接口 映射

/*
数据类型
*/
package main

import (
    "fmt"
    "unsafe"
)

func main() {
    viewVariableTypes()
    viewMemoryUsage()
    charactersAndStrings()
    typeConversion()
    pointer()
}

/*
查看变量类型
*/
func viewVariableTypes() {
    a, b := 100, "test"
    fmt.Printf("a的数据类型：%T，b的数据类型：%T\n", a, b)
}

/*
查看占用内存大小
注意：需要导入unsafe和fmt包
*/
func viewMemoryUsage() {
    a, b := 100, "test"
    fmt.Printf("a的内存大小：%d，b的内存大小：%d\n", unsafe.Sizeof(a), unsafe.Sizeof(b))
}

/*
字符串与字符
*/
func charactersAndStrings() {
    a1 := 's'
    a2 := '0'
    a3 := '国'
    //使用 ` 包住字符串即可
    var str = `这是用来测试
               跨行字符串`
    fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)       //输出字符的ascii值
    fmt.Printf("a1 = %c, a2 = %c,a3=%c\n", a1, a2, a3) //格式化输出字符
    fmt.Println(str)
}

/*
类型转换
*/
func typeConversion() {
    a1 := 1.2
    a2 := int(a1)
    fmt.Println("a2=", a2)
}

/*
指针
*/
func pointer() {
    a := 1
    b := &a
    fmt.Printf("%x, %d, %x\n", b, *b, &b)

    //通过指针改变变量值
    (*b) = (*b) * 10
    fmt.Printf("%v\n", a)
}

2.5 输入与输出

输入语句：fmt.Scanln()

输出语句：fmt.Println()

package main

import "fmt"

func main() {
    var str string
    var a int
    fmt.Println("请输入：")
    fmt.Scanln(&str)    //读取一行
    fmt.Scanf("%d", &a) //指定输入格式
    fmt.Println("str=", str)
    fmt.Println("a=", a)
}

2.6 for-range遍历

package main

import "fmt"

func main() {
    str := "用于测试for-range遍历"
    for index, s := range str {
        fmt.Printf("%d-->%c\n", index, s)
    }
}

2.7 生成随机数

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().Unix())
    text := rand.Intn(100) + 1
    fmt.Println(text)
}

3.函数

package main

import (
    "fmt"
    "math/rand"
    "time"
)

/*
全局变量定义
*/
var (
    test = func(n1 int, n2 int) int {
        return n1 * n2
    }
)

func main() {
    fmt.Println("main函数已执行...")
    fmt.Println(generateRandom(time.Now().Unix(), 100))
    fmt.Println(test(45, 89))
}

/*
init函数
注意：该函数会在main函数之前执行
*/
func init() {
    fmt.Println("init函数已执行...")
    /*
		匿名函数(即没有名字的函数)
	*/
    result := func(a int, b int) int {
        return a + b
    }(10, 45)
    fmt.Println("result=", result)

    /*
		匿名函数赋值
	*/
    a := func(a1 int, a2 int) (int, int) {
        return a2, a1
    }
    a1 := 10
    a2 := 29
    a1, a2 = a(a1, a2)
}

/*
生成随机数(普通函数)
*/
func generateRandom(time int64, _range int) int {
    rand.Seed(time)
    return rand.Intn(_range)
}

/*
 闭包
*/
func test01() func(int) int {
    var n int = 10
    return func(x int) int {
        n = n + x
        return n
    }
}

4.内存分配

package main

import "fmt"

func main() {
    p := new(int)
    fmt.Println("*p = ", *p, ", p = ", p)
    *p = 29
    fmt.Println("*p = ", *p)
}

5.异常捕获

defer、recover捕获异常，相当于try-catch

package main

import "fmt"

func test() {
    defer func() {
        error := recover() //捕获异常
        if error != nil {
            fmt.Println("error=", error) //输出异常
        }
    }()
    a := 1
    b := 0
    fmt.Println("result=", a/b)
}

func main() {
    test()
}

自定义错误异常

package main

import (
    "errors"
    "fmt"
)

func test02(name string) (err error) {
    if name == "abc" {
        return nil
    } else {
        return errors.New("这是自定义错误信息：" + name + "错误！") // 定义新的错误信息
    }
}

func test2() {
    error := test02("zhangsan")
    if error != nil {
        panic(error) // 终止程序
    }
    fmt.Println("执行成功")
}

func main() {
    test2()
}

6.数组

6.1 数组定义

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    //定义数组：var 数组名 [数组大小] 数组类型
    var array [6]int
    var a [4]int = [4]int{1, 2, 3, 4}
    var b = [4]int{1, 2, 3, 4}
    var c = [...]int{1, 2, 3, 4}       // 自行判断长度，中括号里...一个不能少
    var d = [...]int{1: 3, 0: 4, 2: 5} // 指定索引和值

    num := 0

    //生成随机数
    rand.Seed(time.Now().Unix())
    for i := 0; i < len(array); i++ {
        array[i] = rand.Int()*20 + 5
        fmt.Println("第", (i + 1), "个数是", array[i])
        num += array[i]
    }
    fmt.Println("均值为：", (num / int((len(array)))))
}

6.2 切片

package main

import "fmt"

func main() {
    array01 := [...]int{1, 2, 3, 4, 5, 6}
    slice := array01[1:4] //使用切片
    slice[0] = 7
    fmt.Println(array01[1])
}

6.3 映射

package main

import "fmt"

func main() {
    m1 := make(map[string]string) // map[键类型] 值类型
    m1["name"] = "Jason"          // 键值对赋值
    m1["age"] = "23"
    //fmt.Println(m1)
    //fmt.Println(m1["name"])//按键取值
    //delete(m1,"age")//删除某值
    /*
		循环遍历
	*/
    for k, v := range m1 {
        fmt.Println(k, "--", v)
    }
}

7.面向对象

7.1 结构体

package main

import "fmt"

/*
定义人类实体结构对象
*/
type Person struct {
    Name string //姓名
    Age  int    //年龄
    Desc string //备注
}

func main() {
    person01 := Person{Name: "zhangsan", Age: 21, Desc: "this is desc info!"}
    fmt.Println(person01)
    person01.Name = "lisi"
    fmt.Println(person01)
    //fmt.Println(person01.Name)
    //fmt.Println(person01.Age)
    //fmt.Println(person01.Desc)
    /*
		结构体指针声明
	*/
    person02 := new(Person) //指针声明方式01
    (*person02).Name = "test"
    (*person02).Age = 45
    (*person02).Desc = "this is test"
    fmt.Println(*person02)

    person03 := &Person{"wangwu", 21, "test"} //指针声明方式02
    fmt.Println(*person03)
}

7.2 方法

package main

import "fmt"

func main() {
    /*
		方法调用
	*/
    per01 := Person{"张三", 21, "测试"}
    per01.method()
    per02 := &Person{"张三", 22, "测试"}
    (*per02).method()
}

/*
方法定义
*/
func (per Person) method() {
    fmt.Println("name:", per.Name)
}

GO语言学习笔记（更新中...）

GO语言学习笔记

1.简介

1.1 什么是GO语言

1.2 GO语言特色

1.3 GO语言环境搭建

2.语法基础

2.1 helloword

2.2 变量声明

2.3 常量声明

2.4 数据类型

2.5 输入与输出

2.6 for-range遍历

2.7 生成随机数

3.函数

4.内存分配

5.异常捕获

6.数组

6.1 数组定义

6.2 切片

6.3 映射

7.面向对象

7.1 结构体

7.2 方法