（二）Golang的變量

為什么需要變量：

  • 變量是程序的基本組成單位
    不論是使用哪種高級程序語言編寫程序，變量都是其程序的基本組成單位，比如：下面代碼中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)
}

    變量的介紹：

  • 變量的概念
    變量相當于內存中一個數(shù)據(jù)存儲空間的表示，可以把變量看做是一個房間的門牌號，通過門牌號可以找到房間，同樣的道理，通過變量名可以訪問到變量（值）。
  • 變量的使用步驟
    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

    變量使用注意事項：

  • 變量表示內存中的一個存儲區(qū)域；
  • 該區(qū)域有自己的名稱（變量名）和類型（數(shù)據(jù)類型）；
  • Golang變量使用的三種方式：
    1）第一種，指定變量類型，定義后若不賦值，使用默認值； 
    package main
import "fmt"
func main() {
//golang的變量使用方式
//第一種：指定變量類型，定義后若不賦值，使用默認值
//init的默認值是0
var i int
fmt.Println("i=", i)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
i= 0

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

    成都創(chuàng)新互聯(lián)公司專注于企業(yè)成都全網(wǎng)營銷推廣、網(wǎng)站重做改版、樂都網(wǎng)站定制設計、自適應品牌網(wǎng)站建設、成都h5網(wǎng)站建設、商城網(wǎng)站建設、集團公司官網(wǎng)建設、外貿網(wǎng)站建設、高端網(wǎng)站制作、響應式網(wǎng)頁設計等建站業(yè)務，價格優(yōu)惠性價比高，為樂都等各大城市提供網(wǎng)站開發(fā)制作服務。

    package main
import "fmt"
func main() {   
//第二種：根據(jù)值自行判斷變量類型（類型推導）
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,:= 的:不能省略，否則報錯
//下面的方式等價于 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）在編程中，有時我們需要一次性定義多個變量，Golang也提供了這樣的語法【在函數(shù)里面定義】

    package main
import "fmt"
func main() {
//該案例演示Golang如何一次性定義多個變量
var a1, a2, a3 int
fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)

//一次性定義多個變量的方式二
var b1, b2, b3 = 100, "tom", 888
fmt.Println("b1=", b1,"b2=", b2,"b3=", b3)

//一次性定義多個變量的方式三，同樣可以使用類型推導
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ù)值可以在同一類型范圍內不斷變化 
    package main
import "fmt"
func main() {
//該區(qū)域的數(shù)據(jù)值可以在同一類型范圍內不斷變化
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
  • 變量在同一個作用域（在一個函數(shù)或者代碼塊）內不能重名；
  • 變量的三要素
    變量=變量名+值+數(shù)據(jù)類型
  • Golang的變量如果沒有賦初值，編譯器會使用默認值，比如，int默認值為0；string默認值為空串；小數(shù)默認值為0。

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

    package main
import "fmt"
//演示golang中+號的使用
func main() {
var i = 1
var j = 2
var r = i + j //做加法運算
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ù)類型，在內存中分配了不同大小的內存空間。
    （二）Golang的變量

    整數(shù)類型：

  • 基本介紹
    簡單的說，就是用于存放整數(shù)值的，比如0，-1,2345等等。
  • 整型的類型
    （二）Golang的變量
    （二）Golang的變量
    （二）Golang的變量
  • 整數(shù)的使用細節(jié)
    1）Golang各整數(shù)類型分：有符合和無符號，int uint的大小和系統(tǒng)有關；
    2）Golang的整數(shù)默認聲明為int型； 
    package main
import(
"fmt"
)
func main() {
var n1 = 100
//%T表示內容的數(shù)據(jù)類型
fmt.Printf("n1 的類型是 %T\n", n1)
}
    D:\gocode\goproject02\main01>go run main.go
n1 的類型是 int

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

    package main
import(
"fmt"
"unsafe" //前提引入unsafe函數(shù)
)
func main() {
var n1 = 100
//%T表示內容的數(shù)據(jù)類型
fmt.Printf("n1 的類型是 %T\n", n1)
//如何在程序查看某個變量的占用字節(jié)大小和數(shù)據(jù)類型
var n2 int64 = 10
//unsafe.Sizeof(n2) 是unsafe包的一個函數(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ù)據(jù)類型。
    5）bit：計算機中的最小存儲單位；byte：計算機中基本存儲單元；1byte=8bit

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

  • 基本介紹
    小數(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ù)類型分類
    （二）Golang的變量
    對上圖的說明：
    1）浮點數(shù)=符號位+指數(shù)位+尾數(shù)位；說明浮點數(shù)都是有符號的。
    2）尾數(shù)部分可能會丟失，造成精度損失，如：-123.0000901
    //尾數(shù)部分可能會丟失，造成精度損失 
    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 的要準確。

  • 浮點型使用細節(jié)
    1）Golang浮點類型有固定的范圍和字段長度，不受具體OS（操作系統(tǒng)）的影響；
    2）Golang的浮點類型默認為float64類型； 
    //Golang的浮點類型默認聲明為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）浮點型常量有兩種表示形式；
    ① 十進制數(shù)形式：如 5.12 .512（必須有小數(shù)點）

    //十進制數(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

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

    //科學計數(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浮點型只有這兩種類型，float32 和 float64，float64 比 float32 更精確。

    字符類型：

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

  • 案例演示

    package main
import(
"fmt"
)
//演示golang中字符類型使用
func main() {
var c1 byte = 'a'
var c2 byte = '0' //字符的0
//當直接輸出byte值，就是輸出了對應字符的碼值
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)

//如果希望輸出對應字符，需要格式化輸出
fmt.Printf("c1=%c c2=%c\n", c1, c2)

//如果輸出的碼值高于byte（0-255）的范圍，輸出就會溢出,可以用int
var c3 int = '北'
fmt.Printf("c3=%c c3對應碼值=%d", c3, c3)
}
    D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
c1= 97
c2= 48
c1=a c2=0
c3=北 c3對應碼值=21271

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

  • 字符類型使用細節(jié)
    1）字符常量是用單引號（‘’）括起來的單個字符；如：var c1 byte = 'a' 里面的“a”
    2）Go中允許使用轉義字符“\”來將其后的字符轉變?yōu)樘厥庾址统Ａ?；如：var c2 char = '\n' ============='\n'表示換行符
    3）Go語言的字符使用UTF-8編碼，查詢字符對應的utf8碼值=====直接搜索”utf8 編碼“；UTF-8 編碼包含 ASCII 編碼；
    英文字母——1個字節(jié)；漢字——3個字節(jié)
    4）在Go中，字符的本質是一個整數(shù)，直接輸出時，是該字符對應的UTF-8碼值；
    5）可以直接給某個變量賦一個數(shù)字，然后按格式化輸出時%c，會輸出該數(shù)字對應的unicode字符； 
    //可以直接給某個變量賦一個數(shù)字，然后按格式化輸出時%c，會輸出該數(shù)字對應的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）字符類型是可以進行運算的，相當于一個整數(shù)，因為它都有對應的Unicode碼；

    //字符類型是可以進行運算的，相當于一個整數(shù)，運算時按照碼值運行；
var n1 = 10 + 'a' // 相當于 10 + 97 = 107
fmt.Println("n1=", n1)
    D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
n1= 107
  • 字符類型的本質探討
    1）字符型存儲到計算機中，需要將字符對應的碼值（整數(shù)）找出來；
    存儲：字符 ——> 對應碼值 ——> 二進制 ——> 存儲
    讀?。憾M制 ——> 碼值 ——> 字符 ——> 讀取
    2）字符和碼值的對應關系是通過字符編碼表決定的（規(guī)定好的）；
    3）Go語言的編碼統(tǒng)一使用UTF-8，非常的方便、統(tǒng)一，不會出現(xiàn)編碼亂碼的問題。

    布爾類型：

  • 基本介紹
    1）布爾類型也叫bool類型，bool類型數(shù)據(jù)只允許取值true或者false；
    2）bool類型占1個字節(jié)；
    3）bool類型適于邏輯運算，一般用于程序流程控制【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)
//注意事項
//1. bool類型占用存儲空間為1個字節(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的字符串是由單個字節(jié)連接起來的；Go語言的字符串的字節(jié)使用UTF-8編碼標識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使用細節(jié)和注意事項
    1）字符串一旦賦值，字符串就不能修改了：在Go中，字符串是不可變的；
    2）字符串的兩種表示形式
    ①雙引號，會識別轉義字符； 
    //使用雙引號，支持轉義字符
str1 := "abc\nbcd"
fmt.Println(str1)
    D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
abc
bcd

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

    //使用反引號，以字符串的原生形式輸出，適用于輸出源碼
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）當拼接字符串太長時，需要使用到多行字符串，可以如下處理【注意，將+號留在上一行】

    //當拼接的字符串很長時，可以分行寫，注意將+保留在上一行
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ù)類型的默認值

  • 基本介紹
    在go中，數(shù)據(jù)類系都有一個默認值，當程序員沒有賦值時，就會保留默認值；在go中，默認值又叫零值。
  • 基本數(shù)據(jù)類型的默認值如下：
    （二）Golang的變量
  • 案例 
    package main
import(
"fmt"
)
//基本數(shù)據(jù)類型的默認值
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ù)類型的相互轉換

  • 基本介紹
    Golang和 Java/c 不同，Go在不同類型的變量之間賦值時需要顯示轉換；也就是說Golang中數(shù)據(jù)類型不能自動轉換。
  • 基本語法
    表達式 T(v) 將值 v 轉換為類型 T。
    T：就是數(shù)據(jù)類型，比如 int32，int64，float32 等等；
    v：就是需要轉換的變量。
  • 案例演示 
    package main
import(
"fmt"
)
//演示golang中基本數(shù)據(jù)類型的轉換
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ù)類型相互轉換的注意事項
    1）Go語言中，數(shù)據(jù)類型的轉換可以是從 表示范圍小---->表示范圍大，也可以 范圍大----->范圍小；
    2）被轉換的是變量存儲的數(shù)據(jù)（即值），變量本身的數(shù)據(jù)類型并沒有變化！ 
    package main
import(
"fmt"
)
//演示golang中基本數(shù)據(jù)類型的轉換
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)
//被轉換的是變量存儲的數(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）在轉換中，比如將 int64 轉換成 int8（-128----127），編譯時不會出錯，只是轉換的結果是按溢出處理，和我們希望的結果不一樣，因此在轉換時，需要考慮范圍。

    //在轉換中，比如將 int64 轉換成 int8（-128----127），編譯時不會出錯;
//只是轉換的結果是按溢出處理，和我們希望的結果不一樣;因此在轉換時，需要考慮范圍。
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

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

    package main
import(
"fmt"
)
func main() {
var n1 int32 = 12
var n2 int64
var n3 int8

//不能編譯通過，因為沒有進行數(shù)據(jù)類型轉換
n2 = n1 + 20    //int32 ----> int64 錯誤
n3 = n1 + 20    //int32 ----> int8 錯誤

//以下是解決方案
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 //【編譯通過，但是結果按溢出處理】
n6 = int8(n4) + 128 //【編譯不通過，因為128超出int8數(shù)據(jù)類型的范圍】
fmt.Println("n5=", n5)
}

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

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

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

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

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

    package main
import(
"fmt"
)
//演示golang中基本數(shù)據(jù)類型轉換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 來轉換
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ù)來轉換
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：表示這個小數(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包中有一個函數(shù) Itoa，可以將int類型轉換成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類型轉換基本數(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類型轉換基本數(shù)據(jù)類型
func main(){
var str string = "true"
var a bool
//strconv.ParseBool(str) 函數(shù)會返回兩個值（value bool，err error）
//因為只想獲取到value bool，使用_忽略第二個值；
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ù)類型，變量存的就是值，也叫值類型；變量存值都對應一個地址。
    2）獲取變量的地址，用 &，比如：var num int，獲取num的地址：&num
    分析一下基本數(shù)據(jù)類型在內存的布局:
    （二）Golang的變量
    3）指針類型，指針變量存的是一個地址，這個地址指向的空間存的才是值。比如：var ptr int = &num
    舉例說明：指針在內存中的布局
    （二）Golang的變量
    4）獲取指針類型所指向的值，使用星號，*ptr

    package main
import(
"fmt"
)
//演示golang中指針類型
func main() {
//基本數(shù)據(jù)類型在內存布局
var i int = 10
//i的地址是什么，&i
fmt.Println("i的地址=", &i)

//ptr是一個指針變量；ptr的類型是*int；
//ptr本身的值為&i（變量i對應的地址）;
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）寫一個程序，獲取一個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
  • 指針課堂練習
    （二）Golang的變量
  • 指針的使用細節(jié)
    1）值類型，都有對應的指針類型，形式為*數(shù)據(jù)類型，比如int對應的指針就是 *int，float32對應的指針就是 *float32，以此類推。
    2）值類型包括：基本數(shù)據(jù)類型 int系列，float系列，bool，string，數(shù)組和結構體struct。

    值類型和引用類型

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

    標識符的命名規(guī)范

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

分享名稱：（二）Golang的變量
新聞來源：http://muchs.cn/article48/jiodhp.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站策劃、移動網(wǎng)站建設、網(wǎng)站設計公司、面包屑導航、做網(wǎng)站、Google

廣告

聲明：本網(wǎng)站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)

營銷型網(wǎng)站建設