Go语言修炼手册

最新推荐文章于 2023-12-12 17:14:39 发布

VIP文章 Autovy

最新推荐文章于 2023-12-12 17:14:39 发布

阅读量505

点赞数 1

分类专栏： go 文章标签： golang

本文链接：https://blog.csdn.net/JohnSmith232/article/details/120193546

版权

参考文章：

Go语言标准库：https://studygolang.com/pkgdoc

Go案例代码：https://gobyexample-cn.github.io/

Go语言学习手册：https://www.topgoer.com/

完整文章地址

HelloGo

1.Golang的主要特征

自动立即回收
更丰富的内置类型
函数多返回值
错误处理
匿名函数和闭包
类型和接口
并发编程
反射
语言交互性

2.第一个Go程序

// 要导入main包才能运行main函数
// 而且一个项目中只能有一个文件导入main包使用main函数（类似于C语言）

package main

import "fmt"
func Hello()  {
   
	fmt.Println("HelloGo")
}

3.Go的值运算

// Value 数据值的一些运算
func Value()  {
   

	fmt.Println("go"+"lang")
	fmt.Println("go","lang")
	fmt.Println("1+1=", 1+1)
	fmt.Println("7.0/3.0")

	fmt.Println(true && false)
	fmt.Println(true || false)
	fmt.Println(!true)

}

运行结果：

变量与常量

1.变量

（1）标准声明

// Go语言用var声明变量

// go推断变量类型
var a = "TestString"
fmt.Println(a)

//  变量名后声明变量类型
var b, c int = 1, 2
fmt.Println(b, c)

var d = true
fmt.Println(d)

// 声明变量赋给默认值
var e int
fmt.Println(e)

（2）批量声明

    var (
        a string
        b int
        c bool
        d float32
    )

（3）短变量声明

// 化简写法声明字符串变量f（相当于 var f string = "apple"）
f := "apple"
fmt.Println(f)

2.常量

// 声明恒定值
const s string = "constant"

func Constants()  {
   
	fmt.Println(s)

	const n  = 500000

	const d = 3e20 / n

	fmt.Println(d)
	// 转换类型
	fmt.Println(int64(d))
	// 数学运算
	fmt.Println(math.Sin(n))

}

常量的声明只是将变量声明中的var更改为const

基本数据结构

1.数组Array

（1）声明默认数组

// 声明默认数组
var a [5]int
fmt.Println(a)
// 数组元素赋值
a[4] = 100
fmt.Println(a)
fmt.Println(a[4])
fmt.Println(len(a))

（2）声明并初始化数组

// 声明并初始化数组
b:= [5]int{
   1, 2, 3, 4}
// ...即让程序自动读取数组大小
c:= [...]int{
   1, 2, 3, 4, 5, 6}
fmt.Println(b, c)

（3）声明二维数组

// 声明二维数组
var twoD [2][3]int
for i := 0; i < 2; i++{
   
    for j:=0; j < 3; j++ {
   
    	twoD[i][j] = i + j
    }
}

fmt.Println(twoD)

2.切片Slice

（1）切片简介

切片是 Go 中的一种关键数据类型（引用类型），它为序列提供了比数组更强大的接口
切片的长度可以改变，因此，切片是一个可变的数组
切片遍历方式和数组一样，可以用len()求长度。表示可用元素数量，读写操作不能超过该限制

（2）切片一般声明

// 声明切片（让数组长度为空即形成切片）
var s1 []int
s2 := []int{
   2,4,5}
fmt.Println(s1, s2)

（3）make创建

// 声明非0长度的空片，需要用内置的make函数
// make([]type, len, cap):len（长度），cap（容量即为切片最长长度，可选）
// cap可以求出slice最大扩张容量，不能超出数组限制。len(slice) >= len(array)，其中array是slice引用的数组
s3 := make([]string, 5, 6)
fmt.Println(s3)
fmt.Println(len(s3),cap(s3))

（4）切片赋值与追加

// 切片赋值（虽然切片可以自动扩容，但是取索引时不会扩容）
s3[0] = "a"
s3[4] = "b"
fmt.Println(s3)

// 向切片中追加元素（必须接受返回值，在追加时可能使切片的容量增大）
s3 = append(s3, "d")
s3 = append(s3, "e","f")
// 切片可以追加其他切片或数组使用...解压缩
s3 = append(s3, s3...)
fmt.Println(s3)

（5）切片复制

// 切片复制
c := make([]string, len(s3))
copy(c, s3)
fmt.Println(c)

（6）由数组或切片获得切片

// 由数组或切片获得切片
// 获得s3的5，6元素
l := s3[5:7]
fmt.Println(l)
// 去掉切片最后一个元素
l = s3[:len(s3)-1]
fmt.Println(l)

3.Map

（1）map的创建

// 创建空地图（键类型为string，值类型为int）
m := make(map[string]int)
m1 := make(map[int]string)

（2）map初始化

// map初始化
n := map[string]string{
   "foo":"str1", "bar":"str2"}
fmt.Println(n)

（3）map赋值与取值

// map键值对赋值
m["k1"] = 7
m["k2"] = 10
// map的键为整型时区别于数组
m1[1] = "test1"
m1[10] = "test2"
fmt.Println(m)
fmt.Println(m1)

// 取值
v1 := m["k1"]
fmt.Println(v1)

不存在取值的返回：

// 不存在的键值默认返回为0，加上_,返回fasle（下划线用来忽略结果，也可以理解为那个位置本应赋给某个值，但是咱们不需要这个值）
prs := m["k2"]
_,prs2 := m["k2"]
fmt.Println(prs, prs2)

（4）map删除操作

// 删除（map限定，不存在的键自动略过不报错）
delete(m, "k2")
fmt.Println(m)

基本流程控制

1.if语句

func If(str string)  {
   

	// if语句
	if str=="IfA" {
   
		fmt.Println("a条件")
	}else{
   
		fmt.Println("其他条件")
	}

	// 声明可以先于条件
	if str = "IfA"; str=="IfA"{
   
		fmt.Println("a条件满足")

	}
	
}

2.switch语句

（1）使用变量作为判定条件

// switch基本案例,使用变量作为判定条件
i := 2
fmt.Println("write", i, "as")
    switch i {
   

    case 1:
    fmt.Println("one")

    case 2:
    fmt.Println("two")

    case 3:
    fmt.Println("three")

}

（2）使用函数返回的变量值作为expression

// 使用函数返回的变量值作为expression
// Weekday返回周数（weekday类型）
switch time.Now().Weekday(){
   
    case time.Saturday, time.Sunday:
    fmt.Println("weekend")

    default:
    fmt.Println("weekday")

}

（3）使用函数返回值的变量作为constant-expression

// 使用函数返回值的变量作为constant-expression
t := time.Now()
switch {
   

    case t.Hour() >= 6 && t.Hour() < 8:
    fmt.Println("清晨")
    case t.Hour() >= 8 && t.Hour() < 12:
    fmt.Println("早上")

    default:
    fmt.Println("其他时间")

}

3.for语句

func For()  {
   

	i := 1

	// 只要i小于等于3就一直执行循环
	for i <= 3{
   
		fmt.Println(i)
		i = i + 1

	}

	// 经典for语句初始/条件/后循环
	for j := 7; j <= 9; j++{
   
		fmt.Println(j)
	}

	// 无条件for循环等待break终止
	for{
   
		fmt.Println("loop")
		break
	}

	for n:= 0; n <= 5; n++{
   

		// 复数进入下个循环
		if n%2 == 0 {
   
			continue
		}
		fmt.Println(n)

	}
	
}

4.Range语句

（1）Range简介

range类似迭代器操作，返回 (索引, 值) 或 (键, 值)
range 格式可以对 slice、map、数组、字符串等进行迭代循环

（2）数组遍历

nums := []int{
   2, 3, 4}
sum := 0
// 遍历数组
//range会提供索引和值，这里我们不需要索引所以用占位符代替
for _, num := range nums{
   
sum += num
}
fmt.Println(sum)

（3）map遍历

// 遍历map
kvs := map[string]string{
   "a":"Ava", "b":"Bella", "c":"Carol", "d":"Diana", "e":"Eileen"}

for k, v := range kvs{
   
	fmt.Printf("%s : %s\n", k, v)
}

// 遍历键
for k := range kvs{
   
	fmt.Println(k