Golang基礎(chǔ)語法

一、變量定義

使用關(guān)鍵字var定義變量：
?? 1硬贯、var [變量名] [變量類型]
??例如： var a int (未給變量賦初始值則變量會有默認值岛马，當前變量默認值為0)
?? 2、var [變量名] [變量類型] = [變量值] ---- 例如：var a int = 1
?? 3工碾、var [變量名],[變量名],... [變量類型] = [變量值],[變量值],...
??例如： var a, b, c int = 1, 2, 3 (同時定義多個變量并賦值時必須保證每個變量都賦值)
?? 4、var [變量名],[變量名],[變量名],... = [變量值],[變量值],[變量值]...
??例如： var a, b, c = 1, "hh", false
??(未定義變量類型時百姓，可以同時定義多個不同類型的變量;go語言編譯器能根據(jù)變量值自動推斷出變量類型)
?? 5渊额、var (
??????[變量名] = [變量值]
??????[變量名] = [變量值]
??????...
?????)
使用“:=”定義變量
?? [變量名] := [變量值]
?? 例如：a := 1 (符號":="定義變量的方式只能在函數(shù)內(nèi)使用，函數(shù)外必須有關(guān)鍵字開頭)

var (
    name  = "豬豬"
    age   = 18
    phone = 12345678
)
func variableDefaultValue() {
    var a int
    var b string
    fmt.Printf("%d,%q\n", a, b)
}

func variableInit() {
    var a, b = 1, "test"
    println(a, b)
}

func variableMultiple() {
    a, b, c := 1, 2, 3
    println(a, b, c)
}
go語言中定義的變量必須被使用瓣戚，在函數(shù)外定義的變量稱為：包內(nèi)變量

二端圈、 內(nèi)建變量類型

bool 、 string
(u)int 子库、(u)int8 舱权、(u)int16 、(u)int32仑嗅、(u)int64宴倍、uintptr(指針) --- 加u即無符號整數(shù)
byte 、rune
float32仓技、float64鸵贬、complex64(實數(shù)float32、虛數(shù)float32) 脖捻、complex128(實數(shù)float64阔逼、虛數(shù)float64)

  • 強制類型轉(zhuǎn)換
func demo() {
    a, b := 3, 4
    var c int
    c = int(math.Sqrt(float64(a*a + b*b)))
    println(c)
}
  • 變量要點

1、變量類型寫在變量名之后
2地沮、編譯器可推測變量類型
3嗜浮、沒有char,只有rune
4羡亩、原生支持復(fù)數(shù)類型

三、 常量與枚舉

/**
 *常量和枚舉
 *使用關(guān)鍵字const定義常量危融，和定義變量基本相同
 *枚舉類型：
 *  普通枚舉
 *  自增值枚舉
 */
func constDemo() {
    //定義常量
    const a = 1
    const b, c = 4, 5
    const project = "golang"
    println(a, b, c, project)
    const (
        language = "golang"
        code     = 01
    )
    println(language, code)
    //普通枚舉
    const (
        java   = 01
        golang = 02
        scala  = 03
    )
    println(java, golang, scala)
    //自增值枚舉
    const (
        lua = iota
        spark
        python
    )
    println(lua,spark,python)
}

四畏铆、條件語句

/**
 * 條件語句
 * if [表達式] {}else{}
 * switch [表達式(可忽略)]
 *
 */
func demo(code int) string {

    a := "hello"
    c := "go"
    d := a + c

    e := "hello" + "go"

    if d == e {
        fmt.Println(true)
    } else {
        fmt.Println(false)
    }

    if b := "hello"; a == b {
        fmt.Println(true)
    } else {
        fmt.Println(false)
    }

    switch {
    case code == 1:
        return "春天"
    case code == 2:
        return "夏天"
    case code == 3:
        return "秋天"
    case code == 4:
        return "冬天"
    default:
        panic("code wrong")
    }
}
  • 總結(jié)

1、if 語句的條件不需要()
2吉殃、if 的條件里可以賦值
3辞居、if 的條件里賦值的變量作用域就在這個if語句里
4、switch 語句會自動break蛋勺，除非使用fallthrough
5瓦灶、switch后可以沒有表達式

五、循環(huán)

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    sum := 0
    for i := 1; i <= 10; i++ {
        sum += i
    }
    fmt.Println(sum)

    fmt.Println(convertToBin(10),
        convertToBin(32832),
        convertToBin(8),
    )

    printFile("test.txt")
    forever()
}

/**
 * 省略初始條件  相當于while
 */
func convertToBin(n int) string {
    res := ""
    for ; n > 0; n /= 2 {
        lsb := n % 2

        //strconv.Itoa(lsb) 轉(zhuǎn)為字符串
        res = strconv.Itoa(lsb) + res
    }
    return res
}

/**
 * 沒有初始條件和遞增值
 */
func printFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        panic(err)
    }

    scanner := bufio.NewScanner(file)

    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

/**
 * 無限循環(huán)
 */
func forever()  {
    for {
        fmt.Println("123")
    }
}
  • 總結(jié)

1迫卢、for 循環(huán)的條件里不需要括號
2倚搬、for 的條件里可以省略初始條件冶共，結(jié)束條件乾蛤，遞增表達式
3、沒有while循環(huán)

六捅僵、函數(shù)

package main

import (
    "fmt"
    "math"
    "reflect"
    "runtime"
)

func calculate(a, b int, opt string) (int, error) {
    switch opt {
    case "+":
        return a + b, nil
    case "-":
        return a - b, nil
    case "*":
        return a * b, nil
    case "/":
        consult, _ := div(a, b)
        return consult, nil
    default:
        return 0, fmt.Errorf("unsupported opt: %s", opt)
    }
}

func apply(op func(int, int) int, a, b int) int {
    //通過反射獲取函數(shù)名稱
    pointer := reflect.ValueOf(op).Pointer()
    funcName := runtime.FuncForPC(pointer).Name()
    fmt.Printf("Calling function %s with args (%d, %d)\n", funcName, a, b)
    return op(a, b)
}

/**
 * 計算兩數(shù)的商和余數(shù) 并返回
 */
func div(a, b int) (consult, remainder int) {
    return a / b, a % b
}

/**
 * a 的 b次方
 */
func pow(a, b int) int {
    return int(math.Pow(float64(a), float64(b)))
}

func sum(nums ...int) int {
    sum := 0
    for i := range nums {
        sum += nums[i]
    }
    return sum
}

func main() {

    res, err := calculate(7, 6, "X")
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(res)
    }

    if res, err := calculate(1, 3, "X"); err != nil {
        fmt.Println("error:", err)
    } else {
        fmt.Println(res)
    }

    fmt.Println(calculate(5, 8, "/"))
    fmt.Println(div(10, 7))

    fmt.Println(apply(pow, 2, 3))
    fmt.Println(apply(func(a int, b int) int {
        return int(math.Pow(float64(a), float64(b)))
    }, 2, 3))

    fmt.Println(sum(1,4,5,6,3))
}
  • 總結(jié)

1家卖、函數(shù)可以返回多個值并可以起名字
2、僅用于非常簡單的函數(shù)
3庙楚、對于調(diào)用者來說沒有區(qū)別
4上荡、函數(shù)可作為參數(shù)
5、沒有默認參數(shù)馒闷，可選參數(shù)

七酪捡、指針

func swap(a, b *int) {
    *b, *a = *a, *b
}

func main() {
    a, b := 3, 4
    swap(&a, &b)
    fmt.Println(a, b)
}
  • 總結(jié)

1、指針不能運算
2纳账、只有值傳遞一種方式

八逛薇、數(shù)組

package main

import "fmt"

func arrays(arr [5]int)  {
    arr[0] = 10
    for i := range arr{
        fmt.Println(arr[i])
    }
}



func main() {

    //定義數(shù)組的方式
    //數(shù)量寫在類型前
    var arr1 [3]int
    arr2 := [5]int{1, 2, 3, 4, 5}
    arr3 := [...]int{1, 3, 6, 4}
    fmt.Println(arr1, arr2, arr3)
    //遍歷數(shù)組
    //方式一
    for i := 1; i < len(arr2); i++ {
        fmt.Println(arr2[i])
    }

    fmt.Println("--------------------------")
    //方式二
    for i := range arr2{
        fmt.Println(arr2[i])
    }
    fmt.Println("--------------------------")
    //方式三，獲取值和下標
    for i,v := range arr2{
        fmt.Println(i,v)
    }

    fmt.Println("arrays------------------------")
    arrays(arr2)

    fmt.Println("arr2----------------")
    fmt.Print(arr2)
}
  • range關(guān)鍵字

1疏虫、意義明確
2永罚、任何地方都能通過'_'省略變量
3、可以同時獲取下標和值

  • 數(shù)組是值類型

1卧秘、[10] int 和 [20] int 是不同類型
2呢袱、調(diào)用 func f(arr [10] int ) 會 拷貝 數(shù)組
3、在go 語言中一般不直接使用數(shù)組

九翅敌、Slice（切片）---- 相當于java的list

image.png
Slice的實現(xiàn)
package main

import "fmt"

func updateVal(arr []int) {
    arr[0] = 10
}

func main() {

    array := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    fmt.Println("array[2:6] = ", array[2:6])
    fmt.Println("array[2:] = ", array[2:])
    fmt.Println("array[:6] = ", array[:6])
    fmt.Println("array[:] = ", array[:])

    fmt.Println("update array before : ", array)
    updateVal(array[:])
    fmt.Println("update array after: ", array)

    s1 := array[1:5] //[1 2 3 4]
    fmt.Println("s1 = array[1:5] = ", s1)
    s2 := s1[3:5]
    fmt.Println("s2 = ", s2)
    fmt.Println("-------------------------------")
    fmt.Printf("s1=%v, len(s1)=%d, cap(s1)=%d\n", s1, len(s1), cap(s1)) //cap(s1) = [1, 2, 3, 4, 5, 6, 7]
    fmt.Printf("s2=%v, len(s2)=%d, cap(s2)=%d\n", s2, len(s2), cap(s2)) //cap(s2) = [4, 5, 6, 7]

}

1羞福、Slice本身沒有數(shù)據(jù)，是對底層array的一個view
2蚯涮、Slice可以向后擴展治专，不可以向前擴展
3焊唬、s[i] 不可以超越 len(s) , 向后擴展不可以超越底層數(shù)組cap(s)

  • 切片的操作
    1、向Slice添加元素時看靠，如果超越cap赶促，系統(tǒng)會重新分配更大的底層數(shù)組
    2、由于值傳遞的關(guān)系挟炬，必須接收append的返回值 例如 s = append(s,val)
package main

import "fmt"

func printSlice(s []int) {
    fmt.Printf("%v, len=%d, cap=%d\n", s, len(s), cap(s))
}



func main() {
    var s []int //zero val for slice is nil
    for i := 0; i < 10; i++ {
        printSlice(s)
        s = append(s, 2*i+1)
    }
    fmt.Println(s)

    s1 := []int{2, 4, 6, 8}
    printSlice(s1)

    s2 := make([]int, 10)
    s3 := make([]int, 8, 16)
    fmt.Println(s2)
    fmt.Println(s3)

    fmt.Println("Slice copy")
    copy(s2, s1)
    printSlice(s2)

    fmt.Println("Slice delete")
    s2 = append(s2[:3],s2[4:]...)
    printSlice(s2)

    fmt.Println("popping from front")
    front := s2[0]
    s2 = s2[1:]
    fmt.Println(front)
    printSlice(s2)


    fmt.Println("popping from back")
    back := s2[len(s2)-1]
    s2 = s2[:len(s2)-1]
    fmt.Println(back)
    printSlice(s2)
}

十鸥滨、Map

  • 定義
    變量名 [key type] value type {}
    例如：
m := map [string] string {
        "name": "hhh",
        "age": "18",
     }
  • 復(fù)合map
    map[K1]map[K2]V 
package main

import "fmt"

func main() {

    fmt.Println("定義map------------------------------------------")
    //定義map
    //方式一  m == nil   變量名稱為m  key為string類型  value為string類型
    var m map[string]string
    fmt.Println("m = ", m)
    //方式二
    m2 := map[string]string{
        "course":  "golang",
        "article": "map",
        "test":    "delete",
    }
    fmt.Println("m2 = ", m2)
    //方式三  m3 == empty map
    m3 := make(map[int]string)
    fmt.Println("m3=", m3)

    fmt.Println("遍歷map-------------------------")
    //遍歷map
    for k, v := range m2 {
        fmt.Println("m2 的key和val: ", k, v)
    }
    for k := range m2 {
        fmt.Println("m2 的key: ", k)
    }
    for value := range m2 {
        fmt.Println("m2 的val: ", value)
    }

    fmt.Println("根據(jù)key獲取元素----------------------------")
    //根據(jù)key值獲取元素
    val := m2["course"]
    fmt.Println(val)

    fmt.Println("判斷map中的元素是否存在-----------------------------")
    //判斷map中的元素是否存在
    val2, ok := m2["course"]
    fmt.Println(val2, ok)

    if val3, ok := m2["course"]; ok {
        fmt.Println(val3)
    } else {
        fmt.Println("val is not exist")
    }

    fmt.Println("根據(jù)Key刪除元素-----------------------")
    //根據(jù)Key刪除元素
    fmt.Println("刪除m2的元素前：",m2)
    delete(m2, "test")
    fmt.Println("刪除m2的元素后：",m2)

}
  • 總結(jié)

1、map是無序的
2谤祖、key不存在時婿滓，獲得value類型的初始值
3、map使用哈希表粥喜，必須可以比較相等
4凸主、除了slice，map额湘，function的內(nèi)建類型都可以作為key
5卿吐、Struct類型不包含上述字段，也可作為key

十一锋华、字符和字符串

  • rune （相當于go的char）

1嗡官、使用range 遍歷pos,rune對
2、使用utf8.RuneCountInString獲得字符數(shù)量
3毯焕、使用len獲得字節(jié)長度
4衍腥、使用[]byte獲得字節(jié)

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市纳猫，隨后出現(xiàn)的幾起案子婆咸，更是在濱河造成了極大的恐慌，老刑警劉巖芜辕，帶你破解...
    沈念sama閱讀 217,826評論 6贊 506
  • 死咒
    序言：濱河連續(xù)發(fā)生了三起死亡事件尚骄，死亡現(xiàn)場離奇詭異，居然都是意外死亡物遇，警方通過查閱死者的電腦和手機乖仇，發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 92,968評論 3贊 395
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來询兴，“玉大人乃沙，你說我怎么就攤上這事∈ⅲ” “怎么了警儒？”我有些...
    開封第一講書人閱讀 164,234評論 0贊 354
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經(jīng)常有香客問我蜀铲，道長边琉，這世上最難降的妖魔是什么伞梯？ 我笑而不...
    開封第一講書人閱讀 58,562評論 1贊 293
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任骂倘，我火速辦了婚禮，結(jié)果婚禮上种柑，老公的妹妹穿的比我還像新娘厌丑。我一直安慰自己定欧，他們只是感情好，可當我...
    茶點故事閱讀 67,611評論 6贊 392
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布怒竿。 她就那樣靜靜地躺著砍鸠，像睡著了一般。 火紅的嫁衣襯著肌膚如雪耕驰。 梳的紋絲不亂的頭發(fā)上爷辱，一...
    開封第一講書人閱讀 51,482評論 1贊 302
  • 城市分裂傳說
    那天，我揣著相機與錄音朦肘，去河邊找鬼饭弓。 笑死，一個胖子當著我的面吹牛厚骗，可吹牛的內(nèi)容都是我干的示启。 我是一名探鬼主播兢哭，決...
    沈念sama閱讀 40,271評論 3贊 418
  • 雙鴛鴦連環(huán)套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼领舰，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了迟螺？” 一聲冷哼從身側(cè)響起冲秽，我...
    開封第一講書人閱讀 39,166評論 0贊 276
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎矩父，沒想到半個月后锉桑，有當?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體，經(jīng)...
    沈念sama閱讀 45,608評論 1贊 314
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡窍株，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點故事閱讀 37,814評論 3贊 336
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年民轴，在試婚紗的時候發(fā)現(xiàn)自己被綠了。 大學時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片球订。...
    茶點故事閱讀 39,926評論 1贊 348
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡后裸，死狀恐怖，靈堂內(nèi)的尸體忽然破棺而出冒滩，到底是詐尸還是另有隱情微驶，我是刑警寧澤，帶...
    沈念sama閱讀 35,644評論 5贊 346
  • ?日本核電站爆炸內(nèi)幕
    正文 年R本政府宣布，位于F島的核電站因苹，受9級特大地震影響苟耻，放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜扶檐，卻給世界環(huán)境...
    茶點故事閱讀 41,249評論 3贊 329
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一凶杖、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧款筑，春花似錦官卡、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 31,866評論 0贊 22
  • 一樁弒父案寻咒，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至颈嚼，卻和暖如春毛秘，著一層夾襖步出監(jiān)牢的瞬間，已是汗流浹背阻课。 一陣腳步聲響...
    開封第一講書人閱讀 32,991評論 1贊 269
  • 情欲美人皮
    我被黑心中介騙來泰國打工叫挟， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人限煞。 一個月前我還...
    沈念sama閱讀 48,063評論 3贊 370
  • 代替公主和親
    正文 我出身青樓抹恳，卻偏偏與公主長得像，于是被迫代替她去往敵國和親署驻。 傳聞我的和親對象是個殘疾皇子奋献，可洞房花燭夜當晚...
    茶點故事閱讀 44,871評論 2贊 354

推薦閱讀更多精彩內(nèi)容