golang學習筆記（一）：包，變量，函數

歡迎訪問個人 博客和 github!

go 語言學習筆記第一彈，來自 gotour ，之後要常寫筆記，把本身學習筆記記錄下來，就算只是筆記也要多寫。

好記性不如爛筆頭，也要多鍛鍊本身的寫做能力。

說實話，今天很累了，最近在折騰操做系統內核，由於原先寫了個bootloader，如今想要轉向 grub 來，遇到坑太多了，已經兩天了😭。

仍是接觸一點新知識簡單的東西，來緩衝一下，腦子迷迷糊糊的。

package

每一個Go程序由不少包組成。

程序都是從 main 包開始運行。

該程序正在使用導入路徑爲「 fmt」和「 math / rand」的軟件包。

按照約定，程序包名稱與導入路徑的最後一個元素相同。

例如，「 math / rand」包包括以語句包rand開頭的文件。

import

此代碼將導入分組爲帶括號的「分解的」導入語句。

您還能夠編寫多個導入語句，例如：

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(math.Pi)
}

可是使用分解式import語句是一種很好的樣式。

導出名稱

在Go中，若是名稱以大寫字母開頭，則導出該名稱。

例如，Pizza是一個導出的名稱，Pi也是，它是從math包導出的。

pizza和pi不以大寫字母開頭，因此它們不被導出。

在導入包時，您只能引用它導出的名稱。任何「未導出」的名稱都不能從包外部訪問。

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(math.Pi)
}

函數

一個函數能夠接受零個或多個參數。

在此示例中，add接受兩個類型爲int的參數。

請注意，類型位於變量名稱以後。

package main

import "fmt"

func add(x int, y int) int {
    return x + y
}

func mins(x int, y int) int {
    return x - y;
}

func main() {
    fmt.Println(add(42, 13))
    fmt.Println(mins(23, 11))
}

當兩個或多個連續的命名函數參數共享一個類型時，能夠從除最後一個以外的全部其餘參數中省略該類型。

在這個例子中，咱們縮短了

x int，y int

至

x，y int

package main

import "fmt"

func add(x, y int) int {
    return x + y
}

func main() {
    fmt.Println(add(42, 13))
}

多個返回值

一個函數能返回多個返回值。

package main

import "fmt"

func swap(a, b string) (string, string) {
    return b, a
}

func main() {
    a, b := swap("ai", "ni")
    fmt.Println(a, b)
}

Named return values

Go的返回值可能會被命名。

若是是，則將它們視爲定義在函數頂部的變量。

應該使用這些名稱來記錄返回值的含義。

沒有參數的return語句返回指定的返回值。

這就是所謂的「naked」 return。

裸返回語句應該只在短函數中使用，以下面的示例所示。

在較長的函數中，它們可能會損害可讀性。

package main

import "fmt"

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}


func main() {
    fmt.Println(split(17))
}

變量

var語句聲明瞭一個變量列表;在函數參數列表中，類型是最後一個。

var語句能夠是包級的，也能夠是函數級的。在這個例子中咱們能夠看到二者。

package main

import "fmt"

var c, python, java bool

func main() {
    var i int
    fmt.Println(i, c, python, java)
}

初始化數值

var聲明能夠包含初始化器，每一個變量一個。

若是有初始化，類型能夠省略;該變量將採用初始化器的類型。

package main

import "fmt"

var i, j int = 1, 2

func main() {
    var c, python, java = true, false, "no!"
    fmt.Println(i, j, c, python, java)
}

短變量初始化

在函數內部，可使用:= short賦值語句來代替具備隱式類型的var聲明。

在函數以外，每一個語句都以一個關鍵字(var、func等)開頭，所以:=結構不可用

package main

import "fmt"

func main() {
    var i, j int = 1, 2
    k := 3
    c, python, java := true, false, "no!"
    fmt.Println(a ,i, j, k, c, python, java)
}

基本數據類型

go 語言的基本數據類型

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128

該示例顯示了幾種類型的變量，而且與import語句同樣，變量聲明也能夠「分解」爲塊。

int，uint和uintptr類型一般在32位系統上爲32位寬，在64位系統上爲64位寬。

當您須要整數值時，應該使用int，除非有特殊緣由要使用大小或無符號整數類型。

package main

import (
    "fmt"
    "math/cmplx"
)

var (
    ToBe   bool       = false
    MaxInt uint64     = 1<<64 - 1
    z      complex128 = cmplx.Sqrt(-5 + 12i)
)



func main() {
    fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
    fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
    fmt.Printf("Type: %T Value: %v\n", z, z)
}

零值

聲明時沒有明確的初始值的變量將被賦予零值。

零值爲：

數字類型爲0，

對於布爾類型爲false

「」（空字符串）表示字符串。

package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

類型轉換

使用 T(v) 將 v 值轉換爲 T 類型

一些例子：

package main

import "fmt"

func main() {
    v := 12.2 // change me!
    fmt.Printf("v is of type %T\n", v)
}

與C語言不一樣，在Go語言中，不一樣類型的項目之間的分配須要顯式轉換。

類型推斷

在聲明變量而不指定顯式類型時（使用：=語法或var =表達式語法），將從右側的值推斷出變量的類型。

鍵入聲明的右側時，新變量具備相同的類型：

var i int j：= i // j是一個整數

可是，當右側包含無類型的數字常量時，新變量多是int，float64或complex128，具體取決於常量的精度：

i：= 42 //整數 

f：= 3.142 // 

float64 g：= 0.867 + 0.5i //complex128

package main

import "fmt"

func main() {
    v := 12.2 // change me!
    fmt.Printf("v is of type %T\n", v)
}

常量

常量像變量同樣聲明，可是使用const關鍵字。

常量能夠是字符，字符串，布爾值或數字值。

不能使用：=語法聲明常量。

package main

import "fmt"

const Pi = 3.14

func main() {
    const World = "世界"
    fmt.Println("Hello", World)
    fmt.Println("Happy", Pi, "Day")

    const Truth = true
    fmt.Println("Go rules?", Truth)
}

數字常量

數字常數是高精度值。

未說明類型的常量採用其上下文所需的類型。

（一個int最多能夠存儲一個64位整數，有時更少。）

package main

import "fmt"

const (
    // 1 左移 100 位
    Big = 1 << 100
    // 右移 99 位
    Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
    return x * 0.1
}

func main() {
    fmt.Println(needInt(Small))
    fmt.Println(needFloat(Small))
    fmt.Println(needFloat(Big))
}

歡迎訪問個人 博客和 github!