（二）Golang的變量

為什么需要變量：

• 變量是程序的基本組成單位
  不論是使用哪種高級(jí)程序語言編寫程序，變量都是其程序的基本組成單位，比如：下面代碼中sum、sub都是變量。

  func getVal(num1 int, num2 int) (int, int) {
  sum := num1 + mum2
  sub := num1 - num2
  return sum, sub
  }
  func main() {
  sum, sub := getVal(30, 30)
  fmt.Println("sum=", sum, "sub=", sub)
  sum2, _ := getVal(10, 30)
  fmt.Println("sum=", sum2)
  }

  變量的介紹：

• 變量的概念
  變量相當(dāng)于內(nèi)存中一個(gè)數(shù)據(jù)存儲(chǔ)空間的表示，可以把變量看做是一個(gè)房間的門牌號(hào)，通過門牌號(hào)可以找到房間，同樣的道理，通過變量名可以訪問到變量（值）。
• 變量的使用步驟
  1）定義變量
  2）給變量賦值
  3）使用變量

  package main
  import "fmt"
  func main() {
  //定義變量
  var i int
  //給i賦值
  i = 10
  //使用變量
  fmt.Println("i=",i) 
  }
  D:\goproject\src\go_code\chapter02\demon01>go run main.go
  i= 10

  變量使用注意事項(xiàng)：

• 變量表示內(nèi)存中的一個(gè)存儲(chǔ)區(qū)域；
• 該區(qū)域有自己的名稱（變量名）和類型（數(shù)據(jù)類型）；
• Golang變量使用的三種方式：
  1）第一種，指定變量類型，定義后若不賦值，使用默認(rèn)值；

  package main
  import "fmt"
  func main() {
  //golang的變量使用方式
  //第一種：指定變量類型，定義后若不賦值，使用默認(rèn)值
  //init的默認(rèn)值是0
  var i int
  fmt.Println("i=", i)
  }
  D:\goproject\src\go_code\chapter02\demon02>go run main.go
  i= 0

  2）第二種，根據(jù)值自行判斷變量類型（類型引導(dǎo)）

  package main
  import "fmt"
  func main() {   
  //第二種：根據(jù)值自行判斷變量類型（類型推導(dǎo)）
  var num = 10.11
  fmt.Println("num=", num)
  }
  D:\goproject\src\go_code\chapter02\demon02>go run main.go
  num= 10.11

  3）第三種，省略var定義變量并賦值

  package main
  import "fmt"
  func main() {
  //第三種：省略var,:= 的:不能省略，否則報(bào)錯(cuò)
  //下面的方式等價(jià)于 var name string   name = "tom"
  name := "tom"
  fmt.Println("name=", name)
  }
  D:\goproject\src\go_code\chapter02\demon02>go run main.go
  name= tom

• 多變量定義
  1）在編程中，有時(shí)我們需要一次性定義多個(gè)變量，Golang也提供了這樣的語法【在函數(shù)里面定義】

  package main
  import "fmt"
  func main() {
  //該案例演示Golang如何一次性定義多個(gè)變量
  var a1, a2, a3 int
  fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)
  
  //一次性定義多個(gè)變量的方式二
  var b1, b2, b3 = 100, "tom", 888
  fmt.Println("b1=", b1,"b2=", b2,"b3=", b3)
  
  //一次性定義多個(gè)變量的方式三，同樣可以使用類型推導(dǎo)
  c1, name, c3 := 200, "mary", 999
  fmt.Println("c1=", c1,"name=", name,"c3=", c3)
  }
  D:\goproject\src\go_code\chapter02\demon03>go run main.go
  a1= 0 a2= 0 a3= 0
  b1= 100 b2= tom b3= 888
  c1= 200 name= mary c3= 999

  2）一次性定義全局變量【在go中函數(shù)外部定義變量就是全局變量】

  package main
  import "fmt"
  //定義全局變量
  var n1 = 100
  var n2 = 200
  var name = "jack"
  //上面的定義方式，也可以改成一次性定義
  var (
  n3 = 300
  n4 = 400
  name2 = "zhangsan"
  )
  func main() {
  fmt.Println("n1=", n1,"n2=", n2,"name=", name)
  fmt.Println("n3=", n3,"n4=", n4,"name2=", name2)
  }
  D:\goproject\src\go_code\chapter02\demon03>go run var.go
  n1= 100 n2= 200 name= jack
  n3= 300 n4= 400 name2= zhangsan

• 該區(qū)域的數(shù)據(jù)值可以在同一類型范圍內(nèi)不斷變化

  package main
  import "fmt"
  func main() {
  //該區(qū)域的數(shù)據(jù)值可以在同一類型范圍內(nèi)不斷變化
  var i int = 10
  i = 30
  i = 50
  fmt.Println("i=", i)
  }
  D:\goproject\src\go_code\chapter02\demon03>go run var02.go
  i= 50

• 變量在同一個(gè)作用域（在一個(gè)函數(shù)或者代碼塊）內(nèi)不能重名；
• 變量的三要素
  變量=變量名+值+數(shù)據(jù)類型
• Golang的變量如果沒有賦初值，編譯器會(huì)使用默認(rèn)值，比如，int默認(rèn)值為0；string默認(rèn)值為空串；小數(shù)默認(rèn)值為0。

• 程序中+號(hào)的使用
  1）當(dāng)左右兩邊都是數(shù)值型時(shí)，則做加法運(yùn)算；
  2）當(dāng)左右兩邊都是字符串時(shí)，則做字符串拼接；

  package main
  import "fmt"
  //演示golang中+號(hào)的使用
  func main() {
  var i = 1
  var j = 2
  var r = i + j //做加法運(yùn)算
  fmt.Println("r=", r)
  
  var str1 = "hello"
  var str2 = "world"
  var res = str1 + str2 //做拼接操作
  fmt.Println("res=", res)
  }
  D:\goproject\src\go_code\chapter02\demon04>go run main.go
  r= 3
  res= helloworld

  數(shù)據(jù)類型的基本介紹：

  每一種數(shù)據(jù)都定義了明確的數(shù)據(jù)類型，在內(nèi)存中分配了不同大小的內(nèi)存空間。
  

  整數(shù)類型：

• 基本介紹
  簡單的說，就是用于存放整數(shù)值的，比如0，-1,2345等等。
• 整型的類型
  
  
  
• 整數(shù)的使用細(xì)節(jié)
  1）Golang各整數(shù)類型分：有符合和無符號(hào)，int uint的大小和系統(tǒng)有關(guān)；
  2）Golang的整數(shù)默認(rèn)聲明為int型；

  package main
  import(
  "fmt"
  )
  func main() {
  var n1 = 100
  //%T表示內(nèi)容的數(shù)據(jù)類型
  fmt.Printf("n1 的類型是 %T\n", n1)
  }

  D:\gocode\goproject02\main01>go run main.go
  n1 的類型是 int

  3）如何在程序查看某個(gè)變量的字節(jié)大小和數(shù)據(jù)類型

  package main
  import(
  "fmt"
  "unsafe" //前提引入unsafe函數(shù)
  )
  func main() {
  var n1 = 100
  //%T表示內(nèi)容的數(shù)據(jù)類型
  fmt.Printf("n1 的類型是 %T\n", n1)
  //如何在程序查看某個(gè)變量的占用字節(jié)大小和數(shù)據(jù)類型
  var n2 int64 = 10
  //unsafe.Sizeof(n2) 是unsafe包的一個(gè)函數(shù)，可以返回n2變量占用的字節(jié)數(shù)
  fmt.Printf("n2 的數(shù)據(jù)類型是 %T\nn2占用的字節(jié)大小是 %d", n2, unsafe.Sizeof(n2))
  }

  D:\gocode\goproject02\main01>go run main.go
  n1 的類型是 int
  n2 的數(shù)據(jù)類型是 int64
  n2占用的字節(jié)大小是 8

  4）Golang程序中整型變量在使用時(shí)，遵守保小不保大的原則，即：在保證程序正確運(yùn)行下，盡量使用占用空間小的數(shù)據(jù)類型。
  5）bit：計(jì)算機(jī)中的最小存儲(chǔ)單位；byte：計(jì)算機(jī)中基本存儲(chǔ)單元；1byte=8bit

  小數(shù)類型/浮點(diǎn)型：

• 基本介紹
  小數(shù)類型就是用來存放小數(shù)的，比如：1.2 0.12-1.94

  package main
  import(
  "fmt"
  )
  //演示golang中小數(shù)類型使用
  func main() {
  var price float32 = 87.23
  fmt.Println("price", price)
  }

  D:\gocode\goproject02\main02>go run main.go
  price 87.23

• 小數(shù)類型分類
  
  對上圖的說明：
  1）浮點(diǎn)數(shù)=符號(hào)位+指數(shù)位+尾數(shù)位；說明浮點(diǎn)數(shù)都是有符號(hào)的。
  2）尾數(shù)部分可能會(huì)丟失，造成精度損失，如：-123.0000901
  //尾數(shù)部分可能會(huì)丟失，造成精度損失

  var num3 float32 = -123.00000901
  var num4 float64 = -123.00000901
  fmt.Println("num3=", num3,"num4=", num4)

  D:\goproject\src\go_code\chapter02\floatdemo06>go run main.go
  num3= -123.00001 num4= -123.00000901

  說明：float64 的精度比float32 的要準(zhǔn)確。

• 浮點(diǎn)型使用細(xì)節(jié)
  1）Golang浮點(diǎn)類型有固定的范圍和字段長度，不受具體OS（操作系統(tǒng)）的影響；
  2）Golang的浮點(diǎn)類型默認(rèn)為float64類型；

  //Golang的浮點(diǎn)類型默認(rèn)聲明為float64類型
  var a = 1.1
  fmt.Printf("a的數(shù)據(jù)類型為 %T \n", a)

  D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
  a的數(shù)據(jù)類型為 float64

  3）浮點(diǎn)型常量有兩種表示形式；
  ① 十進(jìn)制數(shù)形式：如 5.12 .512（必須有小數(shù)點(diǎn)）

  //十進(jìn)制數(shù)形式
  b := 5.12
  c := .123
  fmt.Println("b=", b, "c=", c)

  D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
  b= 5.12 c= 0.123

  ② 科學(xué)計(jì)數(shù)法形式：如 5.1234e2 ==== 5.12 * 10的2次方； 5.12E-2 ==== 5.12/10的2次方

  //科學(xué)計(jì)數(shù)法形式
  d := 5.1234e2 // 5.1234 * 10的2次方
  e := 5.1234E2 // 5.1234 * 10的2次方
  f := 5.1234E-2 // 5.1234 / 10的2次方
  fmt.Println("d=", d, "e=", e, "f=",f)

  D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
  d= 512.34 e= 512.34 f= 0.051234

  4）Golang浮點(diǎn)型只有這兩種類型，float32 和 float64，float64 比 float32 更精確。

  字符類型：

• 基本介紹
  Golang中沒有專門的字符類型，如果要存儲(chǔ)單個(gè)字符（字母），一般使用byte來保存；
  字符串就是一串固定長度的字符連接起來的字符序列。Go的字符串是由單個(gè)字節(jié)連接起來的；也就是說對于傳統(tǒng)的字符串是由字符組成的，而Go的字符串不同，它是由字節(jié)組成的。

• 案例演示

  package main
  import(
  "fmt"
  )
  //演示golang中字符類型使用
  func main() {
  var c1 byte = 'a'
  var c2 byte = '0' //字符的0
  //當(dāng)直接輸出byte值，就是輸出了對應(yīng)字符的碼值
  fmt.Println("c1=", c1)
  fmt.Println("c2=", c2)
  
  //如果希望輸出對應(yīng)字符，需要格式化輸出
  fmt.Printf("c1=%c c2=%c\n", c1, c2)
  
  //如果輸出的碼值高于byte（0-255）的范圍，輸出就會(huì)溢出,可以用int
  var c3 int = '北'
  fmt.Printf("c3=%c c3對應(yīng)碼值=%d", c3, c3)
  }

  D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
  c1= 97
  c2= 48
  c1=a c2=0
  c3=北 c3對應(yīng)碼值=21271

  對上面代碼說明：
  1）如果保存的字符在ASCII表，比如【0-1，a-z，A-Z...】直接可以保存到byte；
  2）如果保存的字符對應(yīng)碼值大于255，這時(shí)可以考慮使用int類型保存；比如中文；
  3）如果需要按照字符的方式輸出，這時(shí)需要格式化輸出，即 fmt.Printf("%c", c1)。

• 字符類型使用細(xì)節(jié)
  1）字符常量是用單引號(hào)（‘’）括起來的單個(gè)字符；如：var c1 byte = 'a' 里面的“a”
  2）Go中允許使用轉(zhuǎn)義字符“\”來將其后的字符轉(zhuǎn)變?yōu)樘厥庾址统Ａ?；如：var c2 char = '\n' ============='\n'表示換行符
  3）Go語言的字符使用UTF-8編碼，查詢字符對應(yīng)的utf8碼值=====直接搜索”utf8 編碼“；UTF-8 編碼包含 ASCII 編碼；
  英文字母——1個(gè)字節(jié)；漢字——3個(gè)字節(jié)
  4）在Go中，字符的本質(zhì)是一個(gè)整數(shù)，直接輸出時(shí)，是該字符對應(yīng)的UTF-8碼值；
  5）可以直接給某個(gè)變量賦一個(gè)數(shù)字，然后按格式化輸出時(shí)%c，會(huì)輸出該數(shù)字對應(yīng)的unicode字符；

  //可以直接給某個(gè)變量賦一個(gè)數(shù)字，然后按格式化輸出時(shí)%c，會(huì)輸出該數(shù)字對應(yīng)的unicode字符；
  var c4 int = 22269  //22269 -> '國'
  fmt.Printf("c4=%c\n", c4)

  D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
  c4=國

  6）字符類型是可以進(jìn)行運(yùn)算的，相當(dāng)于一個(gè)整數(shù)，因?yàn)樗加袑?yīng)的Unicode碼；

  //字符類型是可以進(jìn)行運(yùn)算的，相當(dāng)于一個(gè)整數(shù)，運(yùn)算時(shí)按照碼值運(yùn)行；
  var n1 = 10 + 'a' // 相當(dāng)于 10 + 97 = 107
  fmt.Println("n1=", n1)

  D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
  n1= 107

• 字符類型的本質(zhì)探討
  1）字符型存儲(chǔ)到計(jì)算機(jī)中，需要將字符對應(yīng)的碼值（整數(shù)）找出來；
  存儲(chǔ)：字符 ——> 對應(yīng)碼值 ——> 二進(jìn)制 ——> 存儲(chǔ)
  讀?。憾M(jìn)制 ——> 碼值 ——> 字符 ——> 讀取
  2）字符和碼值的對應(yīng)關(guān)系是通過字符編碼表決定的（規(guī)定好的）；
  3）Go語言的編碼統(tǒng)一使用UTF-8，非常的方便、統(tǒng)一，不會(huì)出現(xiàn)編碼亂碼的問題。

  布爾類型：

• 基本介紹
  1）布爾類型也叫bool類型，bool類型數(shù)據(jù)只允許取值true或者false；
  2）bool類型占1個(gè)字節(jié)；
  3）bool類型適于邏輯運(yùn)算，一般用于程序流程控制【if條件控制語句和for循環(huán)控制語句】
  4）不可以用0或非0的整數(shù)替代false和true。
• 案例演示

  package main
  import(
  "fmt"
  "unsafe"
  ) 
  //演示golang中bool類型使用
  func main() {
  var b = false
  fmt.Println("b=", b)
  //注意事項(xiàng)
  //1. bool類型占用存儲(chǔ)空間為1個(gè)字節(jié)
  fmt.Println("b 的占用字節(jié) =", unsafe.Sizeof(b))
  //2. bool類型只能取true或者false
  }

  D:\goproject\src\go_code\chapter02\booldemo08>go run main.go
  b= false
  b 的占用字節(jié) = 1

  字符串類型：

• 基本介紹
  字符串就是一串固定長度的字符連接起來的字符序列；Go的字符串是由單個(gè)字節(jié)連接起來的；Go語言的字符串的字節(jié)使用UTF-8編碼標(biāo)識(shí)Unicode文本。
• 案例演示

  //演示golang中string類型使用
  func main() {
  //string的基本使用
  var address string = "北京長城 112 helloworld！"
  fmt.Println(address)
  }

  D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
  北京長城 112 helloworld！

• string使用細(xì)節(jié)和注意事項(xiàng)
  1）字符串一旦賦值，字符串就不能修改了：在Go中，字符串是不可變的；
  2）字符串的兩種表示形式
  ①雙引號(hào)，會(huì)識(shí)別轉(zhuǎn)義字符；

  //使用雙引號(hào)，支持轉(zhuǎn)義字符
  str1 := "abc\nbcd"
  fmt.Println(str1)

  D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
  abc
  bcd

  ②反引號(hào)，以字符串的原生形式輸出，包括換行和特殊字符，可以輸出源代碼等效果。

  //使用反引號(hào)，以字符串的原生形式輸出，適用于輸出源碼
  str2 := `
  package main
  import(
      "fmt"
  )
  `
  fmt.Println(str2)

  D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
      package main
      import(
              "fmt"
      )

  3）字符串拼接方式

  //字符串拼接方式
  var str3 = "hello" + "world!"
  fmt.Println(str3)

  D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
  helloworld!

  4）當(dāng)拼接字符串太長時(shí)，需要使用到多行字符串，可以如下處理【注意，將+號(hào)留在上一行】

  //當(dāng)拼接的字符串很長時(shí)，可以分行寫，注意將+保留在上一行
  var str4 = "hello" + "world!" + "world!" + "world!" + 
  "hello" + "world!" + "world!" + "world!" + "hello" + 
  "world!" + "world!" + "world!" + "hello" + "world!" + 
  "world!" + "world!"
  fmt.Println(str4)

  D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
  helloworld!world!world!helloworld!world!world!helloworld!world!world!helloworld!
  world!world!

  基本數(shù)據(jù)類型的默認(rèn)值

• 基本介紹
  在go中，數(shù)據(jù)類系都有一個(gè)默認(rèn)值，當(dāng)程序員沒有賦值時(shí)，就會(huì)保留默認(rèn)值；在go中，默認(rèn)值又叫零值。
• 基本數(shù)據(jù)類型的默認(rèn)值如下：
  
• 案例

  package main
  import(
  "fmt"
  )
  //基本數(shù)據(jù)類型的默認(rèn)值
  func main() {
  var a int  // =0
  var b float32   // =0
  var c float64   // =0
  var d bool  // false
  var name string  // ""
  //這里的%v 表示按照變量的值輸出
  fmt.Printf("a=%d,b=%v,c=%v,d=%v,name=%v", a,b,c,d,name)
  }

  D:\goproject\src\go_code\chapter02\defaultdemo10>go run main.go
  a=0,b=0,c=0,d=false,name=

  基本數(shù)據(jù)類型的相互轉(zhuǎn)換

• 基本介紹
  Golang和 Java/c 不同，Go在不同類型的變量之間賦值時(shí)需要顯示轉(zhuǎn)換；也就是說Golang中數(shù)據(jù)類型不能自動(dòng)轉(zhuǎn)換。
• 基本語法
  表達(dá)式 T(v) 將值 v 轉(zhuǎn)換為類型 T。
  T：就是數(shù)據(jù)類型，比如 int32，int64，float32 等等；
  v：就是需要轉(zhuǎn)換的變量。
• 案例演示

  package main
  import(
  "fmt"
  )
  //演示golang中基本數(shù)據(jù)類型的轉(zhuǎn)換
  func main() {
  var i int32 = 100
  //將 i => float32
  var n1 float32 = float32(i)
  //低精度 => 高精度
  var n2 int64 = int64(i)
  fmt.Printf("i=%v n1=%v n2=%v", i,n1,n2)
  }

  D:\goproject\src\go_code\chapter02\transtype11>go run main.go
  i=100 n1=100 n2=100

• 基本數(shù)據(jù)類型相互轉(zhuǎn)換的注意事項(xiàng)
  1）Go語言中，數(shù)據(jù)類型的轉(zhuǎn)換可以是從 表示范圍小---->表示范圍大，也可以 范圍大----->范圍??；
  2）被轉(zhuǎn)換的是變量存儲(chǔ)的數(shù)據(jù)（即值），變量本身的數(shù)據(jù)類型并沒有變化！

  package main
  import(
  "fmt"
  )
  //演示golang中基本數(shù)據(jù)類型的轉(zhuǎn)換
  func main() {
  var i int32 = 100
  //將 i => float32
  var n1 float32 = float32(i)
  //低精度 => 高精度
  var n2 int64 = int64(i)
  fmt.Printf("i=%v n1=%v n2=%v\n", i,n1,n2)
  //被轉(zhuǎn)換的是變量存儲(chǔ)的數(shù)據(jù)（即值），變量本身的數(shù)據(jù)類型并沒有變化?。?！
  fmt.Printf("i type is %T", i)
  }

  D:\goproject\src\go_code\chapter02\transtype11>go run main.go
  i=100 n1=100 n2=100
  i type is int32

  3）在轉(zhuǎn)換中，比如將 int64 轉(zhuǎn)換成 int8（-128----127），編譯時(shí)不會(huì)出錯(cuò)，只是轉(zhuǎn)換的結(jié)果是按溢出處理，和我們希望的結(jié)果不一樣，因此在轉(zhuǎn)換時(shí)，需要考慮范圍。

  //在轉(zhuǎn)換中，比如將 int64 轉(zhuǎn)換成 int8（-128----127），編譯時(shí)不會(huì)出錯(cuò);
  //只是轉(zhuǎn)換的結(jié)果是按溢出處理，和我們希望的結(jié)果不一樣;因此在轉(zhuǎn)換時(shí)，需要考慮范圍。
  var num1 int64 = 999999
  var num2 int8 = int8(num1)
  fmt.Println("num2=", num2)

  D:\goproject\src\go_code\chapter02\transtype11>go run main.go
  num2= 63

• 課堂練習(xí)
  1）以下代碼編譯不能通過和解決方案

  package main
  import(
  "fmt"
  )
  func main() {
  var n1 int32 = 12
  var n2 int64
  var n3 int8
  
  //不能編譯通過，因?yàn)闆]有進(jìn)行數(shù)據(jù)類型轉(zhuǎn)換
  n2 = n1 + 20    //int32 ----> int64 錯(cuò)誤
  n3 = n1 + 20    //int32 ----> int8 錯(cuò)誤
  
  //以下是解決方案
  n2 = int64(n1) + 20
  n3 = int8(n1) + 20
  fmt.Println("n2=", n2, "n3=", n3)
  }

  2）如果相加的值大于本身的數(shù)據(jù)類型范圍，則編譯不通過

  func main() {
  //如果相加的值大于本身的數(shù)據(jù)類型范圍，則編譯不通過
  var n4 int32 = 12
  var n5 int8
  var n6 int8
  n5 = int8(n4) + 127 //【編譯通過，但是結(jié)果按溢出處理】
  n6 = int8(n4) + 128 //【編譯不通過，因?yàn)?28超出int8數(shù)據(jù)類型的范圍】
  fmt.Println("n5=", n5)
  }   

  基本數(shù)據(jù)類型和string的轉(zhuǎn)換

• 基本介紹
  在程序開發(fā)中，經(jīng)常將基本數(shù)據(jù)類型轉(zhuǎn)換成string，或者將string轉(zhuǎn)換成基本數(shù)據(jù)類型。

• 基本數(shù)據(jù)類型轉(zhuǎn)換string類型
  1）方式一：fmt.Sprintf("%參數(shù)"， 表達(dá)式)
  函數(shù)介紹：

  func Sprintf
  func Sprintf(format string, a ...interface{}) string
  Sprintf根據(jù)format參數(shù)生成格式化的字符串并返回該字符串。

  參數(shù)需要和表達(dá)式的數(shù)據(jù)類型相匹配；fmt.Sprintf().. 會(huì)返回轉(zhuǎn)換后的字符串。
  案例演示：

  package main
  import(
  "fmt"
  )
  //演示golang中基本數(shù)據(jù)類型轉(zhuǎn)換string類型
  func main() {
  var num1 int = 99
  var num2 float64 = 23.456
  var b bool = true
  var myChar byte = 'h'
  var str string  //空的string
  
  //使用第一種方式 fmt.Sprintf 來轉(zhuǎn)換
  str = fmt.Sprintf("%d", num1)
  fmt.Printf("str type %T; str=%q\n", str, str)
  
  str = fmt.Sprintf("%f", num2)
  fmt.Printf("str type %T; str=%q\n", str, str)
  
  str = fmt.Sprintf("%t", b)
  fmt.Printf("str type %T; str=%q\n", str, str)
  
  str = fmt.Sprintf("%c", myChar)
  fmt.Printf("str type %T; str=%q", str, str)
  }

  D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
  str type string; str="99"
  str type string; str="23.456000"
  str type string; str="true"
  str type string; str="h"

  2）方式二：使用strconv包的函數(shù)
  函數(shù)介紹：

  func FormatBool(b bool) string
  func FormatInt(i int64, base int) string
  func FormatUint(i uint64, base int) string
  func FormatFloat(f float64, fmt byte, prec, bitSize int) string

  案例說明：

  package main
  import(
  "fmt"
  "strconv"
  )
  func main() {
  //使用第二種方式 strconv 函數(shù)來轉(zhuǎn)換
  var num3 int = 99
  var num4 float64 = 23.456
  var b2 bool = true
  
  str = strconv.FormatInt(int64(num3), 10)
  fmt.Printf("str type %T; str=%q\n", str, str)
  
  //說明:'f'格式；10：表示小數(shù)位保留10位；64：表示這個(gè)小數(shù)是float64；
  str = strconv.FormatFloat(num4, 'f', 10, 64)
  fmt.Printf("str type %T; str=%q\n", str, str)
  
  str = strconv.FormatBool(b2)
  fmt.Printf("str type %T; str=%q", str, str)
  
  //strconv包中有一個(gè)函數(shù) Itoa，可以將int類型轉(zhuǎn)換成string；
  var num5 int = 3456
  str = strconv.Itoa(num5)
  fmt.Printf("str type %T; str=%q", str, str)
  }

  D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
  str type string; str="99"
  str type string; str="23.4560000000"
  str type string; str="true"
  str type string; str="3456"

• string類型轉(zhuǎn)換基本數(shù)據(jù)類型
  使用strconv包的函數(shù)，函數(shù)介紹：

  func ParseBool(str string) (value bool, err error)
  func ParseInt(s string, base int, bitSize int) (i int64, err error)
  func ParseUint(s string, base int, bitSize int) (n uint64, err error)
  func ParseFloat(s string, bitSize int) (f float64, err error)

  案例演示：

  package main
  import(
  "fmt"
  "strconv"
  )
  //演示golang中string類型轉(zhuǎn)換基本數(shù)據(jù)類型
  func main(){
  var str string = "true"
  var a bool
  //strconv.ParseBool(str) 函數(shù)會(huì)返回兩個(gè)值（value bool，err error）
  //因?yàn)橹幌氆@取到value bool，使用_忽略第二個(gè)值；
  a, _ = strconv.ParseBool(str)
  fmt.Printf("a type %T; a=%v\n", a, a)
  
  var str2 string = "1234566"
  var b int64
  b, _ = strconv.ParseInt(str2, 10, 64)
  fmt.Printf("b type %T; b=%v\n", b, b)
  
  var str3 string = "124.324"
  var c float64
  c, _ = strconv.ParseFloat(str3, 64)
  fmt.Printf("c type %T; c=%v", c, c)
  }

  D:\goproject\src\go_code\chapter02\string2basictype13>go run main.go
  a type bool; a=true
  b type int64; b=1234566
  c type float64; c=124.324

  說明一下，由于strconv函數(shù)返回的是int64或float64，如果希望得到int32，float64等，如下處理：

  var d int64
  d = int32(d)

  指針：

• 基本介紹
  1）基本數(shù)據(jù)類型，變量存的就是值，也叫值類型；變量存值都對應(yīng)一個(gè)地址。
  2）獲取變量的地址，用 &，比如：var num int，獲取num的地址：&num
  分析一下基本數(shù)據(jù)類型在內(nèi)存的布局:
  
  3）指針類型，指針變量存的是一個(gè)地址，這個(gè)地址指向的空間存的才是值。比如：var ptr int = &num
  舉例說明：指針在內(nèi)存中的布局
  
  4）獲取指針類型所指向的值，使用星號(hào)，*ptr

  package main
  import(
  "fmt"
  )
  //演示golang中指針類型
  func main() {
  //基本數(shù)據(jù)類型在內(nèi)存布局
  var i int = 10
  //i的地址是什么，&i
  fmt.Println("i的地址=", &i)
  
  //ptr是一個(gè)指針變量；ptr的類型是*int；
  //ptr本身的值為&i（變量i對應(yīng)的地址）;
  var ptr *int = &i
  fmt.Printf("ptr=%v\n", ptr)
  fmt.Printf("ptr的地址=%v\n", &ptr)
  
  //獲取指針類型所指向的值，使用 *
  fmt.Printf("ptr指向的值=%v", *ptr)
  }

  D:\gocode\goproject02\pointerdemo>go run main.go
  i的地址= 0xc042050058
  ptr=0xc042050058
  ptr的地址=0xc04206e020
  ptr指向的值=10

• 案例演示
  1）寫一個(gè)程序，獲取一個(gè)int變量num的地址，并顯示到終端；
  2）將num的地址賦給指針ptr，并通過ptr去修改num的值。

  package main
  import(
  "fmt"
  )
  func main() {
  var num int = 100
  fmt.Println("num的地址=", &num)
  
  var ptr *int = &num
  fmt.Printf("ptr=%v\n", ptr)
  *ptr = 200
  fmt.Println("num=", num)
  }

  D:\gocode\goproject02\pointerdemo>go run main02.go
  num的地址= 0xc042050058
  ptr=0xc042050058
  num= 200

• 指針課堂練習(xí)
  
• 指針的使用細(xì)節(jié)
  1）值類型，都有對應(yīng)的指針類型，形式為*數(shù)據(jù)類型，比如int對應(yīng)的指針就是 *int，float32對應(yīng)的指針就是 *float32，以此類推。
  2）值類型包括：基本數(shù)據(jù)類型 int系列，float系列，bool，string，數(shù)組和結(jié)構(gòu)體struct。

  值類型和引用類型

• 值類型和引用類型的說明
  1）值類型：基本數(shù)據(jù)類型 int系列，float系列，bool，string，數(shù)組和結(jié)構(gòu)體struct；
  2）引用類型：指針，slice切片，map，管道chan，interface等都是引用類型。
• 值類型和引用類型的使用特點(diǎn)
  1）值類型：變量直接存儲(chǔ)值，內(nèi)存通常在棧中分配；
  示意圖：
  
  2）引用類型：變量存儲(chǔ)的是一個(gè)地址，這個(gè)地址對應(yīng)的空間才是真正存儲(chǔ)數(shù)據(jù)（值），內(nèi)存通過在堆上分配，當(dāng)沒有任何變量引用這個(gè)地址時(shí)，該地址對應(yīng)的數(shù)據(jù)空間就成為一個(gè)垃圾，由GC來回收。
  示意圖：
  
  3）內(nèi)存的桟區(qū)和堆區(qū)示意圖
  

  標(biāo)識(shí)符的命名規(guī)范

• 標(biāo)識(shí)符概念
  1）Golang對各種變量、方法、函數(shù)等命名時(shí)使用的字符序列稱為標(biāo)識(shí)符；
  2）凡是自己可以起名字的地方都叫標(biāo)識(shí)符。
• 標(biāo)識(shí)符的命名規(guī)則
  1）由26個(gè)英文字母大小寫，0-9，_組成；
  2）數(shù)字不可以開頭；var num int //ok; var 3num int //error
  3）Golang中嚴(yán)格區(qū)分大小寫；
  var num int
  var Num int
  說明：在golang中，num和Num是兩個(gè)不同的變量。
  4）標(biāo)識(shí)符不能包含空格；
  
  5）下劃線“_”本身在Go中是一個(gè)特殊的標(biāo)識(shí)符，稱為空標(biāo)識(shí)符。可以代表任何其他的標(biāo)識(shí)符，但是對應(yīng)的值會(huì)被忽略（比如：忽略某個(gè)返回值）。所以僅能被作為占位符使用，不能作為標(biāo)識(shí)符使用。
  6）不能以系統(tǒng)保留關(guān)鍵字作為標(biāo)識(shí)符（一共有25個(gè)），比如：break，if 等等。
• 標(biāo)識(shí)符命名注意事項(xiàng)
  1）包名：保持package的名字和目錄保持一致，盡量采取有意義的包名，簡短，有意義，不要和標(biāo)準(zhǔn)庫沖突 fmt
  2）變量名、函數(shù)名、常量名：采用駝峰法
  舉例：var stuName string = "tom" 形式：xxxYyyyZzzz...
  3）如果變量名、函數(shù)名、常量名首字母大寫，則可以被其他的包訪問；如果首字母小寫，則只能在本包中使用。
  
• 系統(tǒng)保留關(guān)鍵字
  在go中，為了簡化代碼編譯過程中對代碼的解析，其定義的保留關(guān)鍵字只有25個(gè)。
  
• 系統(tǒng)的預(yù)定義標(biāo)識(shí)符
  除了保留關(guān)鍵字外，go還提供了36個(gè)預(yù)訂的標(biāo)識(shí)符，其包括基礎(chǔ)數(shù)據(jù)類型和系統(tǒng)內(nèi)嵌函數(shù)。