教程集 > Golang编程 > golang教程 > 正文 Golang知识点（已更新完入门阶段）

Golang知识点（已更新完入门阶段）

发布时间：2021-04-18 编辑：jiaochengji.com

教程集为您提供Golang知识点（已更新完入门阶段）等资源，欢迎您收藏本站，我们将为您提供最新的Golang知识点（已更新完入门阶段）资源

文章目录

入门
- 导出名
- 函数
- 变量
- 短变量声明
- 基本类型
- 类型转换
- 类型推导
- 常量
- 数值常量
- for
- if 的简短语句
- switch
- defer 栈
- 指针
- 结构体字段
- 结构体指针
- 结构体文法
- 数组
- 切片
- 切片就像数组的引用
- - 切片的默认行为
  - 切片的长度与容量
- nil 切片
- - 用 make 创建切片
  - append函数
- Range
- 方法
- 方法与指针重定向
- 选择值或指针作为接收者
- 接口与隐式实现
- 错误
- Reader
- goroutine
- 信道
- range 和 close
- select 语句
- 默认选择
- sync.Mutex

入门

导出名

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

pizza 和 pi 并未以大写字母开头，所以它们是未导出的。

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

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Pi)
}

package main

import (
	"fmt"
	_"math"
)

func main() {
	fmt.Println(11)
}

函数

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

在本例中，add 接受两个 int 类型的参数。

注意类型在变量名之后。

package main

import "fmt"

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

func main() {
	fmt.Println(add(42, 13))
}

变量

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

就像在这个例子中看到的一样，var 语句可以出现在包或函数级别

package main

import "fmt"

var c, python, java bool

func main() {
	var i int
	fmt.Println(i, c, python, java)
}

短变量声明

在函数中，简洁赋值语句 := 可在类型明确的地方代替 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)
}

基本类型

Go 的基本类型有

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
    // 表示一个 Unicode 码点

float32 float64

complex64 complex128

本例展示了几种类型的变量。同导入语句一样，变量声明也可以“分组”成一个语法块。

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。

package main

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)
}

字符串格式化:

// 定义示例类型和变量
type Human struct {
 Name string
}

var people = Human{Name:"zhangsan"}

*普通占位符*
占位符     说明                           举例                   输出
%v      相应值的默认格式。            Printf("%v", people)   {zhangsan}，
% v     打印结构体时，会添加字段名     Printf("% v", people)  {Name:zhangsan}
%#v     相应值的Go语法表示           Printf("%#v", people)   main.Human{Name:"zhangsan"}
%T      相应值的类型的Go语法表示       Printf("%T", people)   main.Human
%%      字面上的百分号，并非值的占位符  Printf("%%")            %

*布尔占位符*
占位符       说明                举例                     输出
%t          true 或 false。     Printf("%t", true)       true

*整数占位符*
占位符     说明                                  举例                       输出
%b      二进制表示                             Printf("%b", 5)             101
%c      相应Unicode码点所表示的字符              Printf("%c", 0x4E2D)        中
%d      十进制表示                             Printf("%d", 0x12)          18
%o      八进制表示                             Printf("%d", 10)            12
%q      单引号围绕的字符字面值，由Go语法安全地转义  Printf("%q", 0x4E2D)        '中'
%x      十六进制表示，字母形式为小写 a-f          Printf("%x", 13)             d
%X      十六进制表示，字母形式为大写 A-F          Printf("%x", 13)             D
%U      Unicode格式：U 1234，等同于 "U X"    Printf("%U", 0x4E2D)        U 4E2D

*浮点数和复数的组成部分（实部和虚部)*
占位符     说明                              举例                           输出
%b      无小数部分的，指数为二的幂的科学计数法，
     与 strconv.FormatFloat 的 'b' 转换格式一致。例如 -123456p-78
%e      科学计数法，例如 -1234.456e 78        Printf("%e", 10.2)       1.020000e 01
%E      科学计数法，例如 -1234.456E 78        Printf("%e", 10.2)       1.020000E 01
%f      有小数点而无指数，例如 123.456        Printf("%f", 10.2)        10.200000
%g      根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%g", 10.20)   10.2
%G      根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%G", 10.20 2i) (10.2 2i)

*字符串与字节切片*
占位符     说明                              举例                           输出
%s      输出字符串表示（string类型或[]byte)   Printf("%s", []byte("Go语言"))  Go语言
%q      双引号围绕的字符串，由Go语法安全地转义  Printf("%q", "Go语言")         "Go语言"
%x      十六进制，小写字母，每字节两个字符      Printf("%x", "golang")         676f6c616e67
%X      十六进制，大写字母，每字节两个字符      Printf("%X", "golang")         676F6C616E67

*指针*
占位符         说明                      举例                             输出
%p      十六进制表示，前缀 0x          Printf("%p", &people)             0x4f57f0

*其它标记*
占位符      说明                             举例          输出
       总打印数值的正负号；对于%q（% q）保证只输出ASCII编码的字符。 
                                           Printf("% q", "中文")  "\u4e2d\u6587"
-      在右侧而非左侧填充空格（左对齐该区域）
#      备用格式：为八进制添加前导 0（%#o）      Printf("%#U", '中')      U 4E2D
       为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；
       如果可能的话，%q（%#q）会打印原始 （即反引号围绕的）字符串；
       如果是可打印字符，%U（%#U）会写出该字符的
       Unicode 编码形式（如字符 x 会被打印成 U 0078 'x'）。
' '    (空格)为数值中省略的正负号留出空白（% d）；
       以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开
0      填充前导的0而非空格；对于数字，这会将填充移到正负号之后

golang没有 ‘%u’ 点位符，若整数为无符号类型，默认就会被打印成无符号的。

宽度与精度的控制格式以Unicode码点为单位。宽度为该数值占用区域的最小宽度；精度为小数点之后的位数。
操作数的类型为int时，宽度与精度都可用字符 ‘*’ 表示。

对于 %g/%G 而言，精度为所有数字的总数，例如：123.45，%.4g 会打印123.5，（而 %6.2f 会打印123.45）。

%e 和 %f 的默认精度为6

对大多数的数值类型而言，宽度为输出的最小字符数，如果必要的话会为已格式化的形式填充空格。

而以字符串类型，精度为输出的最大字符数，如果必要的话会直接截断。

类型转换

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

一些关于数值的转换：

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

或者，更加简单的形式：

i := 42
f := float64(i)
u := uint(f)

Go 在不同类型的项之间赋值时需要***显式***转换.

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)
	fmt.Println(x, y, z)
}

类型推导

在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var =表达式语法），变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同：

var i int
j := i // j 也是一个 int

不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int, float64 或 complex128 了，这取决于常量的精度：

i := 42           // int
f := 3.142        // float64
g := 0.867   0.5i // complex128

常量

常量的声明与变量类似，只不过是使用 const 关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用 := 语法声明。

数值常量

数值常量是高精度的值。

一个未指定类型的常量由上下文来决定其类型。

（int 类型最大可以存储一个 64 位的整数，有时会更小。）

（int 可以存放最大64位的整数，根据平台不同有时会更少。）

package main

import "fmt"

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

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

func main() {
  //fmt.Println(Big)// overflows int
	fmt.Println(needInt(Small))//21
	fmt.Println(needFloat(Small))//0.2
	fmt.Println(needFloat(Big))//1.2676506002282295e 29
}

for

Go 只有一种循环结构：for 循环。

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号，大括号 { } 则是必须的。

初始化语句和后置语句是可选的。

package main

import "fmt"

func main() {
	sum := 1
	for ; sum < 1000; {
		sum  = sum
	}
	fmt.Println(sum)
}

此时你可以去掉分号，因为 C 的 while 在 Go 中叫做 for。

package main

import "fmt"

func main() {
	sum := 1
	for sum < 1000 {
		sum  = sum
	}
	fmt.Println(sum)
}

if 的简短语句

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

package main

import (
	"fmt"
	"math"
)

func pow(x, n, lim float64) float64 {
	if v := math.Pow(x, n); v < lim {
		return v
	}
	return lim
}

switch

switch 是编写一连串 if - else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。

Go 只运行选定的 case，而非之后所有的 case。实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

package main

import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Print("Go runs on ")
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.\n", os)
	}
}

defer 栈

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照先进后出的顺序调用

package main

import "fmt"

func main() {
	fmt.Println("counting")

	for i := 0; i < 10; i   {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

指针

类型 *T 是指向 T 类型值的指针。其零值为 nil。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

结构体字段

结构体字段使用点号来访问。

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	v.X = 4
	fmt.Println(v.X)
}

结构体指针

结构体字段可以通过结构体指针来访问

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	p := &v
  p.X = 1e9 // (*p).X = 1e9, 此处隐式间接引用
	fmt.Println(v)
}

结构体文法

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体
	v2 = Vertex{X: 1}  // Y:0 被隐式地赋予
	v3 = Vertex{}      // X:0 Y:0
	p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)

func main() {
	fmt.Println(v1, v2, v3, p)// {1 2} {1 0} {0 0} &{1 2}
}

数组

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

package main

import "fmt"

func main() {
	var a [2]string
	a[0] = "Hello"
	a[1] = "World"
	fmt.Println(a[0], a[1])
	fmt.Println(a)

	primes := [6]int{2, 3, 5, 7, 11, 13}
	fmt.Println(primes)
}

切片

类型 []T 表示一个元素类型为 T 的切片。

切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔, 左闭右开

package main

import "fmt"

func main() {
	primes := [6]int{2, 3, 5, 7, 11, 13}

	var s []int = primes[1:4]
	fmt.Println(s)// [3, 5, 7]
}

//切片文法
q := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(q)//[2 3 5 7 11 13]

切片就像数组的引用

切片并不存储任何数据，它只是描述了底层数组中的一段。

更改切片的元素会修改其底层数组中对应的元素。

与它共享底层数组的切片都会观测到这些修改。

切片的默认行为

切片下界的默认值为 0，上界则是该切片的长度。

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}

	s = s[1:4]
	fmt.Println(s)//[3, 5, 7]

	s = s[:2]
	fmt.Println(s)// [3, 5]

	s = s[1:]
	fmt.Println(s)//[5]
}

切片的长度与容量

切片s拥有长度 len(s)和容量cap(s)。

切片的长度就是它所包含的元素个数。

切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	printSlice(s)

	// 截取切片使其长度为 0
	s = s[:0]
	printSlice(s)

	// 拓展其长度
	s = s[:4] // s = s[:7]  silce bounds out of range
	printSlice(s)

	// 舍弃前两个值
	s = s[2:]
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

nil 切片

切片的零值是 nil。

nil 切片的长度和容量为 0 且没有底层数组。

用 make 创建切片

切片可以用内建函数 make 来创建，这也是你创建动态数组的方式。

make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：

a := make([]int, 5)  // len(a)=5

要指定它的容量，需向 make 传入第三个参数：

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

append函数

加到切片末尾
当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

将b加到a末尾

a := []string{"John", "Paul"}
b := []string{"George", "Ringo", "Pete"}
a = append(a, b...) // equivalent to "append(a, b[0], b[1], b[2])"

Range

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本

可以将下标或值赋予 _ 来忽略它。

for i, _ := range pow
for _, value := range pow

若你只需要索引，忽略第二个变量即可。

for i := range pow

func main() {
	pow := make([]int, 10)
	for i := range pow {
		pow[i] = 1 << uint(i) // == 2**i
	}
	for _, value := range pow {
		fmt.Printf("%d\n", value)
	}
}

方法

Go 没有类。不过你可以为结构体类型定义方法。

方法就是一类带特殊的 接收者 参数的函数。

方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。

在此例中，Abs 方法拥有一个名为 v，类型为 Vertex 的接收者。

package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X   v.Y*v.Y)
}

func main() {
	v := Vertex{3, 4}
	fmt.Println(v.Abs())
}

方法与指针重定向

比较前两个程序，你大概会注意到带指针参数的函数必须接受一个指针：

var v Vertex
ScaleFunc(v, 5)  // 编译错误！
ScaleFunc(&v, 5) // OK

而以指针为接收者的方法被调用时，接收者既能为值又能为指针：

var v Vertex
v.Scale(5)  // OK
p := &v
p.Scale(10) // OK

对于语句 v.Scale(5)，即便 v 是个值而非指针，带指针接收者的方法也能被直接调用。也就是说，由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5)。

package main

import "fmt"

type Vertex struct {
	X, Y float64
}

func (v *Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func ScaleFunc(v *Vertex, f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func main() {
	v := Vertex{3, 4}
	v.Scale(2)
	ScaleFunc(&v, 10)

	p := &Vertex{4, 3}
	p.Scale(3)
	ScaleFunc(p, 8)

	fmt.Println(v, p)
}
您可能感兴趣的文章：

                   php难不难

                   PHP多久能学会？

                   Golang笔记：语法，并发思想，web开发，Go微服务相关

                   为什么要学 Go

                   golang gc实现分析（go1.14.4）

                   小米技术出品——走进Golang之编译器原理

                   php架构师主要是做什么的

                   php程序员需要会什么技术？

                   【后端教程】走进Golang之编译器原理

                   seo网站优化必须看哦


        
        
        




        
        
            
            
        

        
            上一篇：golang toml解析
            下一篇：Go语言学习、二维数组
                    

        

            [关闭]






    

    



    
        最近更新
        
                        判断单选按钮是否选中代码
                        图片滚代码
                        文件上传前判断合法性
                        文件上传前判断合法性[远程文件]
                        ctrl 回车发布信息
                        间歇式滚动广告[直滚]
                        windows启动效果
                        遮照层上面浮动的确定层效果
                        CSS滑门为自动切换
                        图片轮显效果
                    
    

    
    
        浏览排行
        
                        判断单选按钮是否选中代码
                        图片滚代码
                        文件上传前判断合法性
                        文件上传前判断合法性[远程文件]
                        ctrl 回车发布信息
                        间歇式滚动广告[直滚]
                        windows启动效果
                        遮照层上面浮动的确定层效果
                        CSS滑门为自动切换
                        图片轮显效果