Golang 基礎語法-基本變量(2)

Golang 基礎語法-基本變量(2)

變量的零值說明

• 數值類型變量的零值爲 0
• 布爾類型變量的零值爲 false
• 字符串類型變量的零值爲 "」

變量的類型轉換語法

golang 中不一樣類型之間的變量賦值須要顯式的轉換

//語法格式 T(v) 將 v 轉換爲 類型 T
var i int = 32
var f float64 = float64(i)
var u uint = uint(64)

變量的定義(聲明)

• 使用 var 聲明
  不管在函數內仍是函數外，均可以使用 var 聲明變量

  基本語法格式爲：
  var varName varType
  var varName = varValue
  var varName1, varName2 varType
  var varName1, varName2 = varValue1, varValue2

  在基本語法格式上能夠進行一些靈活組合，可是建議不要用花哨的語法

  //聲明可是不初始化(foo 的值爲對應變量類型的零值)
  var foo int;
  //聲明且初始化(var聲明初始化的時候不須要指定變量類型，編譯器自動根據初始化值肯定變量類型)
  var bar  = 3 //推薦寫法
  var bar int = 3 //合法可是不推薦
  //聲明 i1, i2 爲 int 類型(初始值爲 int 類型的零值 0)
  var i1, i2 int
  //聲明 i1 和 i2同時賦值爲1，2
  var i1, i2 = 1, 2
  //聲明 int 類型的 i1,string 類型的 s1
  var i1, s1 = 1, "a"
  //聲明一組全局變量,變量能夠初始化或者不初始化
  var(
      i1, i2 = 1, 2
      i3, i4 int
      s1 = "111221"
      b1 = true
  )

• 快捷語法
  只能在函數體內使用快捷語法，函數體外非法

  語法格式
  varName1 := varValue1

  func main(){
      //聲明變量 i1而且同時給變量賦值
      i1 := 1
      //聲明變量 i2,s1而且同時給他們賦值
      i2, s1 := 1, "11"
  }

• var聲明和快捷語法聲明須要注意的地方

  便捷聲明方法是聲明一個新的變量且賦值，不能用做給 var 聲明的變量賦值

  var foo = 1
  func main(){
      foo := 10
      //輸出10 使用的局部變量取值
      fmt.Println(foo)
      //PS: 必定要注意下面有語法錯誤
      var bar int
      bar := 11   //便捷方式實際上是先聲明一個新變量而後給賦值，可是此時 bar 變量已經存在了不能重複定義
  }

特殊變量 _

變量 _ 用來拋棄忽略某個值，golang 中不容許存在沒有使用的變量

• 函數多返回值拋棄

  _, r := divide(10, 3)

• 導入包不使用(可是會調用導入包的 init方法)

  import(
      "fmt"
      _ "os"
  )

常量

常量是指變量一旦定義，在編譯階段它的值就是肯定了的，在運行階段是不能夠被改變的，golang 中 number|boolean|string 類型能夠定義爲常量

定義語法
const constantName = value
cosnt constantName constantType = value

const PI = 3.14
const Pi float32 = 3.14156

變量類型

golang 中的 基本變量類型主要爲 number,bool,string等

Boolean

關鍵詞 bool 用於定義 boolean類型變量，boolean 類型變量的取值只有 true 和 false, 零值(默認值)爲 false
golang 不容許把 boolean 類型轉變爲數字類型

數字類型(Numerrical)

Integers

golang 不容許類型不一樣的變量進行運算，例如 int8類型的變量和 int32類型的變量不能進行加法操做

• signed

  • int 長度取決於操做系統，32位操做系統是32位，64位操做系統是64位
  • rune 它是int32的別名
  • int8
  • int16
  • int32
  • int64

• unsigned

  • uint
  • byte 它是 uint8的別名
  • uint8
  • uint16
  • uint32
  • uint64

浮點型

注意沒有 float 這個類型

• float32
• float64

複數(Complex)

• complex128
• complex64

字符串(string)

goalng 使用 UTF-8做爲編碼結合，使用 " 或者 ` 包裹起來的字符就是一個 string
` 定義多行字符串

var s1 = "hello"
var s2 = `hello
word`

string 對象不容許改變值(可是能夠給從新賦值)，下面的語法錯誤

var s = "hello"
s[0] = 'c'

若是要改變一個變量的值，須要使用舊的變量建立

s := "heloo"
c := byte(s) //string 轉換爲[]byte 類型
c[0] = 'c'
s2 := string(c) //把 c []byte 轉爲 string
fmt.Printf("%s\s\n", s2)

+ 能夠用來拼接兩個字符串

s := "hello, "
m := "world"
a := s + m
fmt.Printf("%s\n", a)

//輸出 "cello, "
s = "c" + s[1:] //返回 "c" + s從索引1到結束的字符串拼接

Error(golang 內置，其餘語言沒有的)

golang沒有 try-catch 語句塊處理異常，內置了 error 類型用於處理錯誤

err := errors.New("some error messaage")
if err != nil {
    //TODO something
}

其餘

• 分組定義
  若是你想定義多個常量，變量或者導入多個包，可使用分組格式

  //如下是非分組形式
  import "fmt"
  import "os"
  
  const i = 100
  const pi = 3.145
  
  var i int
  var pi float32
  var prefix string
  //分組形式
  import(
      "fmt"
      "os"
  )
  const(
    
      pi = 3.145
      prefix = "GO"
  )
  var(
  
      pi float32
      prefix string
  )

• iota 枚舉

  關鍵字 iota 能夠生成枚舉類型，枚舉值從0開始，每次加1

const(
        //x == 0
        x = iota
        //y == 1
        y = iota 
        //z == 2
        z = iota 
        //若是常量名稱後面沒有任何表達式
        //則 w 等價於 w = iota, w == 3
        w
    )
    const v = iota //v == 0
    //PS 注意在同一行時的 iota 特殊狀況
    const(
        //若是 iota 在同一行，則 e == f == g == 0
        e, f, g = iota, iota, iota 
    )

• 變量的可見性

  • 任何以大寫字母開頭的變量都是能夠被導出的，即在包外能被訪問，
  • 函數或者常量大寫字母開頭的，也是能夠被導出的，包外能夠訪問的
  • golang 中沒有 public 或者 private 來控制變量函數常量等的可見性，經過變量函數常量的名稱的首字母是否大小寫來判斷

package test
//Foo 在包 test 以外能夠經過 test.Foo 訪問
var Foo
//bar 在包 test 以外經過 test.bar 訪問是錯誤的，由於它的首字母是小寫，包外不可見
var bar
//函數在test 包外可使用 test.Test1()訪問
func Test1(){

}
//函數在 test 包外不能夠經過 test.test2()訪問，只能夠在包內使用
func test2(){

}
//包外使用 test.I訪問
Const I = 1
// j 不能夠在包外經過 test.j 訪問
cont j = 10