Golang中的基礎(chǔ)語法有哪些

這篇“Golang中的基礎(chǔ)語法有哪些”文章的知識(shí)點(diǎn)大部分人都不太理解，所以小編給大家總結(jié)了以下內(nèi)容，內(nèi)容詳細(xì)，步驟清晰，具有一定的借鑒價(jià)值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“Golang中的基礎(chǔ)語法有哪些”文章吧。

導(dǎo)包

示例：工程結(jié)構(gòu)如下

GOPATH 設(shè)置為工程根目錄（E:\GO_PROJECT）

test1.go：

package package_test

import "fmt"

/*
定義函數(shù)
*/
func Func1（） {
    fmt.Println（"test1 func1"）
}

test2.go：

package package_test

import "fmt"

func Func2（） {
    fmt.Println（"test2 func2"）
}

testmain.go：

package main

import "dir1/dir2"  // 導(dǎo)入的是【目錄名】

func main（） {
    package_test.Func1（）  // 調(diào)用的是【包名】
}

運(yùn)行：

// 方式一
go bulid testmain.go  // 編譯（生成可執(zhí)行文件）
./ testmain  // 運(yùn)行（可執(zhí)行文件）

//方式二
go run testmain.go  // 編譯+運(yùn)行

導(dǎo)包結(jié)論：

一個(gè) GO 程序中一定要有 main 包和 main 函數(shù)，這是 GO 程序執(zhí)行的入口。

編譯器會(huì)根據(jù)指定的相對(duì)路徑去搜索包然后導(dǎo)入，這個(gè)相對(duì)路徑是從 GOROOT 或 GOPATH（workspace）下的 src 下開始搜索：

• GOROOT

• 項(xiàng)目 GOPATH

• 全局 GOPATH

GOlang 和 Java 的區(qū)別是，在 GO 中 import 的是目錄，而不是包名；并且 GO 沒有強(qiáng)制要求包名和目錄名需要一致，即包和目錄是兩個(gè)不同的概念。

import 導(dǎo)入的是源文件所在的目錄名，而不是定義的包名。

在代碼中引用包內(nèi)的成員時(shí)，使用定義的包名而不是目錄名。

在習(xí)慣上將包名和目錄名保證一致，但這并不是強(qiáng)制規(guī)定。

在同一級(jí)目錄中，所有源文件只能使用相同的包名。

同一包名下的變量名、函數(shù)名等不能重復(fù)。

多個(gè)目錄下的相同包名，彼此無關(guān)。

包中的成員（如函數(shù)）以名稱?字母??寫，決定其訪問權(quán)限：

• ?字母?寫，可被包外訪問（即public）

• ?字母?寫，僅包內(nèi)成員可以訪問（即private）

工程管理

為了更好的管理項(xiàng)目中的文件，GO 要求將文件都要放在相應(yīng)的目錄中，具體規(guī)定了以下目錄：

• src 目錄：以代碼包的形式組織并保存 GO 源碼文件（比如 .go 文件、.c 文件、.h 文件、.s 文件等）

• pkg 目錄：用于存放經(jīng)由 go install 命令構(gòu)建安裝后的代碼包（包含 GO 庫源碼文件）的 ".a" 歸檔文件。

• bin 目錄：與 pkg 目錄類似，在通過 go install 命令完成安裝后，保存由 GO 命令源碼文件生成的可執(zhí)行文件。

以上目錄稱為工作區(qū)（Workspace），工作區(qū)其實(shí)就是一個(gè)對(duì)應(yīng)于特定工程的目錄。

src 目錄用于包含所有的源代碼，是 GO 命令行工具一個(gè)強(qiáng)制的規(guī)則；而 pkg 和 bin 則無需手動(dòng)創(chuàng)建，GO 命令行工具在構(gòu)建過程中會(huì)自動(dòng)創(chuàng)建這些目錄。

變量

變量聲明

• 變量名必須以字母或下劃線開頭，后面可以跟任意數(shù)量的字母、數(shù)字或下劃線。

• 變量的三種聲明&初始化方式如下：

// 方式一：先聲明（有默認(rèn)值），后賦值
var a int
a = 10
var b, c string
b = "b"
c = "c"

// 方式二：聲明+賦值
var a int = 10

// 方式三：自動(dòng)推導(dǎo)類型（注意：這種方式只能在函數(shù)內(nèi)使用）
a := 10
b, c := 11, 12
b, c = c, b  // 值交換

// 匿名變量
_, i, _, j = 1, 2, 3, 4

格式化輸出

基本數(shù)據(jù)類型

值的字面量（literal）是指代碼中值的文字表示。一個(gè)值可能存在多種字面量表示。

表示基本類型值的文本稱為基本字面量?；咀置媪恳脖环Q為字面量常量或未命名常量。

示例：

func main() {
    var ch byte = 97  // 聲明字符類型
    fmt.Printf("ch=%c", ch)  //  輸出 a
}

這里定義了 ch 是一個(gè)字符類型，賦值卻是一個(gè)整數(shù) 97，打印的結(jié)果是小寫字符 'a'。

原因是：計(jì)算機(jī)不能直接存儲(chǔ)字符類型，只能轉(zhuǎn)成數(shù)字存儲(chǔ)，那為什么小寫字符 'a' 對(duì)應(yīng)的整數(shù)是 97 呢？因?yàn)橛?jì)算機(jī)是根據(jù) ASCII 碼來存儲(chǔ)的。

強(qiáng)制類型轉(zhuǎn)換

package main

import "fmt"

func main() {

    chinese := 97
    math := 99
    english := 96

    fmt.Printf("總分是 %d，平均分(整數(shù))是 %d, 平均分(浮點(diǎn)數(shù))是 %f", chinese+math+english, (chinese+math+english)/3, float32(chinese+math+english)/3)
    // 總分是 292，平均分(整數(shù))是 97, 平均分(浮點(diǎn)數(shù))是 97.333336
}

注意：

GO 語言中不允許隱式轉(zhuǎn)換，所有類型轉(zhuǎn)換必須顯式聲明（強(qiáng)制轉(zhuǎn)換），而且轉(zhuǎn)換只能發(fā)生在兩種相互兼容的類型之間

    var ch byte = 'c'
    // var a int = ch  // cannot use ch (type byte) as type int in assignment
    var b int = int(ch)  // 數(shù)據(jù)類型名(待轉(zhuǎn)換的值)

• int 轉(zhuǎn) float 強(qiáng)制轉(zhuǎn)換：多小數(shù)

• float 轉(zhuǎn) int 強(qiáng)制轉(zhuǎn)換：丟精度

接收鍵盤輸入

package main

import fmt

func main（） {
    var age int
    fmt.Println（"請(qǐng)輸入年齡："）
    fmt.Scanf（"%d", &age）  // 將接收的值賦給age變量
    fmt.Printf（"age=%d", age）
}

常量

常量聲明

func main() {
    // 變量：程序運(yùn)行期間，值可以改變，聲明使用var
    // 常量：程序運(yùn)行期間，值不可以改變，聲明使用const
    const a int = 11
    // a = 12  // error：常量不可以修改
    
    const b = 12 // 自動(dòng)推導(dǎo)類型（常量不可以使用:=）
}

iota 枚舉

iota 常量生成器：用于生成一組遞增的整型常量，減去了每行都要寫一遍初始化表達(dá)式的繁瑣。

func main() {

    // 在一個(gè) const 聲明語句中，在第一個(gè)聲明的常量所在的行，iota 將會(huì)被置為 0，然后在每一個(gè)有常量聲明的行遞增 1
    const (
        a = iota  // 0
        b = iota  // 1
        c = iota  // 2
    )

    const d = iota // iota 遇到const，會(huì)被置為 0

    // 可以只寫一個(gè)iota
    const (
        e = iota  // 0
        f // 1
        g
    )

    // 同一行值一樣
    const (
        h = iota  // 0
        i, j, k = iota, iota, iota  // 1
        l = iota  // 2
    )

}

運(yùn)算符

算術(shù)運(yùn)算符

賦值運(yùn)算符

關(guān)系運(yùn)算符

邏輯運(yùn)算符

條件語句

if 語句

package main

import "fmt"

func main() {

    var score int
    fmt.Println("請(qǐng)輸入成績(jī)：")
    fmt.Scanf("%d", &score)

    // if 語句支持一個(gè)初始化語句+判斷條件
    if good_score := 90; score >= good_score {
        fmt.Println("優(yōu)秀")
    } else if soso_score := 60; score >= soso_score {
        fmt.Println("及格")
    } else {
        fmt.Println("需要努力")
    }
}

switch 語句

注意：case 后面默認(rèn)自帶 break，如果想執(zhí)行完成某個(gè) case 后繼續(xù)執(zhí)行后面的 case，可以使用 fallthrough 關(guān)鍵字。

func main() {

    bonus := 5000
    var score string
    finish := true
    fmt.Println("請(qǐng)輸入年終評(píng)級(jí)：")
    switch fmt.Scanf("%s", &score); score {
    case "A":
        bonus += 1000
    case "B":
        bonus += 5000
    case "C":
    case "D":
        bonus -= 1000
    default:
        finish = false
        fmt.Println("輸入有誤，請(qǐng)輸入正確的評(píng)級(jí)")
    }
    if finish {
        fmt.Printf("您的年終獎(jiǎng)為：%d", bonus)
    }

}

循環(huán)語句

GO 中的 3 種循環(huán)方式：

package main

import "fmt"

func main() {

    // 第1種方式
    for i := 0; i < 5; i++ {
        fmt.Printf("i=%d\n", i)
    }

    // 第2種方式：類似while循環(huán)
    num := 1
    for num < 5 {
        fmt.Printf("num=%d\n", num)
        num++
    }

    // 第3種方式
    for {
        fmt.Println("死循環(huán)")
    }
}

函數(shù)

函數(shù)定義

函數(shù)就是將一堆代碼進(jìn)行封裝，以便重用的一種機(jī)制。

func 函數(shù)名(){
    函數(shù)體
}

參數(shù)列表

import "fmt"

func MyFunc(a int, b int, args ...int) {  // 注意：不定長(zhǎng)參數(shù)必須放在參數(shù)列表最后
    fmt.Println("定長(zhǎng)參數(shù)為：", a, b)
    for i, data := range args {  // 若不需要編號(hào)，則可使用 for _, data := range args
        fmt.Println("編號(hào)為：", i)
        fmt.Println("數(shù)據(jù)為：", data)
    }
}

func main() {
    MyFunc(1, 2, 3, 4, 5)
}

打印結(jié)果：

定長(zhǎng)參數(shù)為： 1 2
編號(hào)為： 0
數(shù)據(jù)為： 3
編號(hào)為： 1
數(shù)據(jù)為： 4
編號(hào)為： 2
數(shù)據(jù)為： 5

函數(shù)返回值

// 定義返回值類型
func Add(a int, b int) int {
    return a + b
}

// 給返回值命名
func Sub(a int, b int) (sub int) {
    sub = a - b
    return sub  // 也可以只寫 return
}

// 返回多個(gè)值
func Sub(a, b, c int) {
    a, b, c = 1, 2, 3
    return a, b, c  // 也可以只寫 return
}

函數(shù)類型

在 GO 語言中還有另外一種定義使用函數(shù)的方式，就是函數(shù)類型。

所謂的函數(shù)類型，就是將函數(shù)作為一種類型可以用來定義變量，基本使用如下：

func Test(a, b int) int {
    return a + b
}

// 定義函數(shù)類型：即需要傳遞兩個(gè)整型參數(shù)，有一個(gè)整型返回值的函數(shù)類型
type FuncType func(a int, b int) int  // type關(guān)鍵字后面跟著類型的名字（FunType）

func main() {
    var result FuncType  // 類型是FuncType類型，即函數(shù)類型
    result = Test
    s := result(1, 2)
    fmt.Printf("s=%d", s)
}

匿名函數(shù)

所謂匿名函數(shù)就是沒有名字的函數(shù)。匿名函數(shù)最主要的功能就是實(shí)現(xiàn)了閉包。

package main

import "fmt"

func main() {
    num := 9

    // 使用方式一：定義匿名函數(shù)并賦值給變量
    f1 := func() {
        // 在匿名函數(shù)中可以直接訪問main()中定義的局部變量
        // 并且在匿名函數(shù)中對(duì)變量的值進(jìn)行了修改，最終會(huì)影響到整個(gè)main()函數(shù)中定義的變量值
        num++
        fmt.Println("匿名函數(shù)：", num)
    }
    f1()                        // 10
    fmt.Println("main函數(shù)：", num) // 10

    // 使用方式二：通過函數(shù)類型
    type FuncType func() // 沒有參數(shù)，沒有返回值
    var f2 FuncType = f1
    f2()

    // 使用方式三：直接調(diào)用
    func(a, b int) {
        fmt.Println("a + b =", a+b)
    }(3, 6)

    // 有參有返回值的匿名函數(shù)
    min, max := func(a, b int) (min, max int) {
        if a > b {
            return b, a
        } else {
            return a, b
        }
    }(12, 13)
    fmt.Printf("min=%d, max=%d\n", min, max)
}

遞歸函數(shù)

示例：階乘

func Test(num int) int {
    if num == 1 {
        return 1
    }
    return num * Test(num-1)
}

func main() {
    var num int
    fmt.Println("請(qǐng)輸入需要階乘的數(shù)：")
    fmt.Scanf("%d", &num)
    fmt.Printf("%d的階乘結(jié)果為：%d", num, Test(num))
}

以上就是關(guān)于“Golang中的基礎(chǔ)語法有哪些”這篇文章的內(nèi)容，相信大家都有了一定的了解，希望小編分享的內(nèi)容對(duì)大家有幫助，若想了解更多相關(guān)的知識(shí)內(nèi)容，請(qǐng)關(guān)注億速云行業(yè)資訊頻道。