Go知识点

淡淡的烟草味﹌ 2022-10-06 01:00 161阅读 0赞

### 文章目录 ###

*  运算符
 *  函数
 *  数组(java的数组类型和数量倒过来)
 *  指针
 *  结构体
 *  切片（动态数组）
 *  接口
 *  Map
 *  错误处理（自带接口error中的方法Error()）
 *  go并发
 *   *  通道

> go没有类

# 运算符 #

- &返回变量存储地址，取址。：	
        - &（变量）; 将给出变量的实际地址。
    - *指针变量。取值：	
      - *（地址）;取数值。*a定义一个指针变量。

# 函数 #

*  函数作为另一个函数的实参
 *  闭包
 *  方法

# 数组(java的数组类型和数量倒过来) #

*  声明
    
     *  `var balance [10] float32`
 *  初始化
    
     *  声明并且初始化
        
         *  定长：balance := \[1\]float32\{0.0\}
         *  不定长：`balance := [...]float32{0.0}`/`var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}`
 *  多维数组
    
        a := [3][4]int{
                
            {
              0, 1, 2, 3} ,   /*  第一行索引为 0 */
             {
              4, 5, 6, 7} ,   /*  第二行索引为 1 */
             {
              8, 9, 10, 11},   /* 第三行索引为 2 */
          }

# 指针 #

*  指针就是存放的是变量的地址，通过*int来声明，直接读取是&a的地址，通过加*来读取，是取数值。
 *  &变量：取变量的地址。\*指针：取指针指向的数值。
 *  空指针：声明未赋值。通过ptr== nilp判断。
 *  指针的指针：var ptr \*\*int;
 *  指针作为函数参数：传地址。

# 结构体 #

*  定义：
    
        type Books struct {
              
                    title string
                    author string
                    subject string
                    book_id int
            }
 *  使用
    
     *  直接赋值
        
            Books{
                    "Go 语言", "www.runoob.com", "Go 语言教程", 6495407}
     *  键值对赋值
        
            Books{
                    title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407}
             Books{
                    title: "Go 语言", author: "www.runoob.com"}
     *  访问  
        Book1.title = “Go 语言”，获取或者修改
     *  结构体指针
        
            var struct_pointer *Books
                      struct_pointer = &Book1
                      struct_pointer.title

# 切片（动态数组） #

*  定义切片
    
     *  定义·未指定长度·的数组：`var numbers []int`
     *  make函数：`slice1 := make([]type, len)`
 *  初始化：
    
     *  定义初始化：
        
         *  `s :=[] int {1,2,3 }`
         *  `s :=make([]int,len,cap)`
     *  截取初始化：
        
         *  `s1 := s[startIndex:endIndex]`
         *  截取后的长度为当前切片的长度，容量为s容量-截取的长度`？？？`
 *  函数：
    
     *  len()：当前长度
     *  cap()：最大容量
     *  append()：追加新元素：numbers = append(numbers, 1)
     *  copy()：拷贝切片：copy(numbers1,numbers)

# 接口 #

*  定义
    
        type Phone interface {
              
            call()
        }
 *  实现接口的方法就是显示了该接口(无函数名字)
    
     *  格式：`（func (sname struct) method_namen() [return_type] {...}）`
        
            func (iPhone IPhone) call() {
                    
                        fmt.Println("I am iPhone, I can call you!")
                    }
 *  使用定义的接口(new)
    
        var phone Phone //声明
        phone = new(NokiaPhone)（使用）
 *  Range遍历
    
     *  数组：
        
            for index, num := range nums {
                  ...
             }
     *  切片
        
            for _, num := range nums {
                 ...（_不使用index）
             }
     *  map
        
            kvs := map[string]string{"a": "apple", "b": "banana"}
            	   for k(, v ):= range kvs {
              }
              ```

# Map #

*  声明  
    \- var声明之后必须make，否则map为nil插入不了数据  
    `var map_variable map[string]string`  
    `map_variable = make(map[string]string)`  
    \- make声明：  
    `map_variable := make(map[string]string)`
    
     *  初始化：
        
         *  单个插入
            
            `map_variable["a"] = "b"`
         *  创建初始化
            
            `countryCapitalMap := map[string]string{"France": "Paris"}`
     *  删除元素
        
        `delete(Map, "key")`
 *  go支持强制类型转换，不支持隐式类型转换。
    
     *  float32(sum)：int的sum转float32
     *  隐式报错:
        
            var a int64 = 3
              var b int32
              b = a

# 错误处理（自带接口error中的方法Error()） #

*  使用：  
    \- stuct1作为参数实现接口中的方法。  
    `func (de *struct1) Error() string {.. }`  
    \- 调用实现的方法：stuct1name.Error()

# go并发 #

*  同一个程序中的所有 goroutine `共享同一个地址`空间
 *  开启新线程：go say(“world”)

## 通道 ##

*  操作符 `<- 用于指定通道的方向`，发送或接收。如果未指定方向，则为双向通道。
    
     *  声明通道：`c := make(chan int)`
        
            ch <- v    // 把 v 发送到通道 ch
              v := <-ch  // 从 ch 接收数据
              // 并把值赋给 v
     *  声明通道缓冲区：`ch := make(chan int, 100)`
        
         *  不声明缓冲区，发送和接收就会是阻塞关系。
     *  遍历通道和关闭通道
        
         *  range遍历：
            
                for i := range c {
                          
                    fmt.Println(i)
                  }
         *  `遍历的通道如果不关闭，遍历就会阻塞`  
            关闭通道：`close（c）`