（二）Golang的變量

時間  2019-12-20
標籤 golang 變量 欄目 Go 简体版
原文   原文鏈接

爲何須要變量：

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

    變量的介紹：

  • 變量的概念
    變量至關於內存中一個數據存儲空間的表示，能夠把變量看作是一個房間的門牌號，經過門牌號能夠找到房間，一樣的道理，經過變量名能夠訪問到變量（值）。
  • 變量的使用步驟
    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

    變量使用注意事項：

  • 變量表示內存中的一個存儲區域；
  • 該區域有本身的名稱（變量名）和類型（數據類型）；
  • 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）第二種，根據值自行判斷變量類型（類型引導）程序員

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

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

    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也提供了這樣的語法【在函數裏面定義】編程

    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中函數外部定義變量就是全局變量】數組

    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
  • 該區域的數據值能夠在同一類型範圍內不斷變化 
    package main
import "fmt"
func main() {
//該區域的數據值能夠在同一類型範圍內不斷變化
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
  • 變量在同一個做用域（在一個函數或者代碼塊）內不能重名；
  • 變量的三要素
    變量=變量名+值+數據類型
  • Golang的變量若是沒有賦初值，編譯器會使用默認值，好比，int默認值爲0；string默認值爲空串；小數默認值爲0。

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

    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

    數據類型的基本介紹：

    每一種數據都定義了明確的數據類型，在內存中分配了不一樣大小的內存空間。
    （二）Golang的變量函數

    整數類型：

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

    3）如何在程序查看某個變量的字節大小和數據類型佈局

    package main
import(
"fmt"
"unsafe" //前提引入unsafe函數
)
func main() {
var n1 = 100
//%T表示內容的數據類型
fmt.Printf("n1 的類型是 %T\n", n1)
//如何在程序查看某個變量的佔用字節大小和數據類型
var n2 int64 = 10
//unsafe.Sizeof(n2) 是unsafe包的一個函數，能夠返回n2變量佔用的字節數
fmt.Printf("n2 的數據類型是 %T\nn2佔用的字節大小是 %d", n2, unsafe.Sizeof(n2))
}
    D:\gocode\goproject02\main01>go run main.go
n1 的類型是 int
n2 的數據類型是 int64
n2佔用的字節大小是 8

    4）Golang程序中整型變量在使用時，遵照保小不保大的原則，即：在保證程序正確運行下，儘可能使用佔用空間小的數據類型。
    5）bit：計算機中的最小存儲單位；byte：計算機中基本存儲單元；1byte=8bitui

    小數類型/浮點型：

  • 基本介紹
    小數類型就是用來存放小數的，好比：1.2 0.12-1.94 
    package main
import(
"fmt"
)
//演示golang中小數類型使用
func main() {
var price float32 = 87.23
fmt.Println("price", price)
}
    D:\gocode\goproject02\main02>go run main.go
price 87.23
  • 小數類型分類
    （二）Golang的變量
    對上圖的說明：
    1）浮點數=符號位+指數位+尾數位；說明浮點數都是有符號的。
    2）尾數部分可能會丟失，形成精度損失，如：-123.0000901
    //尾數部分可能會丟失，形成精度損失 
    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 的要準確。編碼

  • 浮點型使用細節
    1）Golang浮點類型有固定的範圍和字段長度，不受具體OS（操做系統）的影響；
    2）Golang的浮點類型默認爲float64類型； 
    //Golang的浮點類型默認聲明爲float64類型
var a = 1.1
fmt.Printf("a的數據類型爲 %T \n", a)
    D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
a的數據類型爲 float64

    3）浮點型常量有兩種表示形式；
    ① 十進制數形式：如 5.12 .512（必須有小數點）操作系統

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

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

    //科學計數法形式
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的字符串是由單個字節鏈接起來的；也就是說對於傳統的字符串是由字符組成的，而Go的字符串不一樣，它是由字節組成的。

  • 案例演示

    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)。

  • 字符類型使用細節
    1）字符常量是用單引號（‘’）括起來的單個字符；如：var c1 byte = 'a' 裏面的「a」
    2）Go中容許使用轉義字符「\」來將其後的字符轉變爲特殊字符型常量；如：var c2 char = '\n' ============='\n'表示換行符
    3）Go語言的字符使用UTF-8編碼，查詢字符對應的utf8碼值=====直接搜索」utf8 編碼「；UTF-8 編碼包含 ASCII 編碼；
    英文字母——1個字節；漢字——3個字節
    4）在Go中，字符的本質是一個整數，直接輸出時，是該字符對應的UTF-8碼值；
    5）能夠直接給某個變量賦一個數字，而後按格式化輸出時%c，會輸出該數字對應的unicode字符； 
    //能夠直接給某個變量賦一個數字，而後按格式化輸出時%c，會輸出該數字對應的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）字符類型是能夠進行運算的，至關於一個整數，由於它都有對應的Unicode碼；

    //字符類型是能夠進行運算的，至關於一個整數，運算時按照碼值運行；
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）字符型存儲到計算機中，須要將字符對應的碼值（整數）找出來；
    存儲：字符 ——> 對應碼值 ——> 二進制 ——> 存儲
    讀取：二進制 ——> 碼值 ——> 字符 ——> 讀取
    2）字符和碼值的對應關係是經過字符編碼表決定的（規定好的）；
    3）Go語言的編碼統一使用UTF-8，很是的方便、統一，不會出現編碼亂碼的問題。

    布爾類型：

  • 基本介紹
    1）布爾類型也叫bool類型，bool類型數據只容許取值true或者false；
    2）bool類型佔1個字節；
    3）bool類型適於邏輯運算，通常用於程序流程控制【if條件控制語句和for循環控制語句】
    4）不能夠用0或非0的整數替代false和true。
  • 案例演示 
    package main
import(
"fmt"
"unsafe"
) 
//演示golang中bool類型使用
func main() {
var b = false
fmt.Println("b=", b)
//注意事項
//1. bool類型佔用存儲空間爲1個字節
fmt.Println("b 的佔用字節 =", unsafe.Sizeof(b))
//2. bool類型只能取true或者false
}
    D:\goproject\src\go_code\chapter02\booldemo08>go run main.go
b= false
b 的佔用字節 = 1

    字符串類型：

  • 基本介紹
    字符串就是一串固定長度的字符鏈接起來的字符序列；Go的字符串是由單個字節鏈接起來的；Go語言的字符串的字節使用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使用細節和注意事項
    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!

    基本數據類型的默認值

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

    基本數據類型的相互轉換

  • 基本介紹
    Golang和 Java/c 不一樣，Go在不一樣類型的變量之間賦值時須要顯示轉換；也就是說Golang中數據類型不能自動轉換。
  • 基本語法
    表達式 T(v) 將值 v 轉換爲類型 T。
    T：就是數據類型，好比 int32，int64，float32 等等；
    v：就是須要轉換的變量。
  • 案例演示 
    package main
import(
"fmt"
)
//演示golang中基本數據類型的轉換
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
  • 基本數據類型相互轉換的注意事項
    1）Go語言中，數據類型的轉換能夠是從 表示範圍小---->表示範圍大，也能夠 範圍大----->範圍小；
    2）被轉換的是變量存儲的數據（即值），變量自己的數據類型並無變化！ 
    package main
import(
"fmt"
)
//演示golang中基本數據類型的轉換
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)
//被轉換的是變量存儲的數據（即值），變量自己的數據類型並無變化！！！
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

//不能編譯經過，由於沒有進行數據類型轉換
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）若是相加的值大於自己的數據類型範圍，則編譯不經過

    func main() {
//若是相加的值大於自己的數據類型範圍，則編譯不經過
var n4 int32 = 12
var n5 int8
var n6 int8
n5 = int8(n4) + 127 //【編譯經過，可是結果按溢出處理】
n6 = int8(n4) + 128 //【編譯不經過，由於128超出int8數據類型的範圍】
fmt.Println("n5=", n5)
}

    基本數據類型和string的轉換

  • 基本介紹
    在程序開發中，常常將基本數據類型轉換成string，或者將string轉換成基本數據類型。

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

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

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

    package main
import(
"fmt"
)
//演示golang中基本數據類型轉換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包的函數
    函數介紹：

    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 函數來轉換
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：表示小數位保留10位；64：表示這個小數是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包中有一個函數 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類型轉換基本數據類型
    使用strconv包的函數，函數介紹：

    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類型轉換基本數據類型
func main(){
var str string = "true"
var a bool
//strconv.ParseBool(str) 函數會返回兩個值（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函數返回的是int64或float64，若是但願獲得int32，float64等，以下處理：

    var d int64
d = int32(d)

    指針：

  • 基本介紹
    1）基本數據類型，變量存的就是值，也叫值類型；變量存值都對應一個地址。
    2）獲取變量的地址，用 &，好比：var num int，獲取num的地址：&num
    分析一下基本數據類型在內存的佈局:
    （二）Golang的變量
    3）指針類型，指針變量存的是一個地址，這個地址指向的空間存的纔是值。好比：var ptr int = &num
    舉例說明：指針在內存中的佈局
    （二）Golang的變量
    4）獲取指針類型所指向的值，使用星號，*ptr

    package main
import(
"fmt"
)
//演示golang中指針類型
func main() {
//基本數據類型在內存佈局
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的變量
  • 指針的使用細節
    1）值類型，都有對應的指針類型，形式爲*數據類型，好比int對應的指針就是 *int，float32對應的指針就是 *float32，以此類推。
    2）值類型包括：基本數據類型 int系列，float系列，bool，string，數組和結構體struct。

    值類型和引用類型

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

    標識符的命名規範

  • 標識符概念
    1）Golang對各類變量、方法、函數等命名時使用的字符序列稱爲標識符；
    2）凡是本身能夠起名字的地方都叫標識符。
  • 標識符的命名規則
    1）由26個英文字母大小寫，0-9，_組成；
    2）數字不能夠開頭；var num int //ok; var 3num int //error
    3）Golang中嚴格區分大小寫；
    var num int
    var Num int
    說明：在golang中，num和Num是兩個不一樣的變量。
    4）標識符不能包含空格；
    （二）Golang的變量
    5）下劃線「_」自己在Go中是一個特殊的標識符，稱爲空標識符。能夠表明任何其餘的標識符，可是對應的值會被忽略（好比：忽略某個返回值）。因此僅能被做爲佔位符使用，不能做爲標識符使用。
    6）不能以系統保留關鍵字做爲標識符（一共有25個），好比：break，if 等等。
  • 標識符命名注意事項
    1）包名：保持package的名字和目錄保持一致，儘可能採起有意義的包名，簡短，有意義，不要和標準庫衝突 fmt
    2）變量名、函數名、常量名：採用駝峯法
    舉例：var stuName string = "tom" 形式：xxxYyyyZzzz...
    3）若是變量名、函數名、常量名首字母大寫，則能夠被其餘的包訪問；若是首字母小寫，則只能在本包中使用。
    （二）Golang的變量
  • 系統保留關鍵字
    在go中，爲了簡化代碼編譯過程當中對代碼的解析，其定義的保留關鍵字只有25個。
    （二）Golang的變量
  • 系統的預約義標識符
    除了保留關鍵字外，go還提供了36個預訂的標識符，其包括基礎數據類型和系統內嵌函數。
    （二）Golang的變量
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程