Go語言基礎數據類型之基本數據類型

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

基本數據類型

整型

整型分爲兩大類

按長度分爲:

Int8 、int16、int32、int64

對應無符號類型:

uint8 、uint16、uint32 、uint64

uit8 是我們熟知的 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位操作系統上就是`uint32`，64位操作系統上就是`uint64`
int	32位操作系統上就是`int32`，64位操作系統上就是`int64`
uintptr	無符號整型，用於存放一個指針

注意： 在使用int和 uint類型時，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺上的差異。

注意:

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

數字字面量語法

Go1.13 版本之後引入了數字字面量語法,這樣便於開發者,以二進制、八進制或十六進制浮點點數的格式定義數字,例如:

v := 0b00101101代表二進制101101,相當於十進制的45
v := 0o377,代表八進制的377,相當於十進制的255
v := 0x1p-2，代表十六進制的 1 除以 2²，也就是 0.25。
還允許我們用 _ 來分隔數字，比如說： v := 123_456 表示 v 的值等於 123456

以上代碼用過了 fmt 包的格式化功能，你可以參考這裏去看上面的代碼

%b    表示爲二進制
%c    該值對應的unicode碼值
%d    表示爲十進制
%o    表示爲八進制
%q    該值對應的單引號括起來的go語法字符字面值，必要時會採用安全的轉義表示
%x    表示爲十六進制，使用a-f
%X    表示爲十六進制，使用A-F
%U    表示爲Unicode格式：U+1234，等價於"U+%04X"

藉助fmt函數將一個整數轉換不同的進制形式展示.

package main

import "fmt"

func main() {
	var a int = 10  // 十進制
	fmt.Printf("%d \n",a)  // %d 表示十進制
	fmt.Printf("%b \n",a)  // %b 表示二進制

	var b int = 077   //以0開頭的 代表八進制
	fmt.Printf("%o \n",b) // %o 佔位符 顯示八進制

	var c int = 0xff   // 十六進制 以0x開頭
	fmt.Printf("%x \n",c)  // %x 表示十六進制
	fmt.Printf("%X \n",c)
}

結果:

10 
1010 
77 
ff 
FF 
Process finished with exit code 0

浮點型

Go語言支持兩種浮點數類型:

兩種浮點數類型數據格式遵循IEEE 754 標準百度百科

float32的浮點數的最大範圍約爲 3.4e38,可以使常量定義: math.MaxFloat32
float64的浮點數的最大範圍約爲1.8e308可以使常量定義:math.MaxFloat64

打印浮點數時可以,使用 fmt包含動詞 %f例子:

package main

import (
	"fmt"
	"math"
)

func main() {

	fmt.Printf("%f \n", math.MaxFloat32) // MaxFloat32 最大範圍 
	fmt.Printf("%f \n", math.MaxFloat64)  //MaxFloat64 最大範圍
	
	var a float64  = 3.1415926  // 推薦用 float64 更爲精確
	var b float32  = 3.1415926

	fmt.Printf("float64： %f \n", a)
	fmt.Printf("float32： %f \n", b)
	fmt.Printf("%f \n", math.Pi)
	fmt.Printf("%.2f \n", math.Pi) // %.2f 表示精確前兩位

結果:

MaxFloat32: 340282346638528859811704183484516925440.000000 
MaxFloat64: 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000 
float64： 3.141593 
float32： 3.141593 
3.141593 
3.14 
Process finished with exit code 0

Go語言默認浮點數類型 float64 有可能你是32位系統就默認成 float32

package main

import (
	"fmt"
	"reflect"
)

func main() {
	
	var a = 3.1415926  // 默認 float64 
	fmt.Println(reflect.TypeOf(a)) // reflect.TypeOf 判斷當前變量 數據類型行 


}

結果:

float64

Process finished with exit code 0

複數

一代而過: 我是數學不太好, 幾乎也用不上, 可能我還沒到那個水平.

complex64和complex128

package main

import (
	"fmt"
)

func main() {

	var c1 complex64
	c1 = 1 + 2i
	var c2 complex128
	c2 = 2 + 3i
	fmt.Println(c1)
	fmt.Println(c2)
}

結果:

(1+2i)
(2+3i)

Process finished with exit code 0

布爾值

Go 語言中以bool 類型生命的變量或者常量, 布爾類型只有

true 真
false 假

package main

import "fmt"

func main() {
   var a bool
   fmt.Println(a) // Go語言中 默認值 爲 false
   var b bool = true     // bool類型 不能強制轉換  只有  真(true) 或者 假(false)
   var c bool = false    
   fmt.Println(b)   
   fmt.Println(c)

}

結果:

false
true
false

Process finished with exit code 0

注意：

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

字符串

Go語言中的字符串以原生數據類型出現, 使用字符串就像是使用其他原生數據類型(int、bool、float32、float64等)一樣.

Go語言中字符串內部實現使用utf-8的編碼方式
字符串的值是以 "" 雙引號的方式出現的
可以在Go語言的源碼中直接添加非ASCII碼字符

代碼:

package main

import "fmt"

func main() {
	s1 := "hello"
	s2 := "你好"
	fmt.Println(s1)
	fmt.Println(s2)

}

結果:

hello
你好

Process finished with exit code 0

字符串轉義符

go語言的字符串常見轉義符包含回車、換行、單引號、製表符等等.

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

舉個例子，我們要打印一個Windows平臺下的一個文件路徑：

package main

import (
	"fmt"
)
func main() {
	a := `str := "c:\Code\lesson1\go.exe\"`  // ``  表示字符串原樣輸出
	fmt.Println(a)
	b := "str := \"c:\\Code\\lesson1\\go.exe\\\""  // 轉義符轉換成普通字符串
	fmt.Println(b)
}

結果:

str := "c:\Code\lesson1\go.exe\"
str := "c:\Code\lesson1\go.exe\"

Process finished with exit code 0

多行字符串

Go語言中要定義個多行字符串我們就必須使用 反引號 :

package main

import "fmt"

func main() {
	s1 := `
	name : 春生
	age  ： 18
	第三行 ...
`
fmt.Println(s1)
}

結果:

        name : 春生
        age  ： 18
        第三行 ...


Process finished with exit code 0

字符串常用操作

方法	介紹
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() {
	s1 := "北京吳彥祖春生"      // utf-8 中文佔用三個字節
	fmt.Println(len(s1)) // 長度 31

	// 字符串拼接 推薦 用+號 語言內部做了優化
	s2 := "牛逼"
	fmt.Println(s1 + s2) // "北京吳彥祖春生" + "牛逼" = "北京吳彥祖春生牛逼"
	fmt.Sprintf(s1, s2)  // fmt.Sprintf 方式拼接
	// 字符串 分割 strings.Split
	s3 := "www.baidu.com"
	fmt.Println(strings.Split(s3,".")) // 結果返回值是以切片的方式返回 [www baidu com]

	// 字符串判斷是否包含 strings.Contains
	fmt.Println(strings.Contains(s1,"春生")) // 返回布爾值 true

	// 判斷字符串前綴
	fmt.Println(strings.HasPrefix(s1,"北京"))  // 返回值 true 如果不是 返回 false

	// 判斷字符串後綴
	fmt.Println(strings.HasSuffix(s1,"生"))  // 返回值 true

	// 判斷子串出選的位置
	fmt.Println(strings.Index(s1,"吳"))   // 返回字符串 子串首次出現的位置
	fmt.Println(strings.LastIndex(s1,"吳")) // 返回字符串s中字符串sep最後一次出現的位置

	// join 操作 將切片數據類型轉換成字符串
	fmt.Println(strings.Join([]string{"lcc","lyh","ry"},","))


}

結果:

21
北京吳彥祖春生牛逼
[www baidu com]
true
true
true
6
6
lcc,lyh,ry

Process finished with exit code 0

byte和rune類型

組成每個字符串的元素叫做字符,可以通過便利的方獲取每個字符用單引號包起來的就是字符:
代碼:

var a = '中'  // 	字符  byte 類型
var b = 'w' // 	字符  byte 類型

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

uint8類型,或者叫byte型,代表ASCII的一個字符.
rune類型,代表一個UTF-8字符.

當需要處理中文、或者日文或其他複合字符時,需要用rune類型.rune實際是一個int32.

Go使用特殊的rune類型來處理 Unicode,讓基於Unicode的文本處理更爲方便,也可以使用byte型默認字符串處理,性能和擴展都需要照顧.

package main

import (
	"fmt"
	"reflect"
	"strings"
)
func ByteFunc() {
	var a  = '中'  // 如果不聲明 var byte a = '中' Go語言默認 是rune utf-8 
	fmt.Println(reflect.TypeOf(a))

	var s1 = "hello北京"

	for i :=0;i < len(s1);i++{  // byte類型
		fmt.Println(s1[i])
	}
	for _,v := range s1{  // rune 類型
		fmt.Println(v)
	}

}
func main() {
	ByteFunc()

}

結果:

int32
h
e
l
l
o
å


ä
º
¬

104
101
108
108
111
21271 // 北
20140 // 京

Process finished with exit code 0

亂碼的出現是因爲 UTF-8編碼下的中文漢字是由 3~4個字節組成的,所以我們不能簡單的安裝字節去便利一個包含中文的字符串,否則就會出現上面第一個 for 循環出現的亂碼.

字符串底層是一個byte數組,所以可以和 []byte類型互相轉換.字符串是能修改的,字符串是由byte字節組成,所以字符串的長度是byte字節的長度.

rune類型用來表示utf8字符,一個rune由一個或多個byte組成.

修改字符串

要修改字符串,需要先將其轉換成 []rune或者[]byte,完成後在轉換成string.
無論哪種轉換,都會重新分配內存空間,並複製字節數組

package main

import (
	"fmt"
	"reflect"
	"strings"
)


func StringSet(){

	s1 := "big"
	// 強制類型轉換 修改字符串
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "蔣秋生"
	runeS2 := []rune(s2)
	runeS2[1] = '春'
	fmt.Println(string(runeS2))
}



func main() {
	StringSet()

}

結果:

pig
蔣春生

Process finished with exit code 0

類型轉換

Go語言中只有強制類型轉換,沒有隱式類型轉換.該語法只能在兩個類型之間支持互相切換

go 不支持隱式轉換類型，比如 :

package main
import "fmt"

func main() {  
    var a int64 = 3
    var b int32
    b = a
    fmt.Printf("b 爲 : %d", b)
}

結果:

cannot use a (type int64) as type int32 in assignment
cannot use b (type int32) as type string in argument to fmt.Printf

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

package main
import "fmt"

func main() {  
    var a int64 = 3
    var b int32
    b = int32(a)  // 轉換之後在賦值。強制轉換
    fmt.Printf("b 爲 : %d", b)
}

比如計算直角三角形的斜邊長時使用math包的Sqrt()函數，該函數接收的是float64類型的參數，而變量a和b都是int類型的，這個時候就需要將a和b強制類型轉換爲float64類型。

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

練習題

編寫代碼分別定義一個整型、浮點型、布爾型、字符串型變量，使用fmt.Printf()搭配%T分別打印出上述變量的值和類型。

package main

import (
	"fmt"
	"reflect"
	"strings"
)

func Exercises(){
	// 編寫代碼分別定義一個整型、浮點型、布爾型、字符串型變量，使用`fmt.Printf()`搭配`%T`分別打印出上述變量的值和類型。
	var a int = 10
	var pi float64 = 3.1415926
	var isOk bool = true
	var str string = "春生"
	fmt.Printf("數值：%d 類型：%T \n",a,a)
	fmt.Printf("數值：%f 類型：%T \n",pi,pi)
	fmt.Printf("數值：%t 類型：%T \n",isOk,isOk)
	fmt.Printf("數值：%s 類型：%T \n",str,str)

}

func main() {
	Exercises()

}

結果:

數值：10 類型：int 
數值：3.141593 類型：float64 
數值：true 類型：bool 
數值：春生 類型：string

編寫代碼統計出字符串"hello北京吳彥祖春生"中漢字的數量。

package main

import (
	"fmt"
	"reflect"
	"strings"
)

func Exercises(){
	// 編寫代碼統計出字符串`"hello北京吳彥祖春生"`中漢字的數量。
	s1 := "hello北京吳彥祖春生"

	num := 0
	for _,v:=range s1 {
		if len(string(v)) >= 3{
			num++
		}
	}
	fmt.Println("共有",num,"漢字")

}

func main() {
	Exercises()

}

結果:

共有 7 漢字

Process finished with exit code 0

Go語言基礎數據類型之基本數據類型

Go語言基礎數據類型之基本數據類型

基本數據類型

整型

特殊類型

數字字面量語法

浮點型

複數

布爾值

字符串

字符串轉義符

多行字符串

字符串常用操作

byte和rune類型

修改字符串

類型轉換

練習題

ntunnel_mysql.php

Go語言fmt包(輸入,輸出,格式化佔位符)

Go 語言安裝及第一個Go語言程序

Go語言基礎數據類型之基本數據類型

Flask - 架構設計

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結