GO語言——入門（1）

一、初識(shí)GO語言

1.GO語言介紹

1.1 GO語言是什么

2009年11月10日，GO語言正式成為開源編程語言家庭一員。GO語言是云計(jì)算時(shí)代的c語言。GO語言專門針對(duì)多處理器系統(tǒng)應(yīng)用程序的編程進(jìn)行優(yōu)化，使用go編譯的程序可以媲美C或者C++代碼的速度，而且更加安全、支持并行進(jìn)程。

1.2 GO語言優(yōu)勢(shì)

  • 可以直接編譯成機(jī)器碼，不需要依賴其他庫。部署就是扔一個(gè)文件上去就完成了
  • 靜態(tài)類型語言，但是有動(dòng)態(tài)語言的感覺，開發(fā)效率高
  • 語言層面支持并發(fā)，可以充分利用多核，很容易使用的并發(fā)
  • 內(nèi)置runtime，支持垃圾回收，特別是GO 1.1之后的GC功能很強(qiáng)大
  • 跨平臺(tái)編譯，如果你寫的GO代碼不包括CGO，那么就可以做到Windows系統(tǒng)編譯Linux的應(yīng)用。
  • 內(nèi)嵌C支持，GO里面也可以直接包含C代碼，利用現(xiàn)有豐富的C庫

1.3 GO 適合來做什么

  • 服務(wù)器編程，例如處理日志、數(shù)據(jù)打包、虛擬機(jī)處理、文件系統(tǒng)等
  • 分布式系統(tǒng)，數(shù)據(jù)庫代理器等
  • 網(wǎng)絡(luò)編程，這一方面目前應(yīng)用最廣，包括web應(yīng)用、API應(yīng)用、下載應(yīng)用
  • 云平臺(tái)

學(xué)習(xí)資料
首頁 - Go語言中文網(wǎng) - Golang中文社區(qū)
Go語言標(biāo)準(zhǔn)庫文檔中文版 | Go語言中文網(wǎng) | Golang中文社區(qū) | Golang中國(guó)

2.GO語言環(huán)境搭建

2.1 window版本GO語言環(huán)境搭建

安裝后我們可以再cmd中查詢GO環(huán)境是否搭建成功


  • 部署LiteIDE

  • 文件解壓縮后就可以直接使用了

  • 設(shè)置文件存儲(chǔ)目錄以及測(cè)試go語言運(yùn)行情況


書寫GO語言時(shí)，請(qǐng)牢記把程序類比成商場(chǎng)。
在GO語言中有且只有一個(gè)入口就是 main
實(shí)現(xiàn)目的就是調(diào)用函數(shù)

package main    
//GO語言是以包作為管理單位
//每個(gè)文件必須先聲明包
//程序必須有一個(gè)main包（極度重要）

import "fmt"   //導(dǎo)入函數(shù)包
//入口函數(shù)
func main() {   //左函數(shù)必須與main函數(shù)同行
//打印
//“hello go”打印到屏幕上，println（）會(huì)自動(dòng)換行
//調(diào)用函數(shù)，大部分都需要導(dǎo)入包
    fmt.Println("hello go")  //go語言結(jié)尾是沒有分號(hào)的
}

Ctrl +R 執(zhí)行文件


使用LiteIDE也存在一定的缺點(diǎn)，例如main的唯一性
image.png

方法一：每個(gè)目錄下只生成一個(gè)go文件。以保證main函數(shù)的唯一性
方法二：在同樣目錄下建立go文件，使用cmd終端進(jìn)行驗(yàn)證操作

go build ***.go   
執(zhí)行   ***.go

go run ***。go

二 、GO基礎(chǔ)類型

1.變量

變量是幾乎所有編程語言中基本的組成元素。從根本上說，變量相當(dāng)于是對(duì)一塊數(shù)據(jù)存儲(chǔ) 空間的命名，程序可以通過定義一個(gè)變量來申請(qǐng)一塊數(shù)據(jù)存儲(chǔ)空間，之后可以通過引用變量名來 使用這塊存儲(chǔ)空間。Go語言中的變量使用方式與C語言接近，但具備更大的靈活性。
數(shù)據(jù)類型的作用：告訴編譯器我們?cè)O(shè)定變量應(yīng)該以多大的內(nèi)存存儲(chǔ)

1.1變量聲明

Go語言的變量明方式與C和C++語言有明顯的不同。對(duì)于純的變量明，Go語言引入了 關(guān)鍵字var，而類型信息放在變量名之后，示例如下：
var v1 int
var v2 string

package main //必須有一個(gè)main包

import "fmt" //導(dǎo)入包，必須要使用

func main() {
    //變量的本質(zhì):程序運(yùn)行期間，可以改變的量
    //1.聲明格式：var 變量名 類型 （聲明變量名后必須要使用）
    //2.只有聲明沒有初始化的變量默認(rèn)值為0
    //3.同一個(gè){ }中，聲明的變量是唯一的
    var a int
    fmt.Println("a=", a)
    //4.可以同時(shí)聲明多個(gè)變量  var b,c int
    a = 10  //變量賦值
    fmt.Println("a=", a)
}

---------------結(jié)果------------------
go run 03_text.go
a=0
a=10

1.2變量初始化

對(duì)于聲明變量時(shí)需要進(jìn)行始化的場(chǎng)景，var關(guān)鍵字可以保留，但不再是必要的元素，如下所示：

var v1 int = 10  // 正確使用方法1  
var v2 = 10      // 正確使用方法2
v3 := 10        // 正確使用方法3

以上三種用法的效果是完全一樣的。與第一種用法相比，第三種用法需要輸入的字符數(shù)大大減少，是程序員和明程序員的最佳選擇。這里Go語言也引入了另一個(gè)C和C++中沒有的符號(hào) （號(hào)和等號(hào)的組合:=），用于明確表達(dá)同時(shí)進(jìn)行變量聲明和初始化的工作。
指定類型已不再是必需的，Go編譯器可以從初始化表達(dá)式的右值推導(dǎo)出該變量應(yīng)該聲明為哪種類型，這讓Go語言看起來有點(diǎn)動(dòng)態(tài)類型語言，盡管Go語言實(shí)際上是不折不扣的強(qiáng)類型語言（靜態(tài)類型語言）。
當(dāng)然，出現(xiàn)在:=的變量不應(yīng)該是已經(jīng)被明過的，否則會(huì)導(dǎo)編譯錯(cuò)誤，比如下面這個(gè)寫法：

會(huì)導(dǎo)類似如下的編譯錯(cuò)誤： 
no new variables on left side of :

1.3變量賦值

在GO語言中，變量初始化和變量賦值是兩個(gè)不同的概念。下面為聲明一個(gè)變量之后的賦值過程

var v10 int 
v10 = 123

案例展示

//存在著兩種方式【func main()內(nèi)的代碼段】
    var b int = 10 //初始化  聲明變量時(shí)，同時(shí)賦值（一步到位）
    b = 20         //復(fù)制    先聲明后付制
    fmt.Println("b=", b)
    //自動(dòng)推到類型，必須初始化，通過初始化的值確定類型
    c := 30
    //%T打印變量所屬類型
    fmt.Printf("c type is %T\n", c)
  • printf和printlin的區(qū)別

Println 與Printf 都是fmt 包中的公共方法
Println :可以打印出字符串，和變量。
Printf : 只可以打印出格式化的字符串,可以輸出字符串類型的變量，不可以輸出整形變量和整形。

package main

import "fmt"

func main() {
    a := 10
    fmt.Printf("a type is %T\n", a)
    fmt.Println(a)
    fmt.Println("abc")
    fmt.Printf("%d", a)
}

-----------結(jié)果-----------
a type  is  int
10
abc
10

除了以上區(qū)別，在對(duì)變量賦值時(shí)，也存在不小的差異。同時(shí)對(duì)多變量賦值時(shí)，推薦使用printf

package main

import "fmt"

func main() {
    a := 10
    fmt.Println("a = ", a)
    fmt.Printf("a = %d\n", a)
    b := 120
    c := 340
    fmt.Println("a =", a, ", b = ", b, ",c = ", c)
    //同時(shí)對(duì)多個(gè)變量進(jìn)行賦值時(shí)使用printf效果更好
    fmt.Printf("a = %d, b = %d , c =%d\n", a, b, c)

}

Go語言的變量賦值與多數(shù)語言一致，但Go語言中提供了C/C++程序員期多年的多重賦值功能，比如下面這個(gè)交換i和j變量的語句：
i , j = j , i


image.png
  • 將j賦值給i,然后再將i賦值給j

多重賦值的特性在Go語言庫的實(shí)現(xiàn)中也被使用得相當(dāng)分，在函數(shù)的多重返回值時(shí)，將對(duì)其進(jìn)行更加深入的?？偠灾?，多重賦值功能讓Go語言與C/C++語言相比可以非常明顯地少代碼行數(shù)。

案例展示

package main

import "fmt"

func main() {
    //a :=10
    //b :=20
    //c :=30
    //多重初始化
    a, b := 10, 20
    fmt.Printf("a = %d, b = %d\n", a, b)
    //傳統(tǒng)方法交換兩個(gè)變量的值
    var tmp int
    tmp = a
    a = b
    b = tmp
    fmt.Printf("a = %d , b = %d\n", a, b)
    //GO語言的多重賦值
    i, j := 10, 20
    i, j = j, i
    fmt.Printf("i = %d , j = %d\n", i, j)
}

1.4匿名變量

我們?cè)谑褂脗鹘y(tǒng)的強(qiáng)類型語言編程時(shí)，經(jīng)常會(huì)出現(xiàn)這種情況，即在調(diào)用函數(shù)時(shí)為了獲取一個(gè)值，卻因?yàn)樵摵瘮?shù)返回多個(gè)值而不得不定義一堆沒用的變量。在Go中這種情況可以通過結(jié)合使用多重返回和匿名變量來避免這種丑陋的寫法，讓代碼看起來更加優(yōu)雅
這種用法可以讓代碼非常清楚，基本上屏蔽掉掉了可能混淆代碼閱讀者視線的內(nèi)容，從而大大減低溝通的復(fù)雜度和代碼維護(hù)的難度。

案例展示

package main

import "fmt"

//go函數(shù)可以返回多個(gè)值
func test() (a, b, c int) {
    return 1, 2, 3
}

func main() {
    //匿名變量，丟棄數(shù)據(jù)不處理。
    //匿名變量配合函數(shù)返回值使用才有優(yōu)勢(shì)
    i, j := 10, 20
    var tmp int
    i = 16
    j = 27
    tmp, _ = i, j
    fmt.Println("tmp=", tmp)
    var c, d, e int
    c, d, e = test()
    fmt.Printf("c=%d,d=%d,e=%d\n", c, d, e)

2.常量

在Go語言中，常量是指編譯期間就已知且不可改變的值。常量可以是數(shù)值類型（包括整型、浮點(diǎn)型和復(fù)數(shù)類型）、布爾類型、字符串類型等。

2.1常量的定義

  • 對(duì)單個(gè)常量進(jìn)行定義
package main

import "fmt"

func main() {
    //變量：程序運(yùn)行期間，可以改變的量，變量聲明需要var
    //常量：程序運(yùn)行期間，不可以改變的量。常量聲明需要const
    const a int = 10
    // a = 20 這種賦值方式是錯(cuò)誤的。不允許給常量賦值
    fmt.Println("a=", a)

    const b = 10
    //在變量賦值時(shí)格式為 b :=10
    fmt.Printf("b type is %T\n", b)
    fmt.Println("b=", b)
}
  • 對(duì)多個(gè)變量或者常量進(jìn)行定義
package main

import "fmt"

func main() {
    var (
        a float64 = 3.4
        b         = 2
    )
    fmt.Println("a=", a)
    fmt.Println("b=", b)
    const (
        i     = 10.246
        j int = 10
    )
    fmt.Println("i=", i)
    fmt.Println("j=", j)

}

2.2 枚舉

枚舉指一系列相關(guān)的常量，關(guān)鍵字iota定義常量組中從0開始按行計(jì)數(shù)的自增枚舉值。

package main

import "fmt"

func main() {
    //1.iota常量自動(dòng)生成器，每一行自動(dòng)累加1
    //2.iota給常量賦值使用
    const (
        a = iota //  值為0
        b = iota //  值為1
        c = iota //  值為2
    )
    fmt.Printf("a = %d , b=%d ,c =%d\n", a, b, c)
    //3.iota每次 遇到const均重新賦值為0
    const d = iota
    fmt.Printf("d =%d\n", d)
    //4.可以只書寫一個(gè)iota，后續(xù)電腦自行推到
    const (
        a1 = iota
        b1
        c1
    )
    fmt.Printf("a1 = %d , b1=%d ,c1 =%d\n", a1, b1, c1)
    //5.iota如果在同一行，其值均相等
    const (
        i          = iota
        j1, j2, j3 = iota, iota, iota
        k          = iota
    )
    fmt.Printf("i = %d , j1=%d , j2=%d, j3=%d,k =%d\n", i, j1, j2, j3, k)
}

3.數(shù)據(jù)類型

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


3.2布爾類型

func main() {
    //1.聲明變量
    var a bool
    fmt.Println("a0=",a)   //判斷布爾類型零值
    
    a = true
    fmt.Println("a=", a)
    //2.自動(dòng)推到類型
    var b = false
    fmt.Println("b=", b)

    c := false
    fmt.Println("c=", c)
}

3.3浮點(diǎn)數(shù)類型

  • float 64 比float 32精度更加準(zhǔn)確
//聲明變量
    var f1 float32
    f1 = 3.1415926
    fmt.Println("f1=", f1)
    //自動(dòng)推到類型
    f2 := 3.99
    fmt.Printf("f2 type is %T\n", f2)

3.4字符（串）類型

  • 字符類型
    在go語言中支持兩個(gè)字符類型，一個(gè)是byte，代表utf-8字符串的單個(gè)字節(jié)的值，另一種是rune，代表單個(gè)Unicode字符
var ch byte //聲明字符類型
    ch = 97
    fmt.Println("ch =", ch)
    //格式化輸出，%c是以字符方式打印，%d是以整型方式打印，%T是以格式類型打印
    fmt.Printf("%c ,%d\n", ch, ch)

    ch = 'a' //字符，單引號(hào)
    fmt.Printf("%c ,%d\n", ch, ch)

    //大寫轉(zhuǎn)小寫，小寫轉(zhuǎn)大寫，兩者相差32
    fmt.Printf("大寫：%d ,小寫%d\n", 'A', 'a')
    fmt.Printf("大寫轉(zhuǎn)小寫：%c\n", 'A'+32)
    fmt.Printf("小寫轉(zhuǎn)大寫：%c\n", 'a'-32)

    // ‘\’以反斜杠開頭的字符是轉(zhuǎn)移符
    fmt.Printf("hrllo word%c", '\n')
    fmt.Printf("hello 比卡丘")
  • 字符串類型
    字符串是不可變值類型，內(nèi)部用指針指向UTF-8字節(jié)數(shù)組
var str1 string //聲明變量
    str1 = "abc"    // 字符為單引號(hào)，而字符串為雙引號(hào)
    fmt.Println("str1=", str1)

    //自動(dòng)推導(dǎo)類型
    str2 := "mike"
    fmt.Printf("str2 類型是 %T\n", str2)

    //內(nèi)建函數(shù)，len()可以測(cè)字符的長(zhǎng)度，有多少個(gè)字符
    fmt.Println("len(str2)=", len(str2))

注意：字符與字符串的區(qū)別

  • 字符單引號(hào)控制，除轉(zhuǎn)義字符（\n）外往往都只有一個(gè)字符。
  • 字符串雙引號(hào)控制字符串有一個(gè)或者多個(gè)字符組成，字符串都是隱藏了一個(gè)結(jié)束符（\0）的
ch := 'a'
    fmt.Println("ch =", ch)

    str := "hello go"
    fmt.Println("str =", str)
    fmt.Printf("str[0]=%c,str[1]=%c\n", str[0], str[1])

3.5 復(fù)數(shù)類型

var t complex128
    t = 2.1 + 3.14i
    fmt.Println("t =", t)

    //自動(dòng)推到類型
    t2 := 3.3 + 4.4i
    fmt.Println("t2 type is %T\n", t2)

    //通過內(nèi)建函數(shù)，取實(shí)部和虛部
    fmt.Println("real(t2)=", real(t2), "imag(t2)=", imag(t2))

4.fmt包的格式化輸出輸入

image.png

4.1輸出的使用

a := 10
    b := "abc"
    c := 'a'
    d := 3.14
    // %T操作變量所屬類型
    fmt.Printf("%T ,%T ,%T,%T\n", a, b, c, d)
    fmt.Printf("a=%d ,b=%s ,c=%c,d=%f\n", a, b, c, d)
    fmt.Printf("a=%v ,b=%v ,c=%v,d=%v\n", a, b, c, d)   //%v自動(dòng)匹配格式

4.2輸入的使用

    var a int //聲明變量
    fmt.Printf("請(qǐng)輸入變量a:")

    //阻塞等待用戶的輸入
    // fmt.Scanf("%d", &a) //別忘記加&
    fmt.Scan(&a)

    fmt.Println("a=", a)

5.類型轉(zhuǎn)換與別名

5.1類型轉(zhuǎn)換

    var a int //聲明變量
    fmt.Printf("請(qǐng)輸入變量a:")

    //阻塞等待用戶的輸入
    // fmt.Scanf("%d", &a) //別忘記加&
    fmt.Scan(&a)

    fmt.Println("a=", a)

5.2類型別名

//給int64起一個(gè)別名叫bigint
    type bigint int64

    var a bigint //等價(jià)于 var a int64
    fmt.Printf("a type is %T\n", a)

    type (
        long int64
        char byte
    )
    var b long = 11
    var ch char = 'a'
    fmt.Printf("b=%d,ch=%c\n", b, ch)

6.運(yùn)算符

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

image.png

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

image.png
fmt.Println("4 > 3結(jié)果：", 4 > 3)
fmt.Println("4 != 3 結(jié)果：", 4 != 3)

--result------------------
H:\golang>go run 08_字符串類型.go
4 > 3結(jié)果： true
4 != 3 結(jié)果： true

6.3 邏輯運(yùn)算符

image.png
fmt.Println("!(4 > 3)結(jié)果：", !(4 > 3))
    fmt.Println("!(4 != 3) 結(jié)果：", (4 != 3))

    //&&與 ，并且，左邊右邊都為真，結(jié)果才是真
    fmt.Println("true && true 結(jié)果", true && true)
    fmt.Println("true && true 結(jié)果", true && false)

    // ||或者，左邊右邊都是假，結(jié)果才是假，其他情況都是真
    fmt.Println("true || true 結(jié)果", true || true)
    fmt.Println("true || true 結(jié)果", true || false)

特別注意：當(dāng)關(guān)系與邏輯運(yùn)算相結(jié)合時(shí)。無區(qū)間定義

  • 在go語言中bool類型和int類型不兼容
#判斷一個(gè)數(shù)字，是否在0-10的范圍內(nèi)
a := 8
    fmt.Println("0 <= a && a <= 10結(jié)果是", 0 <= a && a <= 10)

6.4位運(yùn)算符

image.png

6.5 賦值運(yùn)算符

image.png

6.6 其他運(yùn)算符

image.png

6.7運(yùn)算優(yōu)先級(jí)

在go語言中，一元運(yùn)算符擁有最高優(yōu)先級(jí)，二元運(yùn)算符的運(yùn)算方向均是從左至右。


image.png
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • 1 GO語言介紹 Go是一種新的語言，一種并發(fā)的、帶垃圾回收的、快速編譯的語言。它具有以下特點(diǎn)： 它可以在一臺(tái)計(jì)算...
    萬能的華哥Dean閱讀 2,742評(píng)論 2贊 38
  • 我先想分析一下現(xiàn)在有哪些公司使用go 語言，go語言在實(shí)際開發(fā)中有哪些使用場(chǎng)景，為什么要從其他語言轉(zhuǎn)換成go語言。...
    碼農(nóng)甲閱讀 645評(píng)論 0贊 0
  • 首先介紹下GO語言的起源 Go語言是一個(gè)開源的編程語言，它能讓構(gòu)造簡(jiǎn)單，可靠且高效的軟件變得容易。GO是從2007...
    DX初學(xué)者閱讀 880評(píng)論 0贊 1
  • Go 語言入門 Go 語言簡(jiǎn)介 Go 使一個(gè)開源的編程語言。 從2007年末 有Robert Griesemer,...
    Impassable_time閱讀 524評(píng)論 0贊 1
  • 本篇主要介紹go的生態(tài)。包括安裝，ide，go命令三部分。隨著作者的持續(xù)學(xué)習(xí)，內(nèi)容可能會(huì)有所更新。 安裝 截止到本...
    納達(dá)丶無忌閱讀 2,203評(píng)論 1贊 6

友情鏈接更多精彩內(nèi)容