Golang语言基础知识点小总结

Golang语言基础知识点小总结

1.go语言有两大类型：

数值类型boolstring数组struct结构体指针slice切片管道chanmapinterface

2.变量的定义：

局部变量

var `变量名` `类型` = `参数`
var `变量名` = `参数`
`变量名` := `参数`

全局变量

var (
     `变量名` = `参数`
)

整数类型小数类型

3.Golang语言中的单引号和双引号的区别：

''""

4.字符串拼接格式：

var str1 string = "123"+
				"456"

5.基本数据类型转换：

在go语言中转换数据类型需要显式转换
将float64类型转换为float32类型

var n1 float64 = 3.2
n2 := float32(n1) 

6.基本数据类型转换为string数据类型：

fmt.Sprintf

num1 := 3
string1 := fmt.Sprintf("%d",num1)

strconv

str1 := strconv.FormatInt(num1,10)         #第一个参数是变量，第二个参数是这个变量的类型  2是2进制数，10是10进制数  具体看官方文档

strconv.Itoa

str1 := strconv.Itoa(num1)                #num1是int类型

7.string数据类型转换为基本数据类型：

var str1 string = "1"
//bool
b,_ := strConv.ParseBool(str1)
//int
b,_ := strConv.ParseInt(str1,10,0)
//float
b,_ := strConv.ParseFloat(str1,64)

8.指针：

*ptr&num&ptr

num := 1
var ptr *int = &num
&ptr = 2

9.接收键盘输入语句：

var name string
fmt.Scanln(&name)
或
fmt.Scanf("%s",&name)

10.分支结构

if elseswitch

swich 表达式 {
		case 表达式1，表达式2，表达式3：
			语句块
			fallthrough
		default:
			语句块	
}

表达式caseif或defaultelseswtchfallthrough

11.for循环控制

1.
num1 := 10
for i:=0; i<num1;i++{
	语句块
}
2.
num1 := 10
i := 1
for i<num1{
	语句块
	i++
}
3.
for {
	语句块
	break
}

for 后面如果什么也不写，相当于无限循环

12.遍历数组

var str [5]int = [5]int{1,2,3,4,5}
for index,val := range str{
	语句块
}

indexval

13.多层循环break和continue的使用

lable1:
for i:=1;i<10;i++{
	lable2:
	for j:=1;j<10;j++{
	}
}

breakbreak lable1continue

14.goto 基本介绍(不推荐使用)

num1 :=1
if num1 == 1{
 	goto lable1
}
fmt.println("你好1")
lable1:
fmt.println("你好2")

输出的会是"你好2"

15.函数定义的基本语法：

func 函数名(形参 类型，形参 类型)（返回值 类型）{
			执行语句
}

16.包的一些知识点

import 自定义名 "路径"

17.打包语法

go build -o 指定路径 需要打的包名

18.自定义类型的细节

type mytype int

mytype

19.func可以当参数传递

func mytype1(num1 int, num2 int)int{

}
func mytype2(n1 func(int,int)int, num1 int, num2 int){
	语句块
}
fun main(){
	num1 := 1
	num2 := 2
	mytype2(mytype1,num1,num2)
}

20.可变参数

func args1(args... int){
	fmt.Println(args)
}

func main(){
	args1(1,2,3,4)
}

args

21.init函数细节

init

22.匿名函数细节

func (n1 int, n2 int)int{
	return n1+n2
}(n1,n2)
或
a := func (n1 int, n2 int)int{}(n21,n2)

匿名函数

23.闭包

func Addupper()func(int,int)int{
	return func(n int,n2 int)int{
		return n+n2
}
}

func main(){
	add := Addupper()
	num3 := add(2,3)
	fmt.Println(num3)
}

24.defer延迟机制

defer

25.时间日期

import "time"
now := time.Now()          # 获取当前时间
now.Format("2006-0102 15:04:05")     #格式化日期时间
now.Unix()        #秒数时间戳
now.UnixNano()   #纳秒数时间戳

26.捕获异常defer+recover

defer func(){
	err := recover()          //revcover可以捕获到异常
	if err != nil{
		fmt.Println("err",err)
	}
}

捕获异常的最大作用在于当程序报错时，后面的代码还可以执行

27.自定义异常 errors.New和panic内置函数

import "errors"
errors.New("代码执行错误")
Panic(err)

自定义异常的最大作用在于读取文件错误时后面的代码不能执行，需要终止程序

28.数组(值类型)

var num [3]int = [3]int{1,2,3}
var num = [...]int{8,9,10}
var num = [...]int{0:8,1:9,2:10}

29.slice切片(值类型）

var num [3]int = [3]int{1,2,3}
var slice1 := num[:]
var slice2 := make([]int,4,10)  #4是大小，10是容量
var slice3 []int = []int{1,2,3}

注意：切片和数组是有很大区别的，数组的大小是固定的，切片大小可以变化

var slice1 []int = []int{1,2,3}
slice1 = append(slice,4)
var slice2 = make([]int,1)
copy(slice2,slice1)          #将slice1的数据copy给slice2

30.map(引用类型) key-value数据结构

var a map[string]string := make(map[string]string)
增 改：
a["key"] = value
删：
delete(a,"key")
查：
val,finRes := a["key"]

for-range

31.结构体

type Logins struct {
	Username string `json:"userename"`
	Password string `json:"password"`
}

序列化/反序列化

import "encoding/json"
var u Logins = Logins{"Username":"123","Password":"123"}
序列化：
jsonstr,err := json.Marshal(结构体变量)
if err != nil{
	fmt.Println("序列化错误")
}

反序列化：
json.Unmarshal([]byte(jsonstr),&u)