基本數據類型
數值型
整數不同類型的取值范圍
有符號:int,int8(8位,byte是int8的別名),int16,int32(rune是int32的別名,表示一個unicode碼點),int64
無符號:uint,uint8,uint16,uint32,uint64
有符號
整數類型,就是用於存放整數值的,比如0,-1,234等等
說明:
例如:int8,表示此數據類型占用空間為8位(1字節),
第一位,符號位,0表示無符號,1表示有符號,
剩余的7位表示數值,所以表示范圍為2的-7到2的7次方-1(減得那個1是0),對於0表示時會有正0和-0,其實都是0所以負數部分就多了1個可以表示的數值
無符號
無符號的整數,特點是沒有符號,所以第一位也可以表示數值本身,范圍比有符號的要大一些,從0開始
其他的數值類型
整數型的使用細節
- Golang各整數類型分為:有符號和無符號,int uint的大小和操作系統有關
- golang的整形默認聲明為int型
- 如何在程序查看某個變量的字節大小和數據類型
fmt.Printf("n1的類型為:%T",n1),查看變量的類型(%T)
fmt.Printf("n1占用的字節數是:%d",n1,unsafe.Sizeof(n1)),查看變量的所占用的字節數
- golang程序中整型變量在使用時,遵守保小不保打的原則,即:在保證程序正確運行下,盡量使用占用空間小的數據類型,如年齡,不會為負數,最大為130+ 所以選用uint8(byte)最為合適
- bit:計算機中的最小存儲單位,byte:計算機中基本存儲單元,1byte = 8bit
浮點類型
存放小數,比如1.2,0.32
float32,float64
說明:
- 浮點數在機器中存放的方式:浮點數=符號位+指數為+尾數位
3.56
11110000111.11111111111111111000
科學計數法
7.809..*10的6次方
2. 尾數部分可能丟失,造成精度損失.(-123.0000901)
float64的精度比float32的精度更准確,如果要保存一個精度高的數應該選用float64
3. 浮點型的存儲分為三部分:符號位+指數位+尾數位,在存儲過程中,精度會有丟失
使用浮點型注意事項
- golang浮點類型有固定的范圍和字段長度,不受具體OS(操作系統)的影響
- goalng的浮點型默認聲明為float64類型
- 浮點型常量有兩種方式表示
1). 十進制數形式:如:5.12 0.512可以用.512表示(必須有小數點)
2). 科學計數法形式:如:5.1234e2 = 5.12*10的2次方 5.12E-2=5.12/10的2次方
4.通常情況下應該使用float64,因為它比float32更准確
字符類型(char)
Go語言中沒有專門的字符型,如果要存儲單個字符(字母),一般使用byte來保存
字符串就是一串固定長度的字符連接起來的字符序列. Go的字符串是由單個字節鏈接起來的,也就是說對於傳統的字符串是由字符組成的,而Go的字符串不同,它是由字節組成的
說明:當輸出byte值時,就是輸出了對應的ASCII碼值
如果希望輸出對應的字符:用格式化輸出
fmt.Printf("c1=%c c2=%c",c1,c2)
如果是漢字的話,需要看值是否在byte的碼值范圍內
overflow溢出,處理方式
輸出漢字對應的碼值
說明:
1.如果保存的字符在ASICC表中,比如[0-1,a-z,A-Z],可以保存到byte中
2.如果保存的字符對應碼值大於255,這時考慮用int類型保存
3.如果需要按照字符的方式輸出,而不是碼值,只是需要格式化輸出,即fmt.Printf("%c",c1)
字符類型使用的注意事項
1.字符常量是用單引號('')引起來的單個字符,
例如:var c1 byte = 'a'
var c2 int = '中'
var c3 byte = '9'
2.Go中允許使用轉義字符''來講其后的字符轉變成特殊字符型常量
例如:
var c3 char = '\n' //'\n'表示換行符
3.Go語言的字符使用UTF-8編碼
4.在Go中字符的本質是一個整體,直接輸出時,是該字符對應的UTF-8編碼的碼值
5.可以直接給某個變量賦一個數字,然后按格式化輸出時%c會輸出改數字對應的Unicode字符
6.字符類型是可以進行運算的,相當於一個整數,因為它都對應有Unicode碼
字符類型的本質
1.字符型存儲到計算機中,需要將字符對應的碼值(整數)找到
存儲:找到漢字對應的碼值,轉成二進制,存儲
讀取:二進制轉成碼值,通過碼值到utf8對照表中找到對應的字符,讀取
2.字符和碼值的對應關系是通過字符編碼表決定的(規定死的)
3.Go語言的編碼都統一成了utf-8,非常的方便,很統一,再也沒有編碼亂碼的問題
布爾型
布爾類型也叫bool類型,只允許取值true和false,占用1字節,通常用於邏輯運算,流程控制
字符串
官方將string歸屬到基本數據類型
字符串就是一串固定長度的字符連接起來的字符序列,Go的字符串是由單個字節鏈接起來的,Go語言的字符串的字節的字節使用UTF-8編碼表示Unicode文本
package main
import "fmt"
func main() {
var address string = "背景你好"
fmt.Println(address)
}
字符串使用細節
1.Go語言的字符串的字節使用UTF-8編碼表示Unicode文本,這樣Golang同意使用UTG-8編碼亂碼問題不會再成為困擾
2.字符串一旦賦值,字符串就不能修改了,在Go中字符串是不可變的
package main
import (
"fmt"
"unsafe"
)
func main() {
var address string = "背景你好"
address[0] = "我不好" // 不可改變字符串中的某個元素
address = "我不好" // 可以重新賦值
fmt.Println(address,unsafe.Sizeof(address))
}
# cannot assign to address[0] (strings are immutable)
3.字符串的表示方法有兩種
1).雙引號,會識別\這種轉義字符
2).反引號`,以字符串的原生形式輸出,包括換行和特殊字符,可以實現防止共計,或者輸出源代碼等效果
4.字符串拼接方式
package main
import (
"fmt"
)
func main() {
var address string = "背景你好"
var age string = "18"
var address_age = address + age
// address += age
// fmt.Println(address)
fmt.Println(address_age)
}
- 當字符串的長度太長是,需要使用到多行字符串,注意需要將+保留在上一行,因為編譯器會自動加分號
不保留在上一行,會表示這一行代碼結束了,下一行代碼就會有錯
package main
import (
"fmt"
)
func main() {
var address string = "背景你好" +
"今天"
// var address string = "背景你好"
// + "今天" //錯誤!!!
fmt.Println(address)
}
基本數據類型的默認值.
在Go中,數據類型都有一個默認值,當沒有賦值時,就會保留其默認值,在Go中的默認值又叫做零值
基本數據類型的轉換
Golang和java/c 不同,Go在不同類型的變量之間賦值時需要顯示轉換(強制轉換),也就是說golang中數據類型不能自動轉換
表達式為:T(v)
將值v轉換為類型T
T:就是數據類型,比如int32,int64,float32等等
v:就是需要轉換的變量
package main
import (
"fmt"
)
func main() {
var str_num int = 1
int_num := int32(str_num)
var float_num = 3.125
var new_float_num float32 = float32(float_num)
fmt.Println(int_num,new_float_num)
}
package main
import (
"fmt"
)
func main() {
var str_num int = 1
int_num := float64(str_num)
fmt.Println(int_num)
}
數據類型轉換注意事項
1.Go中,數據類型的轉換可以從表示范圍小->表示范圍打,表示范圍打->表示范圍小
2.被轉換的是變量存儲的數據(即值),變量本身的數據類型並沒有變化!
3.在轉換中,比如將int64轉成int8,編譯時不會報錯,只是轉換的結果是按溢出處理(得到一個和希望結果不一樣的值)
注意
編譯無法通過
如何修改代碼可以正確?(go語言不支持自動轉換數據類型,需要強轉類型)
基礎數據類型和string的轉換
在程序開發中,經常需要將基本數據類型轉換成string類型,或者將string類型轉成基本數據類型
基本數據類型轉string
方式:
1.fmt.Sprintf("%參數",表達式)
1).參數需要和表達式的數據類型相匹配
2).fmt.Sprintf()會返回轉換后的字符串
package main
import (
"fmt"
)
func main() {
var str1_num int = 1000
var str2_num float64 = 154.24554
var str3_num bool = true
var str4_num byte = 'h'
var str string // 空的字符串
str = fmt.Sprintf("%d", str1_num)
str = fmt.Sprintf("%d", str2_num)
str = fmt.Sprintf("%t", str3_num)
str = fmt.Sprintf("%w", str4_num)
fmt.Printf("str1_num 轉換后的 type (%T) is %q\n", str, str)
fmt.Printf("str2_num 轉換后的 type (%T) is %q\n", str, str)
fmt.Printf("str3_num 轉換后的 type (%T) is %q\n", str, str)
fmt.Printf("str4_num 轉換后的 type (%T) is %q", str, str)
}
2.使用strconv包的函數
package main
import (
"fmt"
"strconv"
)
func main() {
var str1_num int = 1000
var str2_num float64 = 154.24554
var str3_num bool = true
var str4_num int = 123
var str4_num int64 = 456
var str string // 空的字符串
str = strconv.FormatInt(int64(str1_num),2) // int64轉成二進制的字符串
fmt.Printf("str1_num(%T) 轉換后為 %q\n",str,str)
str = strconv.FormatFloat(str2_num,'f',10,64) // float轉成10位的float64的字符串
fmt.Printf("str1_num(%T) 轉換后為 %q\n",str,str)
str = strconv.FormatBool(str3_num) // bool 轉成 字符串
fmt.Printf("str1_num(%T) 轉換后為 %q\n",str,str)
str = strconv.Itoa(str4_num) // int類型很方便的轉換成字符串
fmt.Printf("str (%T) 轉換后為%q",str,str)
str = strconv.Itoa(int(str5_num)) // int64必須轉成int,才可以用這個函數
fmt.Printf("str (%T) 轉換后為%q",str,str)
}
string轉成基本數據類型
package main
import (
"fmt"
"strconv"
)
func main() {
var str1 string = "true"
var str_to_bool bool
str_to_bool , _ = strconv.ParseBool(str1)
fmt.Printf("str_to_bool (%T) 轉換成%q\n",str_to_bool,str_to_bool)
var str2 string = "123456"
var str_to_int int64
var str_to_int2 int
str_to_int , _ = strconv.ParseInt(str2,10,64) // 只能轉成int64,如果是int需要強轉
str_to_int2 = int(str_to_int)
fmt.Printf("str_to_bool (%T) 轉換成%v\n",str_to_int2,str_to_int2)
var str3 string = "12.1254"
var str_to_float float64
str_to_float , _ = strconv.ParseFloat(str3,64)
fmt.Printf("str_to_float (%T) 轉換成%v",str_to_float,str_to_float)
}
說明: 因為返回的是int64或者float64,如果希望得到int32或float32,用int32()/float32()強轉一下
注意事項
在將string類型轉換成基本數據類型時,要確保string類型能夠轉成有效的數據,比如可以吧"123"轉成一個整數,但是不能把"hello" 轉成一個整數,如果這樣做,Golang 直接將其轉換成0,其他所有轉不成功的數據類型都會置其為默認值
派生/復雜數據類型
指針(pointer)
基本介紹
1.基本數據類型,變量存的是值,也叫值類型
2.獲取變量的地址,用&,比如:var num int,獲取num的地址:&num
var i int = 100
fmt.Printf("i的內存地址為",&i)
3.指針類型,變量存的是一個地址,這個地址指向的空間存的才是值,比如var ptr *int=&num
package main
import "fmt"
func main() {
var i int = 100
fmt.Printf("i的內存地址為%v\n",&i)
// xx是一個指針變量,類型是*int,並且指向i的內存地址,內存地址指向的才是值
var xx *int = &i
// 指針變量也是有自己的內存地址的
fmt.Printf("xx指向的內存地址為%v\n",xx,)
fmt.Printf("xx指針變量的內存地址為",&xx)
}
4.獲取指針類型所指向的值,使用:*,比如var ptr int,使用ptr獲取p指向的值
package main
import "fmt"
func main() {
var i int = 100
fmt.Printf("i的內存地址為%v\n",&i)
// xx是一個指針變量,類型是*int,並且指向i的內存地址,內存地址指向的才是值
var xx *int = &i
// 指針變量也是有自己的內存地址的
fmt.Printf("xx指向的內存地址為%v\n",xx,)
fmt.Printf("xx指針變量的內存地址為%v\n",&xx)
fmt.Printf("xx指針變量指向的值為",*xx)
}
練習
題目:
1.寫一個程序,獲取int變量num的地址,並顯示到終端
2.將num的地址賦給指針ptr,並通過ptr去修改num的值
package main
import "fmt"
func main() {
var num int = 500
fmt.Printf("i的內存地址為%v\n",&num)
var ptr *int = &num
*ptr = 500
fmt.Printf("改變后的值為num=",num)
}
指針的注意事項
1.值類型,都有對應的指針類型,形式為*數據類型,比如int的對應的指針就是int,float32 對應的指針類型就是float32,依次類推
2.值類型包括:基本數據類型int系列,float系列,bool,string,數組和結構體(struct)
值類型和引用類型
值類型和引用類型在go中都有哪些數據結構
1.值類型:基本數據類型int系列,float系列,bool,string,數組和結構體struct
2.引用類型:指針,slice切片,map,管道channel,接口(interface)等都是引用類型
區別
1.值類型,變量直接存儲值,內存通常在棧中分配
2.引用類型,變量存儲的是一個地址,這個地址對應的空間才真正存儲數據(值),內存通常在堆上分配.當沒有任何變量引用這個地址時,該地址對應的數據空間就變成為一個垃圾有GC來回收
