Golang 類型定義總結手冊| 面試最基礎

變量 var

• 關鍵字是 var ，定義後須被調用
• 支持多個同時定義
• 支持使用 := 缺省定義

變量定義（聲明）

//使用var 關鍵字 進行變量定義 ： var + 變量名 + 變量類型
//Var name type
var aa int = 10
//var name 省略類型
var aa = 10
// 多個進行定義,也可省略類型
var Mon, Tues, Wed, Thur, Fri, Sat, Sun int
var (
    Monday    int
    Tuesday   int
    Wednesday int
    Thursday  int
    Friday    int
    Saturday  int
    Sunday    int
)
// 使用 := 快捷定義，但":=" 結構不能在函數外使用
 var aa := 10
 //多個定義
 aa, bb ：=10, '10'
 //聲明但可不使用
 aa,_ := 10, '10'

變量調用

//變量調用分爲 局部變量 和 全局變量
package main

//import
import (
    "fmt"
)

//全局變量定義 aa ss
var (
    aa = 3
    ss = "kkk"
)

//局部變量定義
func variableZeroValue() {
    var a int
    var s string
    //fmt.Println(a, s)
    fmt.Printf("%d %q \n", a, s)
}
func main() {
    //fmt.Println("helloworld")
    variableZeroValue()
    }

常量 const

• 關鍵字爲 const， 可不被調用
• 枚舉類型 iota
• 常量不可改變

常量定義

//const name type
//const name
//:=
//多常量
const（
aa = 1
bb =2
）
//使用iota， 從0開始，iota 自增被打斷，須顯式恢復
const (
        b = 1 << (10 * iota)
        kb
        mb
        gb
    )

常量調用

• 常量使用與變量類似 ，故不贅述
• 與c語言不一樣，常量不能經過指針進行強制更改

數組 arr

• 在Go語言中數組是固定長度的數據類型，它包含相同類型的連續的元素，這些元素能夠是內建類型，像數字和字符串，也能夠是結構類型，元素能夠經過惟一的索引值訪問，從0開始。
• 使用 var 關鍵字

數組定義

//定義 長度是5的arr
var arr [5]int
//定義並初始化
var arr [5]int = [5]int{1,2,3,4,5}
//快速定義
arr ：= [5]int{1,2,3,4,5}
//不知長度
arr := [...]int{1,2,3,4}
//部分初始化, 其餘位置初始化爲0
arr := [5]int{1:1,3:4}

調用

package main
import "fmt"

func main() {
    array := [2]int{}
    fmt.Printf("數組長度：%d，數組容量：%d\n", len(array), cap(array))
}
//數組長度：2，數組容量：2

切片 Slice

• "動態數組" ，長度不固定，能夠追加 append （name, 5）
• 經過內部指針和相關屬性應用數組片斷
• type, len, cap 爲Slice三個屬性, 若是slice == nil 則len，cap均爲零

定義

//定義一個切片，不用大小
var name []int
//定義並初始化
var aa []int = []int{1,2,3}
var bb = []int{1,2,3}
//經過內置函數make 進行定義 make (type, len, cap)
var aa []int = make([]int, 3)
var aa = make([]int, 3)
var aa = make([]int, 3, 3)
aa := make([]int, 3)
//經過切數組獲得 arr ：= [5]int{1,2,3,4,5}
aa := arr[:len(arr)-1]

調用

切片拷貝，使用copy() 函數 copy 在兩個 slice 間複製數據，複製長度以 len 小的爲準。兩個 slice 可指向同一底層數組，容許元素區間重疊。

package main
import "fmt"
func main() {    
    var a = []int{1, 2, 3, 4, 5}
    b := []int{100, 200}
    copy(a, b)
    fmt.Println(a, b)
    }

運行結果：

[100 200 3 4 5]  [100 200]

容器 Map

• key- value 表
• 無序，散列表hash完成
• 可以使用內置函數delete(m, "key"), 不能夠在map上使用cap()方法。

定義

//聲明
var m map[int]string
//聲明並初始化
var m map[int]string {1;"1",2;'2'}
//經過make 建立
var m1 = make(map[int]string, 10)
m2 = make(map[int]string, 10)

調用

//增
m[3] = "3"
//刪，刪除操做，若是 key 不存在，不會出錯
delete(m, "3")
//改
m[1] ='2'
//查
if _, ok = m[3]; ok{
 fmt.Println("find it")
}
//長
len := len(m)

管道 Channel

• 當作管道， 可單雙向使用， chan 定義

• 無緩衝的與有緩衝channel有着重大差異，那就是一個是同步的 一個是非同步的。 好比

  無緩衝chan：ch1:=make(chan int)

  有緩衝chan：ch2:=make(chan int,1)

  無緩衝： ch1<-1 不只僅是向 c1 通道放 1，而是一直要等有別的攜程 <-ch1 接手了這個參數，那麼ch1<-1纔會繼續下去，要否則就一直阻塞着。

  有緩衝： ch2<-1 則不會阻塞，由於緩衝區大小是1(實際上是緩衝大小爲0)，只有當放第二個值的時候，第一個還沒被人拿走，這時候纔會阻塞。

  緩衝區是內部屬性，並不是類型構成要素。

• 普通 channel 能夠隱式轉爲只讀channel或只寫channel，反過來則不行

• 內置函數 len() 返回未被讀取的緩衝元素數量，使用內置函數 cap() 返回緩衝區大小

• 使用內置函數 close() 進行關閉 chan，向已經關閉的 channel 發送數據會引起 panic 錯誤。

定義

//使用chan 定義
var aa chan int
var aa chan string
var aa chan map[int]string
//make 定義 
var aa = make(chan int) //無緩衝
var aa = make(chan int, 10) //有緩衝
//只讀 
var aa <-chan int
var aa = make(<-chan int, 10)
//只寫
var aa chan<- int
var aa = make(chan<-int, 10)

調用

//開
var aa = make(chan int, 3)
//放
aa <- 1
//關
close(aa)

指針

• *（取值符） 來獲取指針所指向的內容 ， &（取地址符）來獲取該變量的指針。
• 不可加減乘除，Go語言是不容許兩個指針類型進行轉換的
• 空指針 nil
• unsafe.Pointer 類型用於表示任意類型的指針

定義

//使用var 進行
var p *int
//使用：= 定義
var str string
p := &str
//指針變量的指針
var **p  int
//time.Time （一個結構體）值的指針 
var t *time.Time

結構體

• 結構體是由一系列具備相同類型或不一樣類型的數據構成的數據集合。

• struct 特色
  一、用來自定義複雜數據結構
  二、struct裏面能夠包含一個或多個字段（屬性）
  三、struct類型能夠定義方法，注意和函數的區分
  四、struct類型是值類型
  五、struct類型能夠嵌套
  六、結構體是用戶單獨定義的類型，不能和其餘類型進行強制轉換
  七、Go中的struct沒有構造函數，通常可使用工廠模式來解決這個問題
  八、咱們能夠爲struct中的每一個字段，寫上一個tag。這個tag能夠經過反射的機制獲取到，最經常使用的場景就是json序列化和反序列化
  九、訪問結構體成員, 用 "." 來鏈接，格式爲："結構體.成員名"

定義

//全局或函數內定義類型
type bight int64
//定義新類型,不能同時嵌入某一類型和其指針類型(名字相同)
type moreType struct{
    linux string
    win string
    debin string
}
type lin stuct{
    *linux
}

//聲明struct結構的時候，在屬性的右側用小米點括起來的內容叫標籤（Tag），在轉換成其它數據格式的時候，會使用其中特定的字段做爲鍵值。例如轉成json格式
    user := &User{UserId: 1, UserName: "helloworld"}
    json_user, _ := json.Marshal(user)
    fmt.Printf("struct User echo : %v\n", string(json_user))

    user_tag := &UserTag{UserId: 1, UserName: "helloworld"}
    json_user_tag, _ := json.Marshal(user_tag)
    fmt.Printf("struct UserTag echo : %v\n", string(json_user_tag))

函數

定義

//無參數
func funName(){
}
//有參數
func funName(x, y int){
}
//一返回值
func funName(x, y int) int{
}
//多返回
fun funNmame(x,y int)(ret int, err error){
}
//只有類型
fun funNmame(int， int)(int, error){
}

一、Go語言函數中的參數不支持默認值。

二、不管是值傳遞，仍是引用傳遞，傳遞給函數的都是變量的副本，不過，值傳遞是值的拷貝。引用傳遞是地址的拷貝，通常來講，地址拷貝更爲高效。而值拷貝取決於拷貝的對象大小，對象越大，則性能越低。

三、map、slice、chan、指針、interface默認以引用的方式傳遞。

四、函數的可變參數只能有一個，且必須是最後一個。

五、在參數賦值時能夠不用用一個一個的賦值，能夠直接傳遞一個數組或者切片，特別注意的是在參數後加上「…」便可。

特殊函數

//匿名函數
var sum func(int, int) int = func(x, y int)int{return x+y}
sum := func(x, y int)int{return x+y}

//遞歸函數
func factorial(i int) int {
    if i <= 1 {
        return 1
    }
    return i * factorial(i-1)
}

延時調用 defer 注意

• 當defer被聲明時，參數被實時解析
• defer執行順序爲先進後出。
• defer 能夠讀取有名返回值