1. <dd id="erndk"></dd>
                1. Go語言基本數據類型

                  互聯網 2022/1/3 6:08:39

                  Go語言有豐富的數據類型,出了基本的整型、浮點型、布爾型、字符串外,還有數組、切片、結構體、函數、map、通道(channel)等。 整型 整型分為兩類:無符號、有符號; 其中uint就是byte型,int16就是C語言中short型,int64就是long型。 類型 描述 uint8 無符號 8位整型 …

                  Go語言有豐富的數據類型,出了基本的整型、浮點型、布爾型、字符串外,還有數組、切片、結構體、函數、map、通道(channel)等。

                  整型

                  整型分為兩類:無符號、有符號;

                  其中uint就是byte型,int16就是C語言中short型,int64就是long型。

                  類型	描述
                  uint8	無符號 8位整型 (0 到 255)
                  uint16	無符號 16位整型 (0 到 65535)
                  uint32	無符號 32位整型 (0 到 4294967295)
                  uint64	無符號 64位整型 (0 到 18446744073709551615)
                  int8	有符號 8位整型 (-128 到 127)
                  int16	有符號 16位整型 (-32768 到 32767)
                  int32	有符號 32位整型 (-2147483648 到 2147483647)
                  int64	有符號 64位整型 (-9223372036854775808 到 9223372036854775807)
                  

                  特殊整型

                  類型	描述
                  uint	32位操作系統上就是uint32,64位操作系統上就是uint64
                  int	32位操作系統上就是int32,64位操作系統上就是int64
                  uintptr	無符號整型,用于存放一個指針
                  

                  注意:在使用intuint類型時,不能假定它是32位或者64位,而要考慮intuint可能在不同平臺上的差異。尤其是跨平臺應用需注意。

                  注意事項:為了保持文件的結構不會受到不同編譯目標平臺字節長度的影響,不要使用intuint。

                  八進制& 十六進制

                  Go語言中無法直接定義二進制數,關于八進制和十六進制數的示例如下:

                  package main
                  
                  import "fmt"
                  
                  // 整型
                  func main() {
                  	var i1 = 101 //類型推導,十進制數
                  	fmt.Printf("%d\n", i1)
                  	fmt.Printf("%b\n", i1)  //把十進制數轉換成二進制
                  	fmt.Printf("%o\n", i1)  //把十進制數轉換成八進制
                  	fmt.Printf("%ox\n", i1) //把十進制數轉換成十六進制
                  
                  	//八進制
                  	i2 := 077 //短變量聲明
                  	fmt.Printf("%d\n", i2)
                  
                  	//十六進制數
                  	i3 := 0x1234567abc
                  	fmt.Printf("%d\n", i3)
                  
                  	//查看變量類型
                  	fmt.Printf("%T\n", i3)
                  
                  	//聲明int8類型的變量
                  	i4 := int8(9) //明確指定int8類型,否則為int類型
                  	fmt.Printf("%T\n", i4)
                  }
                  

                  浮點型

                  Go語言支持兩種浮點型數:float32float64。打印浮點數時,可以使用fmt包配合%f,代碼如下:

                  package main
                  
                  import (
                  	"fmt"
                  	"math"
                  )
                  
                  func main() {
                  	f1 := 3.14159
                  	fmt.Printf("%T\n", f1) //默認Go語言中的小數都是float64
                  	f2 := float32(3.14159) //顯示聲明float32
                  	fmt.Printf("%T\n", f2) //此處f1的值不能賦值給f2,類型不同
                  	fmt.Printf("%f\n", math.Pi)
                  	fmt.Printf("%.2f\n", math.Pi)
                  }
                  

                  輸出:

                  D:\Go\src\github.com\hooo818\studygo\day01\05float>.\05float.exe
                  3.141593
                  3.14
                  

                  復數

                  complex64complex128

                  復數有實部和虛部,complex64的實部和虛部都是32位,complex128的實部和虛部都是64位。

                  var c1 complex64
                  c1= 1+ 2i
                  var c2 complex128
                  c2= 3+ 4i
                  fmt.printf("%T\n", c1)
                  fmt.Printf("%T\n", c2)
                  

                  布爾值

                  Go語言中以bool類型進行聲明布爾類型數據,布爾類型數據只有true(真)false(假)兩個值。

                  import "fmt"
                  
                  func main() {
                  	//布爾類型
                  	b1 := true
                  	var b2 bool
                  	fmt.Printf("%T\n", b1)
                  	fmt.Printf("%T value:%v\n", b2, b2)
                  }
                  

                  輸出結果:

                  bool
                  bool value:false //默認值是false
                  

                  注意:

                  1. 布爾類型變量的默認值為false;
                  2. Go語言中不允許將整型強制轉換為布爾型;
                  3. 布爾型無法參與數值運算,也無法與其他類型進行轉換。

                  字符串

                  Go語言中字符串以原生數據類型出現,使字符串就像使用它的原生數據類型int\bool\float32\float64等一樣。Go語言里面的字符串的內部實現使用utf-8編碼。字符串的值為雙引號("...")中的內容??梢栽贕o語言的源碼中直接添加非ASCII碼,例如:

                  s1:= "Hello"
                  s2:= "你好"
                  

                  注意:Go語言中字符串必須使用雙引號("")包裹,Go語言中單引號('')包裹的字符是字符(單獨的字母、漢字、符號表示一個字符

                  s:= "Hello Go 語言" //字符串
                  c1:= 'h' //字符
                  c2:= 'l' //字符
                  c3:= '洪' //字符,一個utf8漢字占3個字節
                  

                  字符串轉義符

                  轉義符	含義
                  \r	回車符(返回行首)
                  \n	換行符(直接跳到下一行的同列位置)
                  \t	制表符
                  \'	單引號
                  \"	雙引號
                  \\	反斜杠
                  

                  例如:

                  package main
                  
                  import "fmt"
                  
                  //字符串
                  
                  func main() {
                  	//\本來是具有特殊含義的,此時需要轉義
                  	path := "\"D:\\Go\\src\\github.com\\hooo818\\studygo\\day01\\08string\""
                  	fmt.Println(path)
                  
                  	s := "I'm  OK"
                  	fmt.Println(s)
                  
                  	//多行字符串
                  	s2 := `
                  		床前明月光
                  		疑是地上霜
                  	`
                  	fmt.Println(s2)
                  }
                  

                  輸出結果為:

                  "D:\Go\src\github.com\hooo818\studygo\day01\08string"
                  I'm  OK
                  
                                  床前明月光
                                  疑是地上霜
                  

                  多行字符串

                  Go語言中要定義一個多行字符串時,就必須使用反引號字符(Esc鍵下方那個鍵);反引號間換行將被作為字符串中的換行,但是所有的轉義字符無效,文本將會被原樣輸出。

                  字符串常用操作

                  方法	                                     介紹
                  len(str)	                              求長度
                  +或fmt.Sprintf	                         拼接字符串
                  strings.Split	                          分割
                  strings.contains	                      判斷是否包含
                  strings.HasPrefix,strings.HasSuffix	      前綴/后綴判斷
                  strings.Index(),strings.LastIndex()	      子串出現的位置
                  strings.Join(a[]string, sep string)	      join操作
                  
                  package main
                  
                  import (
                  	"fmt"
                  	"strings"
                  )
                  
                  //字符串
                  
                  func main() {
                  	//\本來是具有特殊含義的,此時需要轉義
                  	path := "\"D:\\Go\\src\\github.com\\hooo818\\studygo\\day01\\08string\""
                  	fmt.Println(path)
                  
                  	s := "I'm  OK"
                  	fmt.Println(s)
                  
                  	//多行字符串
                  	s2 := `
                  		床前明月光
                  		疑是地上霜
                  	`
                  	fmt.Println(s2)
                  
                  	//字符串相關操作
                  	fmt.Println(len(s)) //字符串長度
                  
                  	name := "理想"
                  	world := "帥"
                  
                  	ss := name + world //使用 "+"" 拼接字符串
                  	fmt.Println(ss)
                  
                  	ss1 := fmt.Sprintf("%s%s", name, world) //使用fmt.Sprintf()拼接字符串,拼接后返回一個字符串
                  	fmt.Println(ss1)
                  
                  	fmt.Printf("%s%s\n", name, world) //僅僅是打印在一起
                  
                  	//分割
                  	ret := strings.Split(path, "\\")
                  	fmt.Println(ret) //["D: Go src github.com hooo818 studygo day01 08string"]
                  
                  	//判斷是否包含
                  	fmt.Println(strings.Contains(ss1, "理想")) //true
                  
                  	//前綴、后綴判斷
                  	fmt.Println(strings.HasPrefix(ss1, "理想")) //true
                  	fmt.Println(strings.HasSuffix(ss1, "帥"))  //true
                  
                  	//判斷字串出現的位置
                  	ss2 := "abcdefb"
                  	fmt.Println(strings.Index(ss2, "c"))  //2
                  	fmt.Println(strings.Index(ss2, "bc")) //1
                  	fmt.Println(strings.LastIndex(ss2, "b")) //6
                  
                  	//拼接
                  	fmt.Println(strings.Join(ret, "+")) //"D:+Go+src+github.com+hooo818+studygo+day01+08string"
                  }
                  

                  fmt占位符

                  package main
                  
                  import "fmt"
                  
                  //fmt 占位符
                  func main() {
                  	var n = 100
                  	fmt.Printf("%T\n", n) //查看類型
                  	fmt.Printf("%v\n", n) //查看變量的值
                  	fmt.Printf("%d\n", n) //十進制
                  	fmt.Printf("%b\n", n) //二進制
                  	fmt.Printf("%o\n", n) //八進制
                  	fmt.Printf("%x\n", n) //十六進制
                  
                  	var s = "Let us Go"
                  	fmt.Printf("%s\n", s) //字符串
                      fmt.Printf("%#v\n", s)//會給字符串加上引號
                  }
                  
                  隨時隨地學軟件編程-關注百度小程序和微信小程序
                  關于找一找教程網

                  本站文章僅代表作者觀點,不代表本站立場,所有文章非營利性免費分享。
                  本站提供了軟件編程、網站開發技術、服務器運維、人工智能等等IT技術文章,希望廣大程序員努力學習,讓我們用科技改變世界。
                  [Go語言基本數據類型]http://www.yachtsalesaustralia.com/tech/detail-279317.html

                  贊(0)
                  關注微信小程序
                  程序員編程王-隨時隨地學編程

                  掃描二維碼或查找【程序員編程王】

                  可以隨時隨地學編程啦!

                  技術文章導航 更多>
                  国产在线拍揄自揄视频菠萝

                        1. <dd id="erndk"></dd>