Go语言之基础知识

╰+攻爆jí腚メ 2023-02-17 06:23 91阅读 0赞

Go语言的出现是为了解决当下编程语言以下的问题：

*  对并发支持不友好
 *  编译速度慢
 *  编程复杂

## Go语言能干什么事？ ##

*  服务器编程，以前你如果使用C或者C++做的那些事情，用Go来做很合适，例如处理日志、数据打包、虚拟机处理、文件系统等。
 *  分布式系统、数据库代理器、中间件等，例如Etcd。
 *  网络编程，这一块目前应用最广，包括Web应用、API应用、下载应用，而且Go内置的net/http包基本上把我们平常用到的网络功能都实现了。
 *  数据库操作
 *  开发云平台，目前国外很多云平台在采用Go开发

## token ##

token是构成源程序的基本不可再分割的单元。  
编译器编译源程序的第一步就是将源程序分割一个个独立的token,这个过程就是词法分析。  
token可以分为关键字、标识符、操作符、分割符合字面常量等。

将源程序分割成token是借助分割符来实现，分割符主要有两类：

*  操作符：+、-、\*、/ 等等,操作符是分割符，也是一种token
 *  纯分割符：包括空格、制表符、换行符合回车符，其本身不具备任何语法含义，只作为其他token的分割功能。

Go语言一共支持25个关键字，主要分为三类。  
引导程序整体结构的8个关键字

*  package //定义包名
 *  import //导入包名
 *  const //常量声明
 *  var //变量声明
 *  func //函数定义
 *  defer //延迟执行
 *  go //并发语法糖
 *  return //函数返回

声明复合数据结构的4个关键字

*  struct //定义结构类型
 *  interface //定义接口类型
 *  map //声明或创建map类型
 *  chan //声明或创建通道类型

控制程序结构的13个关键字

*  if else //if else 语句关键字
 *  for range break continue //for 循环使用
 *  switch select type case default fallthrough //switch和select语句使用的关键字
 *  goto //goto跳转语句

## Go语言提供了20种数据类型 ##

整数（12个）：byte int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr  
浮点数（2个）：float32 float64  
复数型（2个）：complex64 complex128  
以上几种的数据类型转换可通过强制类型装换来实现

var count int = 5  
var mean float32 = float32(count)

字符和字符串型（2个）：string rune  
字符串与数字的转化是借助strconv来实现的  
补充： = 是赋值， := 是声明变量并赋值 并且系统自动推断类型，不需要var关键字

package main
    import (
       "fmt"
       "strconv"
    )
    func main() { 
       c,err := strconv.ParseFloat(b,64)   //这里是短类型声明的方式，可以同时对多个变量进行赋值
       _ = err //（_是空白标识符） err是操作失败赋予的默认值，这句是解决err没有被使用的报错 
       fmt.Println("Hello, World!",c)
    }

接口型（1个）：error  
布尔型（1个）：bool

其他  
内置函数（15个）： make new len cap append copy delete panic recover close complex real image print println  
常量值标识符（4个）

*  true false
 *  inta //用在连续的枚举类型的声明中
 *  nil //指针、引用型的变量的默认值就是nil （可以理解为null）
 *  空白标识符（1个）：\_ //用来声明一个匿名的变量，通常用来占位，避免变量未使用，编译不通过。

## Go语言支持的复合数据类型 ##

复合数据类型指的是其他类型组合而成的类型。Go语言支持一下的复合数据类型：

*  指针
 *  数组
 *  切片
 *  字典
 *  通道
 *  结构
 *  接口

## 指针 ##

Go语言支持指针，指针的声明类型为\*T，Go同样支持多级指针\*\*T。  
指针是一种保存变量地址的变量.  
对于普通变量，只允许修改它的内容；对于指针，可以修改指针变量的指向地址和该地址的内容。

//普通数据
    a := 123
    b  := &a
    //b++ Go禁止指针运算
    
    //结构体
    type User stuct{ 
     name string
     age int
    }
    andes := User{ 
       name : "luo"
       age : 18
    }
    p := &andes

## 数组 ##

数组创建完长度就固定了，不可以再追加元素  
数组初试化的方式有以下方式：  
1.指定长度和初始化字面量

array :=[3] int{ 1,2,3}

2.不指定长度，但是由后面的初始化列表数量来确定其长度

array :=[...]int{ 1,2,3}

3.指定总长度，并通过索引值进行初始化，没有初始化元素时使用类型默认值

array :=[3]int{ 1:1,2:3}

4.不指定总长度，并通过索引值进行初始化，没有初始化元素时使用类型默认值

array :=[...]int{ 1:1,2:3}

**数组操作**  
方式一

array :=[...]int{ 1,2,4}
    for i,v := range array{ 
       fmt.Println("Hello, World!", v)
       _ = i
    }

// i是索引值，v是真实值  
//输出结果  
Hello, World! 1  
Hello, World! 2  
Hello, World! 4

方式二

array :=[...]int{ 1,2,4}
    alengh := len(array)
    for i:=0;i<alengh;i++ { 
       fmt.Println("Hello, World!", array[i])
    }

## 切片 ##

切片（slice）是一种变长数组，其数据结构中有指向数组的指针，所以是一种引用类型。  
其结构如下：

type slice struct { 
    array unsafe.Pointer   //指向底层数组的指针
    len int  //切片的元素数量
    cap int  //底层数组的容量
    }

1.由数组创建切片

array :=[...]int{ 1,2,3,4,5,6,7}
    s1 := array[0:5] //获取 array[0] -array[4]
    s2 := array[:5]  //获取 array[4]之前所有的
    s3 := array[2:5] //获取 array[2] 到 array[4]
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)

结果是：  
\[1 2 3 4 5\]  
\[1 2 3 4 5\]  
\[3 4 5\]

2.通过内置函数make创建切片  
由内置函数make创建的切片个元素被默认初始化为切片元素类型的零值。

//len=10,cap=10
    aslice := make([]int, 10)
    
    //len=10,cap=15
    bslice := make([]int,10,15)
    fmt.Println(aslice)
    fmt.Println(bslice)
    
    //获取切片长度
    fmt.Println(len(aslice))
    //获取切片底层数组容量
    fmt.Println(cap(aslice))
    //对切片追加元素
    bslice = append(bslice,1)
    fmt.Println(bslice)
    fmt.Println("拷贝前的aslice",aslice)
    fmt.Println("拷贝前的bslice",bslice)
    
    //用于复制一个切片，只会复制aslice、bslice中最小的
    copy(aslice,bslice)
    fmt.Println("拷贝后的aslice",aslice)
    fmt.Println("拷贝后的bslice",bslice)

结果为：  
\[0 0 0 0 0 0 0 0 0 0\]  
\[0 0 0 0 0 0 0 0 0 0\]  
10  
10  
\[0 0 0 0 0 0 0 0 0 0 1\]  
拷贝前的aslice \[0 0 0 0 0 0 0 0 0 0\]  
拷贝前的bslice \[0 0 0 0 0 0 0 0 0 0 1\]  
拷贝后的aslice \[0 0 0 0 0 0 0 0 0 0\]  
拷贝后的bslice \[0 0 0 0 0 0 0 0 0 0 1\]

3.字符串和切片的相关转换

str :="hello,世界!"
    a := []byte(str)  //将字符串转换为[]byte类型的切片
    b := []rune(str)   //将字符串转换为[]rune类型的切片
    fmt.Println(a)
    fmt.Println(b)

结果：  
\[104 101 108 108 111 44 228 184 150 231 149 140 33\]  
\[104 101 108 108 111 44 19990 30028 33\]

## map ##

map是一种引用类型，又称为字典类型。map\[K\]T K是key的类型 T是value的类型

1.map的创建  
方式一：使用字面量创建

ma :=map[string]int{ "a":1,"b":2}
    fmt.Println(ma["a"])
    fmt.Println(ma["b"])

结果：  
1  
2

方式二：使用内置的make函数创建  
make(map\[K\]T) //map的容量使用默认值  
make(map\[K\]T,len) //map的容量使用给定的len值

mp1 :=make(map[int]string)
    mp2 :=make(map[int]string,10)
    mp1[1] = "luo"
    mp2[1] = "king"
    fmt.Println(mp1[1])
    fmt.Println(mp2[1])

结果：  
luo  
king

map的操作

//遍历操作
    mp1 :=make(map[int]string)
    mp1[1] = "luo"
    mp1[2] = "nice"
    
    //删除
    delete(mp1,1)
    for k,v := range mp1{ 
       fmt.Println("key=",k,"value=",v)
    }
    
    //修改
    mp1[2] = "bad"
    for k,v := range mp1{ 
       fmt.Println("key=",k,"value=",v)
    }

结果：  
key= 2 value= nice  
key= 1 value= luo  
key= 2 value= nice  
key= 2 value= bad

备注：  
1.如果map的Value的类型是引用类型的话，不能够直接使用 ma\[1\].age =12 方式进行修改  
要修改对象后，替换整个元素  
2.map不是并发安全地，并发安全的map可以使用标准包sync中的map.

## struct ##

Go中的struct类型和C类似，即为结构  
struct的声明以及赋值

package main
    import (
       "fmt"
    )
    
    type Person struct{ 
       name string
       age int
    }
    
    
    type Class struct{ 
       Person
       number int
    }
    
    func main() { 
    
    p := Person{ 
    name: "luo",
    age: 18,
    }
    c :=Class{ 
         Person :p,
         number:12,
    }
    fmt.Println(p)
    fmt.Println(c)
    
    }

结果：  
\{luo 18\}  
\{ \{luo 18\} 12\}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200812232622964.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA==,size_16,color_FFFFFF,t_70#pic_center