一文搞定 go 入门基础

前言: 在前前一段时间里，公司业务需求认为学习go对熟悉业务代码有很大的帮助，对于刚刚开始学习go的我，过完了一遍go基本语法和gin所有的demo有一种感觉–>天晴了，雨停了，我又行了。。
实际场景上，当没代码没得抄时，一脸懵逼，最近也总结了下为啥有这种情况，一是代码量还差得远，二是下层建筑不牢固。
这一段时间，十分认真的思考了很多问题，所以决定不管如何需要将go做到从入门到进阶的水平。所有学习其实都一样，不能浮躁要沉下心来，不能急于求成，没有啃不会的书，只有不够努力的人。
至此，我会将所学到的所有go知识点汇总沉淀到go专栏中，希望个人技能🌲能有所提升。

作者：变优秀的小白

Github：关注YX-XiaoBai

QQ群(new): 811792998

爱好：Americano More Ice !

下面是关于go基础知识的补充，所以知识点都以实际例子来演示使用

一文搞定 go 入门基础

packages(包)

• 按照约定，包名与导入路径的最后一个元素一致。

例如，"math/rand"包中的源码均以package rand语句开始。

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	fmt.Println("My favorite number is", rand.Intn(10))
}

imports(导入)

• 此代码用圆括号组合了导入，这是分组形式的导入语句

当然可以编写多个导入语句，但 分组导入 是更好的形式

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("Now u have %g problems.\n", math.Sqrt(9))
}

exported-names(导出名)

• 在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。

Go中，以大写字母开头即已导出，以小写字母开头即未导出

func main() {
	fmt.Println(math.Pi)
}
// output
// 3.141592653589793

• 举个未导出而去使用的例子

func main() {
	fmt.Println(Math.pi)
}
// output
// # command-line-arguments
// main/exported-names.go:13:14: cannot refer to unexported name math.pi
// main/exported-names.go:13:14: undefined: math.pi

functions(函数)

• 函数可以没有参数 或 接受多个参数

package main

import "fmt"

func add(x int, y int) int {
	return x + y
}

func main()  {
	fmt.Println(add(60, 6))
}
// output
// 66

• 当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其它都可以省略

x int, y int的缩写 -> x, y int

func add1(x, y int) int {
	return x + y
}

multiple-results(多值返回)

• 函数可以返回任意数量的返回值

package main

import "fmt"

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}
// output
// world hello

named-results(命名返回值)

• Go的返回值可被命名，它们会被视作定义在函数顶部的变量

需要注意的是，没有参数的 return 语句返回已命名的返回值，即直接返回，长函数不建议使用，会影响可读性

package main

import "fmt"

func split(sum int) (x, y int) {
	x = sum * 4 /9
	y = sum - x
	return
}

func main() {
	fmt.Println(split(9))
}

variables(变量)

• var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。

var可以出现在包或函数级别

package main

import "fmt"

var c, python, java bool

func main() {
	var i int
	// 输出变量定义的默认值
	fmt.Println(i, c, python, java)
}
// output
// 0 false false false

variables-with-initializers(变量初始化)

• 变量声明可以包含初始值，每个变量对应一个

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型

package main

import "fmt"

var i, j int = 1, 2

func main() {
	var c, python, java = true, false, "no!"
	fmt.Println(i, j , c, python, java)
}
// output
// 1 2 true false no!

short-variable-declarations(短变量声明)

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明
函数外的每个语句都必须以关键字开始（var, func 等等）

需要注意的是， := 结构不允许在函数外使用

package main

import "fmt"

func main() {
	var i, j int = 1, 2
	k := 3
	c, python, java := true, false, "no!"

	fmt.Println(i, j, k, c, python, java)
}

basic-type(基本类型)

Go的基本类型如下

	bool
	string
	int  int8  int16  int32  int64
	uint uint8 uint16 uint32 uint64 uintptr
	byte // uint8 的别名
	rune // int32 的别名
		// 表示一个 Unicode 码点
	float32 float64
	complex64 complex128

实际场景使用如下，其中涉及了go的运算符和包的func使用，后面文章会补充~

import (
	"fmt"
	"math/cmplx"
)

var (
	ToBe bool = false
	MaxInt uint64 = 1<<64 - 1
	z complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
	fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
	fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
	fmt.Printf("Type: %T Value: %v\n", z, z)
}

zero(零值)

• 没有明确初始值的变量声明会被赋予它们的 零值

数值类型为 0，
布尔类型为 false，
字符串为 ""（即空字符串)

package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string
	
	fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

type-conversions(类型转换)

• 表达式 T(v) 将值 v 转换为类型 T

package main

import (
	"fmt"
	"math"
)

func main() {
	var x, y int = 3, 4
	var f float64 = math.Sqrt(float64(x*x + y*y))
	var z uint = uint(f)
}

我们可以从上面代码进一步简化写法

func main() {
	x, y := 3, 4
	f :=	math.Sqrt(float64(x*x + y*y))
	z := uint(f)
	fmt.Println(x, y, z)
}

type-inference(类型推导)

下面的例子可以通过修改v后运行查看，变量的类型由:=右边的值推导得出

package main

import "fmt"

func main() {
	v := 66
	fmt.Println("v is of type %T\n", v)
}

constants(变量)

• 使用const关键字
• 常量可以是字符、字符串、布尔值或数值
• 注意！常量不能用:=语法声明

package main

import "fmt"

const Pi = 3.14

func main() {
	const World = "小白"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("GO rules?", Truth)
}

numeric-constants(数值常量)

最后来讲下数值常量，数值常量是高精度的值，可以根据下面给的例子去理解一下

package main

import "fmt"

const (
	// 将 1 左移 100 位来创建一个非常大的数字
	// 即这个数的二进制是 0000 0001，右移后 1 跟着 100 个 0
	Big = 1 << 100
	// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
	Small = Big >> 99
)

func needInt(x int64) int64 { return x*10 + 1 }
func needFloat(x float64) float64 {
	return x * 0.1
}

func main() {
	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))
	//fmt.Println(needInt(Big))
}

结束语：大家如果遇到什么疑问或者建议的，可直接留言评论！作者看到会马上一一回复！

如果觉得小白此文章不错或对你有所帮助，留下一键三连💫！❤️ni！