Go-數據類型以及變量,常量,函數,包的使用

Go-數據類型以及變量,常量,函數,包的使用

一.數據類型

1.字符串類型

string
-雙引號包裹的："xxx"
-反引號包裹，能夠換行，   
注意：
區別於python，是沒有單引號，三引號的
用法：
var s string=`
你好
我好
你們好
`
var b string="你好\n" +
        "我好" +
        "你們好"

2.數字類型

有符號整型（整數 含正負）:

• int: int 在32位機器上是int32 在64位機器是int64
• int8: 表示佔一個字節（8個比特位）表示的範圍是：正負2的7次方-1
• int16: 表示佔兩個字節（16個比特位）表示的範圍是：正負2的15次方-1
• int32: 相似int8
• int64: 相似int8

無符號整型（正整數 ）:

• uint :uint 在32位機器上是uint32 在64位機器是uint64
• uint8 : int8 表示數字範圍是 正2的8次方-1
• uint16
• uint32
• uint64

浮點型

float32 : 有符號小數,32後7位

float64: 64 有符號小數,32後7位

都是表示小數點後範圍不同（代碼裏面沒有float，只有float64和float32）

complex64: 32 位實數和虛數

complex128: 64 位實數和虛數

別名

• rune:rune是int32的別名
• byte:byte 是uint8的別名

3.布爾類型(首字母小寫)

false 和 true

4.派生類型(簡單介紹)

指針類型（Pointer）
數組類型
結構化類型(struct)
Channel 類型
函數類型
切片類型
接口類型（interface）
Map 類型

二.變量的聲明

方式一（全定義）

單個變量

var 變量名 變量數據類型=變量值

多個變量

a,b,c都爲string必須3個變量類型相同

var a,b,c string="1","2","3"   //注意string必須是雙引號

方式二（類型推導） 類型能夠省略

單個變量

var 變量名 =變量值

多個變量

a,c爲string，b爲int

a,b,c三個變量類型不一樣也能夠聲明
var a,b,c="1",2,"3"

方式三（簡略聲明）

單個變量

變量名 := 變量值  //注意點:= 必須連着不能有空格

多個變量

a,b,c都爲string

a,b,c三個變量類型不一樣也能夠聲明
a,b,c :="1",2,"3"

注意點

• 同一變量名不能重複聲明
• 變量定義和賦初值(int 空值是 0 string空值是 "")
• 變量要先定義後才能夠賦值再使用
• 變量名定義後必須使用，不然報錯
• 能夠聲明多個變量(三種方式均可以用)
• 若是聲明後的變量須要修改值用=

var a int
a=100

三.常量的聲明

方式一

const 變量名 變量類型 =值

方式二

const 變量名 =值

package main

import "fmt"

//程序運行期間不容許修改
//數據庫，redis鏈接
//const關鍵字 常量名 =常量值   賦值一次，不容許修改
//const NAME  = "cxk"
//const NAME  string = "cxk"
const sex  = true 
func main() {
    //fmt.Println(NAME)
    //fmt.Println(sex)
    //sex=false
    
    fmt.Println(sex)
}

注意點

常量一旦被定義賦值後將沒法第二次修改

4、函數的使用

無參數無返回值

方式一
func 函數名()(){}

方式二
func 函數名(){}

無參數有返回值

方式一
func 函數名()(返回參數1的數據類型1){}

定長參數,有返回值

func 函數名(參數1 類型，參數2 類型)(返回參數1的數據類型1,返回參數2的數據類型){}
//若是參數1與參數2的數據類型相同
func 函數名(參數1，參數2 類型)(返回參數1的數據類型1,返回參數2的數據類型){}
//若是參數1與參數2的數據類型爲int,參數3數據類型爲uint
func 函數名(參數1，參數2 int,參數3 uint)(返回參數1的數據類型1,返回參數2的數據類型){}

定長參數,無回值

//方式一
func 函數名(參數1 類型，參數2 類型){}

//方式二
func 函數名(參數1 類型，參數2 類型)(){}

不定長參數

//方式一
func 函數名(不定長參數1 ...類型){}

//有定長參數和不定長參數
func 函數名(定長參數 類型,不定長參數1 ... 類型){}
//不定長的參數必須寫在定長的參數後面

//不定長參數全部數據類型
func 函數名(不定長參數1... interface{}){}

匿名函數

//定義
func (參數一,參數二)(返回參數1的數據類型1){return 1 }
//定義+調用
func (參數一,參數二)(返回參數1的數據類型1){return 1 }()

命名返回值

package main

import "fmt"

func abc()(a int,b int){
    //var a,b int  至關於默認執行這條
    //可是ab只在函數內生效函數外部生效
    return    
    //return 與return a,b是同樣的
}
func main() {
    fmt.Println(abc())
}

注意點

• 因爲是編譯型語言main 與main裏面使用的函數不須要注意前後關係
• 沒有關鍵字傳參
• 沒有默認參數
• 函數沒有縮進的約數,可是爲了排版仍是要注意縮進否則會看上去很是很是醜

函數使用實例：

//函數
package main

func main() {

    //test()
    //test(3,4,"xxx") //沒有關鍵字參數一說,都按位置傳，也沒有默認參數
    //test(3,4,"xxx")

    //三種方法調用
    //var a int =test(3,4)   //定義變量a接收返回值
    //var a  =test(3,4)
    //a  :=test(3,4)
    //fmt.Println(a)
    //返回兩個值，就要用兩個值來接受
    //a,b:=test(3,4)  //這種用的多
    //var a,b int=test(3,4)
    //var a,b =test(3,4)
    //fmt.Println(a,b)
    //若是有個值不想接收
    // _,a,_:=test(3,4)
    //fmt.Println(a)
    // py中 _ 是一個真正的變量，go中，就是沒有
    //fmt.Println(_)

    test(1,2,3,4,5,5,6,7)
}
//func關鍵字  函數名(參數1 參數類型，參數2 參數類型)(){
//函數體的內容
//}
//函數使用1(沒有先定義再使用這一說)
//func test()  {
//  fmt.Println("我是test")
//}
//函數使用2 帶參數
//func test(a int,b int,c string) {
//  fmt.Println(a+b)
//  fmt.Println(c)
//}

//函數使用3
//func test(a ,b int,c string) {
//  fmt.Println(a+b)
//  fmt.Println(c)
//}

////函數使用 4 規定返回值類型
//func test(a,b int) int {
//  //返回a+b的結果
//  return a+b
//}

//函數使用 5 規定返回值類型,返回多個值
//func test(a,b int) (int,int,string) {
//  //返回a+b的結果
//  return a+b,a*b,"ok"
//}

//函數使用6 不定長參數
//func test(z ...int)  {
//  fmt.Println(z)
//
//}

5、包的使用

包的介紹以及使用

爲何使用包？

爲了更加好的維護代碼

包的位置？

必須在GOPATH路徑的src中

能導入的內容？

導入的內容名稱必須是大寫字母開頭否則沒法導入包

src中的一個文件夾爲一個包

包內的變量以及函數名

在同一文件夾下,就至關於同一包中,任何變量名不能進行二次定義

在同一包中,能夠互相使用其餘GO文件下的函數且不須要導入

go 程序中必須有一個main和一個main入口

若是不是package main他就是一個包,他會把裏面的函數都進行保存,不能有main函數

main`也是一個特殊的包,其中必需要有main函數,做爲程序的入口,也就是執行這個文件的時候其中就是運行`main函數

導入第三方模塊

語法:go get 第三方模塊路徑

文件會被安裝在GOPATH路徑的src文件夾下