Golang程序設計——基本語法

時間  2021-02-26
標籤 編程 數組 數據結構 編程語言 函數 學習 spa 指針 code 欄目 Go 简体版
原文   原文鏈接

本文學習Go語言基本語法，例如變量和常量、數據類型、運算符、條件語句、循環語句。編程

變量和常量

變量和常量是計算機程序不可或缺的部分。本節將介紹如何在Go程序中聲明、使用變量和常量、還將介紹聲明方式和做用域。數組

變量聲明

在Go語言中，聲明變量的方式有多種。在前面的文章介紹過，Go語言是一種靜態類型語言，所以聲明變量時必須指明其類型。數據結構

例：聲明string類型的變量。編程語言

package main

import "fmt"

func main() {
    var s1 string = "Hello World"
    var s2 = "Hello World"
    var s3 string
    s3 = "Hello World"
    fmt.Println(s1, s2, s3)
}
  • 使用關鍵字var聲明變量。
  • 若是變量類型能夠經過值推導則不用聲明類型。s2經過值能夠推導類型爲string類型。
  • 變量能夠在聲明後賦值，未賦值的變量值爲該類型的零值。
變量的類型很重要，由於這決定了可將什麼值賦給該變量。例如，對於類型爲string的變量，不能將整數賦值給它。將不匹配的值賦值給變量時，將致使編譯錯誤。

例：將string類型的值賦值給int類型的變量。函數

package main

import "fmt"

func main() {
    var i int
    i = "Hello World"
    fmt.Println(i)
}

編譯該文件將致使編譯錯誤。學習

go build main.go 
# command-line-arguments
./main.go:7:4: cannot use "Hello World" (type untyped string) as type int in assignment

多變量聲明

例：聲明多個類型相同的變量並進行賦值（顯式指定類型）。ui

package main

import "fmt"

func main() {
    var s1, s2 string = "S1", "S2"
    fmt.Println(s1, s2)
}

例：聲明多個類型不一樣的變量並進行賦值（不能顯式指定類型）。spa

package main

import "fmt"

func main() {
    var s1, i1= "S1", 1
    fmt.Println(s1, i1)
}

例：聲明多個類型不一樣的變量（顯式指定類型）。指針

package main

import "fmt"

func main() {
    var (
        s1 string
        i1 int
    )
    s1 = "Hello"
    i1 = 10
    fmt.Println(s1, i1)
}
聲明變量後能夠再次賦值，可是同一個變量只容許聲明一次，不然將致使編譯錯誤。

簡短變量聲明

在函數中聲明變量時，能夠用更簡潔的方式。code

package main

import "fmt"

func main() {
    s1 := "Hello World"
    fmt.Println(s1)
}
  • :=表示簡短變量聲明，能夠不使用var，不指定類型，可是必須進行賦值。
  • 只能在函數中使用簡短變量聲明。

變量聲明最佳實踐

Go語言提供了多種變量聲明方式，下面的聲明方式都是合法的。

var s string = "Hello"
var s1 = "Hello"
var s2 string
s2 = "Hello"
s3 := "Hello"

該使用哪一種方式呢？

Go語言對此有一個限制——只能在函數內部使用簡短變量聲明，在函數外部必須使用var進行聲明。

在標準庫中遵循的約定以下：有初始值的狀況下，在函數內使用簡短變量聲明，在函數外使用var並省略類型；無初始值的狀況下使用var並指定類型。 
package main

import "fmt"

var s = "Hello World"

func main() {
    s1 := "Hello World"
    fmt.Println(s, s1)
}

變量和零值

在Go語言中，聲明變量時若是未初始化，則變量爲默認值，該默認值也稱爲零值。在其餘語言中未初始化的值爲null或undefined。

package main

import "fmt"

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

在Go語言中，檢查變量是否爲空，必須與該類型的零值比較。例如檢測string類型的變量是否爲空，能夠與""斷定。

package main

import "fmt"

func main() {
    var s string
    if s == "" {
        fmt.Println("s爲空")
    }
}

變量做用域

做用域指變量能夠在什麼地方使用，而不是說變量在哪裏聲明的。Go語言使用基於塊的詞法做用域，簡單來講就是{}會產生一個做用域。

Go語言做用域規則以下：

  1. 一對大括號({})表示一個塊，塊是能夠嵌套的
  2. 對於在塊內聲明的變量，能夠在本塊以及子塊中訪問
  3. 子塊能夠訪問父塊的變量，父塊不能訪問子塊的變量

例：Go語言的做用域。

package main

import "fmt"

func main() {
    var s1 = "s1"
    {
        var s2 = "s2"
        // 能夠訪問s1,s2
        fmt.Println(s1, s2)
        {
            var s3 = "s3"
            // 能夠訪問s1,s2,s3
            fmt.Println(s1, s2, s3)
        }
    }
    // 只能訪問s1
    fmt.Println(s1)
}
簡單來講，就是塊內能夠訪問塊外的變量，塊外不能訪問塊內變量。

聲明常量

常量只在整個程序運行過程當中都不變的值，常量必須在聲明時賦值，聲明後不能夠更改。

Go語言使用const關鍵字聲明常量。

package main

import "fmt"

const s = "Hello"

func main() {
    const s2 = "World"
    const s3,s4 = "Hello","World"
    fmt.Println(s, s2)
}
常量也支持一次聲明多個，此外常量的做用域和變量做用域一致。

數據類型

Go語言提供了豐富的數據類型，按類別分爲布爾型、數值型（整數、浮點數、複數）、字符串型 、派生型。其中派聲型包括指針類型、數組類型、結構體類型、接口類型、Channel類型、函數類型、切片類型和Map類型。

派生類型咱們將在後面的內容中進行介紹。

布爾類型

布爾類型值只能爲true或false。某些語言容許使用1和0來表示true和false，但Go語言不容許。

布爾類型的零值爲false。

package main

import "fmt"

func main() {
    var b bool
    if b {
        fmt.Println("b是true")
    } else {
        fmt.Println("b是false")
    }
}

數值型

Go語言中數值型包含整數、浮點數以及複數。

整數型

類型 字節數 範圍
byte 1 0 ~ 28
uint8 1 0 ~ 28
int8 1 -27 ~ 27-1
uint16 2 0 ~ 216
int16 2 -215 ~ 215-1
uint32 4 0 ~ 232
int32 4 -231 ~ 231-1
uint64 8 0 ~ 264
int64 8 263 ~ 263-1
int 平臺相關(32位或64位)
uint 平臺相關(32位或64位)

浮點數

類型 字節數 範圍
float32 4 -3.403E38 ~ 3.403E38
float64 8 -1.798E308 ~ 1.798E308

複數

略

字符串類型

字符串能夠是任何字符序列，包括數字、字母和符號。Go語言使用Unicode來存儲字符串，所以能夠支持世界上全部的語言。

下面是一些字符串示例：

var s = "$%^&*"
var s2 = "1234"
var s3 = "你好"

運算符

運算符用於在程序運行時執行數據運算和邏輯運算。Go語言支持的運算符有：

  • 算術運算符
  • 邏輯運算符
  • 關係運算符
  • 位運算符

算術運算符

算術運算符是用來對數值類型進行算術運算的。下表列出了Go語言支持的算術運算符。

運算符 說明
+ 相加
- 相減
* 相乘
/ 相除
% 取餘
++ 自增
-- 自減 
package main

import "fmt"

func main() {
    var (
        a = 10
        b = 20
    )
    fmt.Printf("a+b=%d\n", a+b)
    fmt.Printf("a-b=%d\n", a-b)
    fmt.Printf("a*b=%d\n", a*b)
    fmt.Printf("a/b=%d\n", a/b)
    fmt.Printf("a%%b=%d\n", a%b)
    a++
    fmt.Printf("a++=%d\n", a)
    a--
    fmt.Printf("a--=%d\n", a)
}
和其餘語言不一樣的是，Go語言不提供++a，--a運算符，只提供a++，a--。

關係運算符

關係運算符用來判斷兩個值的關係。下表列出了Go語言支持的關係運算符。

運算符 說明
== 判斷兩個值是否相等
!= 判斷兩個值是否不相等
> 判斷運算符左邊的值是否大於右邊的值
< 判斷運算符左邊的值是否小於右邊的值
>= 判斷運算符左邊的值是否大於等於右邊的值
<= 判斷運算符左邊的值是否小於等於右邊的值 
package main

import "fmt"

func main() {
    var (
        a = 10
        b = 20
    )
    if a == b {
        fmt.Println("a==b")
    } else {
        fmt.Println("a!=b")
    }

    if a < b {
        fmt.Println("a<b")
    } else {
        fmt.Println("a>=b")
    }

    if a <= b {
        fmt.Println("a<=b")
    } else {
        fmt.Println("a>b")
    }
}

邏輯運算符

邏輯運算符用來對操做數進行邏輯判斷。下表列出了Go語言支持的邏輯運算符。

運算符 說明
&& 邏輯與。兩邊操做數都爲true則結果爲true，不然爲false
\ \ 邏輯或。兩邊操做數只要有一個爲true則結果爲true，不然爲false
! 邏輯非。若是操做數爲true則結果爲false，不然爲true 
package main

import "fmt"

func main() {
    var a, b = true, false
    if a && b {
        fmt.Println("a和b同時爲true")
    } else {
        fmt.Println("a和b至少一個爲false")
    }

    if a || b {
        fmt.Println("a和b至少一個爲true")
    } else {
        fmt.Println("a和b都爲false")
    }
    if !a {
        fmt.Println("a是false")
    } else {
        fmt.Println("a是true")
    }
}

位運算符

位運算符用來對整數進行二進制位操做。下表列出了Go語言支持的位運算符。

運算符 說明
& 按位與
\ 按位或
^ 按位異或
>> 右移
<< 左移 
package main

import "fmt"

func main() {
    var (
        a = 1
        b = 2
    )
    fmt.Printf("a&b=%d\n", a&b)
    fmt.Printf("a|b=%d\n", a|b)
    fmt.Printf("a^b=%d\n", a^b)
    fmt.Printf("a>>1=%d\n", a>>1)
    fmt.Printf("a<<1=%d\n", a<<1)
}

條件語句

條件語句是計算機程序的重要組成部分，幾乎全部編程語言都支持。簡單地說，條件語句檢查指定的條件是否知足，並在知足時執行指定的操做。

下表列出了Go語言支持的條件語句。

if 由一個布爾表達式後緊跟一個或多個語句組成。
if...else if...else 由多個布爾表達式分支組成，並提供例外分支
switch 基於不一樣條件執行不一樣操做，並提供默認操做

例：if的使用。

package main

import "fmt"

func main() {
    var a = 10
    if a > 10 {
        fmt.Println("a大於10")
    } else if a == 10 {
        fmt.Println("a等於10")
    } else {
        fmt.Println("a小於10")
    }
}

例：switch的使用。

package main

import "fmt"

func main() {
    var a = 10

    switch a {
    case 1:
        fmt.Println("a等於1")
    case 2:
        fmt.Println("a等於2")
    case 10:
        fmt.Println("a等於3")
    default:
        fmt.Println("默認分支")
    }
}
和其餘語言不一樣，Go語言的case分支不須要添加break。

循環語句

在其餘語言中通常會提供for、while、foreach等關鍵字實現循環，而在Go語言中只提供for關鍵字，可是也實現了相似的效果。

for

for循環有着經典的三段式結構：

  1. 循環初始化
  2. 循環終止條件
  3. 循環步進條件
package main

import "fmt"

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

while

while循環指定循環終止條件，不知足條件時循環一直執行並向終止條件靠攏，知足條件後終止循環。（無終止條件的循環稱爲死循環）

package main

import "fmt"

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

死循環不須要終止條件。

package main

import (
  "fmt"
  "time"
)

func main() {
  i := 0
  for {
    fmt.Println(i)
    i++
    time.Sleep(time.Second)
  }
}

foreach

foreach循環多用來遍歷列表、字典等數據結構。

package main

import "fmt"

func main() {
  list := []int{1, 2, 3, 4, 5}
  for index, value := range list {
        fmt.Println(index, value)
  }
}

continue

continue用來跳過本次循環繼續執行下次循環。

package main

import "fmt"

func main() {
  for i := 0; i < 5; i++ {
    if i == 1 {
      continue
    }
    fmt.Println(i)
  }
}

該程序判斷i爲1時跳過並執行下次循環，該程序輸出以下。

0
2
3
4

3.1.5 break

break用來跳出循環，後續循環將不執行。

package main

import "fmt"

func main() {
  for i := 0; i < 5; i++ {
    if i == 1 {
      break
    }
    fmt.Println(i)
  }
}

該程序判斷i爲1時跳出循環，該程序輸出以下。

0

小結

本文介紹了Go語言的基本語法，包括變量和常量的使用、基礎數據類型、流程控制等知識。下一章將介紹Go語言的數據容器類型，包括數組、切片和映射。

img

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程