精精国产xxxx视频在线播放7,激情国产,在线中文视频

1、標識符與關鍵字
- 1.1 標識符
- 1.2 關鍵字
2、變量
- 2.1 什么是變量
- 2.2 變量類型
- 2.3 變量聲明
3、常量
- 3.1 iota
4、基本數據類型
- 4.1 整型
- 4.2 浮點型
- 4.3 復數
- 4.4 布爾值
- 4.5 字符串
- 4.6 byte和rune類型
- 4.7 類型轉換
5、運算符
- 5.1 算數運算符
- 5.2 關系運算符
- 5.3 邏輯運算符
- 5.4 位運算符
- 5.5 賦值運算符
- 5.6 運算符優(yōu)先級

1、標識符與關鍵字

在了解數據類型之前，先了解一下go的標識符和關鍵字

1.1 標識符

在編程語言中標識符就是定義的具有某種意義的詞，比如變量名、常量名、函數名等等。 Go語言中標識符允許由字母數字和_(下劃線）組成，并且只能以字母和_開頭：abc , _ , _123, a123。

1.2 關鍵字

關鍵字是指語言預先定義好的具有特殊含義的標識符。關鍵字和保留字都不建議用作變量名。

Go語言有25個關鍵字：

				?

									break        default      func         interface    select

									case         defer        go           map          struct

									chan         else         goto         package      switch

									const        fallthrough  if           range        type

									continue     for          import       return       var

Go語言中有37個保留字

				?

									Constants:    true  false  iota  nil

									    Types:    int  int8  int16  int32  int64  

									              uint  uint8  uint16  uint32  uint64  uintptr

									              float32  float64  complex128  complex64

									              bool  byte  rune  string  error

									Functions:   make  len  cap  new  append  copy  close  delete

									             complex  real  imag

									             panic  recover

2、變量

2.1 什么是變量

程序運行過程中的數據都是保存在內存中，想要在代碼中操作某個數據時就需要去內存上找到這個變量，但是如果直接在代碼中通過內存地址去操作變量的話，代碼的可讀性會非常差而且還容易出錯，所以就利用變量將這個數據的內存地址保存起來，以后直接通過這個變量就能找到內存上對應的數據了。

所以變量的本質就是一小塊內存，用于存儲數據，在程序運行過程中數值可以改變

變量是為存儲特定類型的值而提供給內存位置的名稱。在go中聲明變量有多種語法。

2.2 變量類型

變量（Variable）的功能是存儲數據。不同的變量保存的數據類型可能會不一樣。常見變量的數據類型有：整型、浮點型、布爾型等。

Go語言中的每一個變量都有自己的類型，并且變量必須經過聲明才能開始使用。

2.3 變量聲明

Go語言中的變量需要聲明后才能使用，同一作用域內不支持重復聲明。并且Go語言的變量聲明后必須使用，否則無法通過編譯。

標準聲明：

Go語言的變量聲明格式為：

var 變量名變量類型

變量聲明以關鍵字var開頭，變量類型放在變量的后面，行尾無需分號：

				?

									var name string

									var age int

									var isTrue bool

批量聲明：

每聲明一個變量就需要寫var關鍵字會比較繁瑣，go語言中還支持批量變量聲明：

				?

									var (

									    a string

									    b int

									    c bool

									    d float32

									)

變量的初始化：

Go語言在聲明變量的時候，會自動對變量對應的內存區(qū)域進行初始化操作。每個變量會被初始化成其類型的默認值，即零值，例如： 整型和浮點型變量的默認值為0。字符串變量的默認值為空字符串。布爾型變量默認為false。切片、函數、指針變量的默認為nil。

當然也可在聲明變量的時候為其指定初始值。變量初始化的標準格式如下：

				?

									var 變量名 類型 = 表達式

									var name string = "golang"

									var age int = 18

或者一次初始化多個變量

				?

									var name, age = "golang", 20

類型推導：

有時候會將變量的類型省略，這個時候編譯器會根據等號右邊的值來推導變量的類型完成初始化。

				?

									var name = "golang"

									var age = 18

短變量聲明：

在函數內部，可以使用更簡略的 := 方式聲明并初始化變量。

				?

									// 全局變量m

									var m = 100

									func main() {

									 n := 10

									 m := 200 // 此處聲明局部變量m

									 fmt.Println(m, n)

									}

匿名變量：

在使用多重賦值時，如果想要忽略某個值，可以使用匿名變量（anonymous variable）。匿名變量用一個下劃線_表示，例如：

				?

									func foo() (int, string) {

									 return 10, "golang"

									}

									func main() {

									 x, _ := foo()

									 _, y := foo()

									 fmt.Println("x=", x)

									 fmt.Println("y=", y)

									}

匿名變量不占用命名空間，不會分配內存，所以匿名變量之間不存在重復聲明。

注意事項：

函數外的每個語句都必須以關鍵字開始（var、const、func等）
:=不能使用在函數外，不能定義全局變量，并且左邊的變量名至少有一個是新的。
_多用于占位，表示忽略值。
變量必須先定義才能使用，定義了就一定要使用。
變量的類型和賦值的類型必須一致。
變量名在同一個作用于域內不能沖突。

3、常量

相對于變量，常量是恒定不變的值，多用于定義程序運行期間不會改變的那些值。常量的聲明和變量聲明非常類似，只是把var換成了const，常量在定義的時候必須賦值。

				?

									const pi = 3.1415

									const e = 2.7182

聲明了pi和e這兩個常量之后，在整個程序運行期間它們的值都不能再發(fā)生變化了。

多個常量也可以一起聲明：

				?

									const (

									    pi = 3.1415

									    e = 2.7182

									)

const同時聲明多個常量時，如果省略了值則表示和上面一行的值相同。 例如：

上面示例中，常量n1、n2、n3的值都是100。

常量可以作為枚舉，常量組

				?

									const (

									    Unknown = 0

									    Female = 1

									    Male = 2

									)

常量組中如不指定類型和初始化值，則與上一行非空常量右值相同

				?

									func main() {

									 const (

									  x uint16 = 16

									  y

									  s = "abc"

									  z

									 )

									 fmt.Printf("%T,%v\n", y, y) //uint16,16

									 fmt.Printf("%T,%v\n", z, z) //string,abc

									}

常量的注意事項：

常量中的數據類型只可以是布爾型、數字型（整數型、浮點型和復數）和字符串型
不曾使用的常量，在編譯的時候，是不會報錯的
顯示指定類型的時候，必須確保常量左右值類型一致，需要時可做顯示類型轉換。這與變量就不一樣了，變量是可以是不同的類型值

3.1 iota

iota是go語言的常量計數器，是特殊的常量，只能在常量的表達式中使用。

iota在const關鍵字出現時將被重置為0。const中每新增一行常量聲明將使iota計數一次(iota可理解為const語句塊中的行索引)。使用iota能簡化定義，在定義枚舉時很有用。

				?

									const (

									  n1 = iota //0

									  n2        //1

									  n3        //2

									  n4        //3

									 )

幾個常見的iota示例:

使用_跳過某些值

				?

									const (

									  n1 = iota //0

									  n2        //1

									  _

									  n4        //3

									 )

iota聲明中間插隊

				?

									const (

									  n1 = iota //0

									  n2 = 100  //100

									  n3 = iota //2

									  n4        //3

									 )

									 const n5 = iota //0

定義數量級（這里的<<表示左移操作，1<<10表示將1的二進制表示向左移10位，也就是由1變成了10000000000，也就是十進制的1024。同理2<<2表示將2的二進制表示向左移2位，也就是由10變成了1000，也就是十進制的8。）

				?

									const (

									  _  = iota

									  KB = 1 << (10 * iota)

									  MB = 1 << (10 * iota)

									  GB = 1 << (10 * iota)

									  TB = 1 << (10 * iota)

									  PB = 1 << (10 * iota)

									 )

多個iota定義在一行

				?

									const (

									  a, b = iota + 1, iota + 2 //iota = 0、a = 1, b = 2

									  c, d                      //iota = 1、c = 2, d = 3

									  e, f                      //iota = 2、e = 3, f = 4

									 )

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

4、基本數據類型

4.1 整型

整型分為以下兩個大類： 按長度分為：int8、int16、int32、int64 對應的無符號整型：uint8、uint16、uint32、uint64

其中，uint8就是byte型，int16對應C語言中的short型，int64對應C語言中的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位操作系統(tǒng)上就是uint32，64位操作系統(tǒng)上就是uint64
int	32位操作系統(tǒng)上就是int32，64位操作系統(tǒng)上就是int64
uintptr	無符號整型，用于存放一個指針

注意： 在使用int和 uint類型時，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺上的差異。除非需要使用特定大小的整數，否則通常應該使用int來表示整數。大小:32位系統(tǒng)32位，64位系統(tǒng)64位。范圍:-2147483648到2147483647的32位系統(tǒng)和-9223372036854775808到9223372036854775807的64位系統(tǒng)。

注意事項 獲取對象的長度的內建len()函數返回的長度可以根據不同平臺的字節(jié)長度進行變化。實際使用中，切片或 map 的元素數量等都可以用int來表示。在涉及到二進制傳輸、讀寫文件的結構描述時，為了保持文件的結構不會受到不同編譯目標平臺字節(jié)長度的影響，不要使用int和 uint。

數字字面量語法（Number literals syntax）

Go1.13版本之后引入了數字字面量語法，這樣便于開發(fā)者以二進制、八進制或十六進制浮點數的格式定義數字，例如：

v := 0b00101101，代表二進制的 101101，相當于十進制的 45。 v := 0o377，代表八進制的 377，相當于十進制的 255。 v := 0x1p-2，代表十六進制的 1 除以 2²，也就是 0.25。

而且還允許用 _ 來分隔數字，比如說： v := 123_456 表示 v 的值等于 123456。

將一個整數以不同進制形式展示：

				?

									func main(){

									 // 十進制

									 var a int = 10

									 fmt.Printf("%d \n", a)  // 10

									 fmt.Printf("%b \n", a)  // 1010  占位符%b表示二進制

									 // 八進制  以0開頭

									 var b int = 077

									 fmt.Printf("%o \n", b)  // 77

									 // 十六進制  以0x開頭

									 var c int = 0xff

									 fmt.Printf("%x \n", c)  // ff

									 fmt.Printf("%X \n", c)  // FF

									}

4.2 浮點型

Go語言支持兩種浮點型數：float32和float64。這兩種浮點型數據格式遵循IEEE 754標準： float32 的浮點數的最大范圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。 float64 的浮點數的最大范圍約為 1.8e308，可以使用一個常量定義：math.MaxFloat64。

打印浮點數時，可以使用fmt包配合動詞%f：

				?

									func main() {

									        fmt.Printf("%f\n", math.Pi)

									        fmt.Printf("%.2f\n", math.Pi)

									}

4.3 復數

complex64和complex128

				?

									var c1 complex64

									c1 = 1 + 2i

									var c2 complex128

									c2 = 2 + 3i

									fmt.Println(c1)

									fmt.Println(c2)

復數有實部和虛部，complex64的實部和虛部為32位，complex128的實部和虛部為64位。

4.4 布爾值

Go語言中以bool類型進行聲明布爾型數據，布爾型數據只有true（真）和false（假）兩個值。

注意：

布爾類型變量的默認值為false。
不允許將整型強制轉換為布爾型.
布爾型無法參與數值運算，也無法與其他類型進行轉換。

4.5 字符串

Go語言中的字符串以原生數據類型出現，使用字符串就像使用其他原生數據類型（int、bool、float32、float64 等）一樣。字符串的內部實現使用UTF-8編碼。字符串的值為雙引號(")中的內容，可以在源碼中直接添加非ASCII碼字符：

				?

									s1 := "hello"

									s2 := "你好"

字符串轉義符：

Go 語言的字符串常見轉義符包含回車、換行、單雙引號、制表符等，如下表所示。

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

打印一個Windows平臺下的一個文件路徑：

				?

									func main() {

									    fmt.Println("str := \"d:\\go\\go.exe\"")

									}

多行字符串：

定義一個多行字符串時，就必須使用反引號字符：

				?

									s1 := `第一行

									第二行

									第三行

									`

									fmt.Println(s1)

反引號間換行將被作為字符串中的換行，但是所有的轉義字符均無效，文本將會原樣輸出。

字符串的常用操作：

介紹	方法
求長度	len(str)
拼接字符串	+或fmt.Sprintf
分割	strings.Split
判斷是否包含	strings.contains
前綴/后綴判斷	strings.HasPrefix,strings.HasSuffix
子串出現的位置	strings.Index(),strings.LastIndex()
join操作	strings.Join(a[]string, sep string)

4.6 byte和rune類型

組成每個字符串的元素叫做“字符”，可以通過遍歷或者單個獲取字符串元素獲得字符。字符用單引號（'）包裹起來，如：

				?

									var a := '中'

									var b := 'x'

Go 語言的字符有以下兩種：

uint8類型，或者叫 byte 型，代表了ASCII碼的一個字符。
rune類型，代表一個 UTF-8字符。

當需要處理中文、日文或者其他復合字符時，則需要用到rune類型。rune類型實際是一個int32。

Go 使用了特殊的 rune 類型來處理 Unicode，讓基于 Unicode 的文本處理更為方便，也可以使用 byte 型進行默認字符串處理，性能和擴展性都有照顧。

因為UTF8編碼下一個中文漢字由3~4個字節(jié)組成，所以不能簡單的按照字節(jié)去遍歷一個包含中文的字符串

字符串底層是一個byte數組，所以可以和[]byte類型相互轉換。字符串是不能修改的字符串是由byte字節(jié)組成，所以字符串的長度是byte字節(jié)的長度。 rune類型用來表示utf8字符，一個rune字符由一個或多個byte組成。

修改字符串：

要修改字符串，需要先將其轉換成[]rune或[]byte，完成后再轉換為string。無論哪種轉換，都會重新分配內存，并復制字節(jié)數組。

				?

									func changeString() {

									 s1 := "big"

									 // 強制類型轉換

									 byteS1 := []byte(s1)

									 byteS1[0] = 'p'

									 fmt.Println(string(byteS1))

									 s2 := "白蘿卜"

									 runeS2 := []rune(s2)

									 runeS2[0] = '紅'

									 fmt.Println(string(runeS2))

									}

4.7 類型轉換

Go語言中只有強制類型轉換，沒有隱式類型轉換。該語法只能在兩個類型之間支持相互轉換的時候使用。

強制類型轉換的基本語法如下：

T(表達式)

其中，T表示要轉換的類型。表達式包括變量、復雜算子和函數返回值等.

				?

									func sqrtDemo() {

									 var a, b = 3, 4

									 var c int

									 // math.Sqrt()接收的參數是float64類型，需要強制轉換

									 c = int(math.Sqrt(float64(a*a + b*b)))

									 fmt.Println(c)

									}

運算符用于在程序運行時執(zhí)行數學或邏輯運算。

5、運算符

Go 語言內置的運算符有：

算術運算符
關系運算符
邏輯運算符
位運算符
賦值運算符

5.1 算數運算符

運算符	描述
+	相加
-	相減
*	相乘
/	相除
%	求余

注意： ++ （自增）和--（自減）在Go語言中是單獨的語句，并不是運算符。

5.2 關系運算符

運算符	描述
==	檢查兩個值是否相等，如果相等返回 True 否則返回 False。
!=	檢查兩個值是否不相等，如果不相等返回 True 否則返回 False。
>	檢查左邊值是否大于右邊值，如果是返回 True 否則返回 False。
>=	檢查左邊值是否大于等于右邊值，如果是返回 True 否則返回 False。
<	檢查左邊值是否小于右邊值，如果是返回 True 否則返回 False。
<=	檢查左邊值是否小于等于右邊值，如果是返回 True 否則返回 False。

5.3 邏輯運算符

運算符	描述
&&	邏輯 AND 運算符。如果兩邊的操作數都是 True，則為 True，否則為 False。
\|\|	邏輯 OR 運算符。如果兩邊的操作數有一個 True，則為 True，否則為 False。
!	邏輯 NOT 運算符。如果條件為 True，則為 False，否則為 True。

5.4 位運算符

位運算符對整數在內存中的二進制位進行操作。

運算符	描述
&	參與運算的兩數各對應的二進位相與。（兩位均為1才為1）
\|	參與運算的兩數各對應的二進位相或。（兩位有一個為1就為1）
^	參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果為1。（兩位不一樣則為1）
&^	二進制位清空&^
<<	左移n位就是乘以2的n次方。 “a<<b”是把a的各二進位全部左移b位，高位丟棄，低位補0。
>>	右移n位就是除以2的n次方。 “a>>b”是把a的各二進位全部右移b位。

A	B	A&B	A\|B	A^B
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

5.5 賦值運算符

運算符	描述	示例
=	簡單的賦值操作符，分配值從右邊的操作數左側的操作數	C = A + B 將分配A + B的值到C
+=	相加并賦值運算符，它增加了右操作數左操作數和分配結果左操作數	C += A 相當于 C = C + A
-=	減和賦值運算符，它減去右操作數從左側的操作數和分配結果左操作數	C -= A 相當于 C = C - A
*=	乘法和賦值運算符，它乘以右邊的操作數與左操作數和分配結果左操作數	C = A 相當于 C = C A
/=	除法賦值運算符，它把左操作數與右操作數和分配結果左操作數	C /= A 相當于 C = C / A
%=	模量和賦值運算符，它需要使用兩個操作數的模量和分配結果左操作數	C %= A 相當于 C = C % A
<<=	左移位并賦值運算符	C <<= 2 相同于 C = C << 2
>>=	向右移位并賦值運算符	C >>= 2 相同于 C = C >> 2
&=	按位與賦值運算符	C &= 2 相同于 C = C & 2
^=	按位異或并賦值運算符	C ^= 2 相同于 C = C ^ 2
\|=	按位或并賦值運算符	C \|= 2 相同于 C = C \| 2