day02 go的資料型別和運算子

染指未来發表於2024-07-02
Go資料型別

前言

  • 動態語言型別
  • 自動開闢資料空間，自動識別資料型別 python
  • 靜態語言型別
  • 開闢記憶體空間，定義資料型別 c，java，go

go 語言中的資料型別

/*
	- go 基本資料型別：
		- 布林型別
		- 數值型別
			- 整型  :
				- 有符號：int,int8,int16,int32,int64.
				- 無符號：uint,uint8,uint16,uint32,uint64
			- 浮點型
				- float32,float64
				- 複數：complex
		- 字串型別
	- 派生資料型別
		- 指標 *
		- 陣列 array
		- 結構體 struct
		- 通道 channel
		- 切片 slice
		- 函式 func
		- 介面 interface
		- Map
*/
code
// 1. 布林型別
	var b1 bool
	var b2 bool
	b1 = true
	b2 = false
	fmt.Println(b1, b2)

	// f fmt.Printf 格式化輸出 ： %d 整數, %s 字串，%p 記憶體地址, %T 資料型別，%t布林型別資料結果 ,%f 浮點資料
	fmt.Printf("布林型別資料的整數結果：b1=%T,%t\n", b1, b1)
	fmt.Printf("布林型別資料的整數結果：b2=%T,%t\n", b2, b2)

	// 布林預設值 ： false = 0 , true = 1
	var b3 bool
	fmt.Println(b3)

	// 2. 整數型別,不能超過該資料型別的長度
	var i1 int8
	i1 = 10
	fmt.Println(i1)
	//i1 = 1000 // 超出 int8 的範圍。 cannot use 1000 (untyped int constant) as int8 value in assignment (overflows)
	fmt.Println(i1)

	//var i2 uint8
	//i2 = -100 // cannot use -100 (untyped int constant) as uint8 value in assignment (overflows)
	//fmt.Println(i2)

	// 3. 浮點型，預設保留 小數點後 六位
	var f1 float32
	f1 = -19999
	fmt.Printf("%T,%f\n", f1, f1)
	fmt.Println(f1)
	f1 = 3.14
	fmt.Printf("%T,%f\n", f1, f1)
	fmt.Println(f1)

	// 保留小數點後3位. 格式化輸出：%.3f，超出的位數四捨五入
	var f2 float32
	f2 = 3.1415926
	fmt.Printf("%.3f\n", f2) // 3.142。自動四捨五入

	// float32 和 float64 精度不一樣. 預設使用 float64
	var f3 float32 = -123.0000901
	var f4 float64 = -123.0000901
	fmt.Println(f3, f4) // -123.00009 -123.0000901

	// 4. 特殊數字型別 無符號
	// byte型別. byte == uint8
	var byte1 byte = 255
	fmt.Println(byte1)
	fmt.Printf("%T\n", byte1) // uint8 型別

	// rune型別 rune == int32
	var rune1 rune = 1000000000
	fmt.Println(rune1)
	fmt.Printf("%T\n", rune1) // int32 型別

	// int 預設根據系統位數來定義
	var int1 int = 1000
	fmt.Println(int1)
	fmt.Printf("%T\n", int1) // int 型別

	// 5. 字串型別. go中字串由字元組成。  go 預設使用utf-8編碼型別
	var str0 string
	str0 = "Hello Word"
	fmt.Printf("%T %s \n", str0, str0) // string 型別

	var str1 string
	str1 = "go 語言學習中" // 空格隔開中文，英文不隔開
	fmt.Println(str1)

	//  單引號：字元 字元的本質是整形數值型別資料.  雙引號：string型別
	s1 := 'A'
	s2 := "A"
	fmt.Println(s1, s2)           // 65, A
	fmt.Printf("%T,%T\n", s1, s2) // int32,string

	// 跳脫字元： \ 轉義符號： \n 換行， \b 刪除上一個字元，\t tab
	fmt.Println("hello\nword")
	fmt.Println("hello\bword")
	fmt.Println("hello\tword")

	// 反 跳脫字元
	fmt.Println("\\n")
	fmt.Println("\"")

	// 多行文字 使用 反引號 : ``
	s3 := `go 多行文字`
	fmt.Println(s3)

	// 6. 數值型別轉換. 格式：新型別的值=新型別(舊型別的值).
	// int 轉換為 float
	var v1 int
	v1 = 1
	v2 := float64(v1)
	fmt.Printf("%T,%d\n", v1, v1)
	fmt.Printf("%T,%.3f\n", v2, v2)

	// float 轉換為 int
	c := 12
	d := float64(c)
	fmt.Printf("%T,%.3f\n", d, d)
	fmt.Printf("%T,%d\n", c, c)

	// 布林型別 不支援轉換

數值型

序號 型別和描述
1 uint8 無符號 8 位整型 (0 到 255)
2 uint16 無符號 16 位整型 (0 到 65535)
3 uint32 無符號 32 位整型 (0 到 4294967295)
4 uint64 無符號 64 位整型 (0 到 18446744073709551615)
5 int8 有符號 8 位整型 (-128 到 127) 0
6 int16 有符號 16 位整型 (-32768 到 32767)
7 int32 有符號 32 位整型 (-2147483648 到 2147483647)
8 int64 有符號 64 位整型 (-9223372036854775808 到 9223372036854775807)

跳脫字元

運算子

/*
		運算子
			- 算數運算子
				- 取模 %
				- 加減乘除
				- ++ , -- 自增/自減
			- 賦值運算子
				- = 賦值運算子
				- += 加等於
				- -= 減等於
				- /= 處等於
				- *= 乘等於
			- 邏輯運算子
				- 與 &&， 或 || ，非 !
				- ! 取反運算子
			- 位運算子。 加密解密常用。 基於二進位制資料計算
				- & 對比位置。相同位置位比較，兩個為1就是1
				- | 對比位置。相同位置比較，一個為1就是1
				- >> 右移。
				- << 左移
				- ^ 相異或
				- &^ 位清空。 a &^ b。 為：0，取a上的數值。 為:1 ，取0（二進位制）

			- 關係運算子
				- 大於>，小於<，等於==,不等於!=，大於等於>=，小於等於<= .
			- 其他運算子
				- & 取地址
				- * 指標符號


*/
code
// 取模
	c := 7 % 2
	fmt.Println(c)

	// 取反
	b := true
	fmt.Println(!b)

	// 位運算
	// &
	aa := 1              //二進位制001
	bb := 5              //二進位制101
	fmt.Println(aa & bb) // 1
	// ｜
	fmt.Println(aa | bb) // 5
	// >> 右
	fmt.Println(bb >> 1) // 2. 101 右移動1位。 10 = 2
	fmt.Printf("%b\n", bb>>1)
	// << 左
	fmt.Println(bb << 1) // 10. 101 左移動1為。 1010 = 10
	fmt.Printf("%b\n", bb<<1)

	println()

	AA := 60 // 二進位制：0011 1100
	BB := 13 // 二進位制：0000 1101
	// &  0000 1100
	fmt.Println(AA & BB) // 12
	res1, _ := strconv.ParseInt("00001101", 2, 64)
	fmt.Println("二進位制轉十進位制：", res1)

	// ｜ 0011 1101
	fmt.Println(AA | BB) // 61
	res2, _ := strconv.ParseInt("00111101", 2, 64)
	fmt.Println("二進位制轉十進位制：", res2)

	// ^ 按位異或.  位置相同為0，不同為1。 0011 0001
	fmt.Println(AA ^ BB) // 0011 0001
	res3, _ := strconv.ParseInt("00110001", 2, 64)
	fmt.Println("二進位制轉十進位制：", res3)

	// &^ 位清空。 a &^ b。 為：0，取a上的數值; 為:1 ，取0（二進位制）
	fmt.Println(AA &^ BB) // 0011 0000
	res4, _ := strconv.ParseInt("00110000", 2, 64)
	fmt.Println("二進位制轉十進位制：", res4)

	// >> 左移 幾位
	fmt.Println(AA << 2) // 二進位制：0011 1100  ---->  1111 0000
	res5, _ := strconv.ParseInt("11110000", 2, 64)
	fmt.Println("二進位制轉十進位制：", res5)

	// << 右移 幾位
	fmt.Println(AA >> 2) // 二進位制：0011 1100  ---->  0000 1111
	res6, _ := strconv.ParseInt("00001111", 2, 64)
	fmt.Println("二進位制轉十進位制：", res6)

位運算子 圖解

運算子 描述 例項
& 按位與運算子"&"是雙目運算子。都是1結果為1，否則是0 (A & B) 結果為 12, 二進位制為 0000 1100
| 按位或運算子"|"是雙目運算子。 都是0結果為0，否是是1 (A | B) 結果為 61, 二進位制為 0011 1101
^ 按位異或運算子"^"是雙目運算子。 不同則為1，相同為0 (A ^ B) 結果為 49, 二進位制為 0011 0001
&^ 位清空，a &^ b，對於b上的每個數值，如果為0，則取a對應位上的數值，如果為1，則取0. (A &^ B) 結果為 48, 二進位制為 0011 0000
<< 左移運算子"<<"是雙目運算子。左移n位就是乘以2的n次方。 其功能把"<<"左邊的運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。 A << 2 結果為 240 ，二進位制為 1111 0000
>> 右移運算子">>"是雙目運算子。右移n位就是除以2的n次方。 其功能是把">>"左邊的運算數的各二進位全部右移若干位，">>"右邊的數指定移動的位數。 A >> 2 結果為 15 ，二進位制為 0000 1111

go 中的資料型別圖

賦值運算子

運算子 描述 例項
= 簡單的賦值運算子，將一個表示式的值賦給一個左值 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

其他運算子

運算子 描述 例項
& 返回變數儲存地址 &a; 將給出變數的實際地址。
* 指標變數。 *a; 是一個指標變數

相關文章