基本类型

虽然从底层而言，所有的数据都是由比特组成，但计算机一般操作的是固定大小的数，如整数、浮点数、比特数组、内存地址等。进一步将这些数组织在一起，就可表达更多的对象，例如数据包、像素点、诗歌，甚至其他任何对象。Go语言提供了丰富的数据组织形式，这依赖于Go语言内置的数据类型。这些内置的数据类型，兼顾了硬件的特性和表达复杂数据结构的便捷性。

基本类型汇总

基本数据类型 长度(字节) 默认值 说明
bool 1 false
byte 1 0 uint8
rune 4 0 Unicode Code Point, int32
int, uint 4或8 0 32 或 64 位
int8, uint8 1 0 -128 ~ 127, 0 ~ 255，byte是uint8 的别名
int16, uint16 2 0 -32768 ~ 32767, 0 ~ 65535
int32, uint32 4 0 -21亿~ 21亿, 0 ~ 42亿，rune是int32 的别名
int64, uint64 8 0
float32 4 0.0
float64 8 0.0
complex64 8
complex128 16
uintptr 4或8 以存储指针的 uint32 或 uint64 整数
复杂数据类型 长度(字节) 默认值 说明
array 值类型
struct 值类型
string "" UTF-8 字符串
slice nil 引用类型
map nil 引用类型
channel nil 引用类型
interface nil 接口
function nil 函数

布尔类型

truefalse
    var b bool = true

==!=

布尔值并不会隐式转换为数字值0或1，反之亦然。必须使用一个显式的if语句辅助转换：

// 布尔类型转换为0或者1
func btoi(b bool) int{
    if b {
        return 1
    }
    return 0
}

// 数字转换为布尔类型
func itob(i int) bool { return i != 0 }

整形

intuintuintptr
intuintuintptr
intuint
int8int16int32int64

无符号整形：

uint8uint16uint32uint64

用不同的进制来表示整数：
十进制：

    var Decimal int = 12

二进制：

    var Binary int = 0b1100

八进制：

    var Octal int = 0o14

十六进制：

    var Hexadecimal int = 0xc

fmt.printf()

    func main() {
        var Decimal int = 12
        var Binary int = 0b1100
        var Octal int = 0o14
        var Hexadecimal int = 0xCvar

        fmt.Printf("10进制数 %d 表示的是: %d \n", Decimal, Decimal)     //12
        fmt.Printf("2进制数 %b 表示的是: %d \n", Binary, Binary)           //12
        fmt.Printf("8进制数 %o 表示的是: %d \n", Octal, Octal)             //12
        fmt.Printf("16进制数 %X 表示的是: %d \n", Hexadecimal, Hexadecimal)    //12
    }

Go0b0o0x

补充：

fmt.Printf()

浮点型

float32float64
float32math.MaxFloat32float64math.MaxFloat64
0.0
float32float64
package main

func main() {
    var f float64 = 3.1415926
    fmt.Printf("保留两个位小数：%.2f",f)    //3.14
    fmt.Printf("保留两个位小数：%.3f",f)    //3.142
}

float64mathfloat64float64int
func IntFromFloat64(x float64) int {
    if math.MinInt32 <= x && x <= math.MaxInt32 { 
        whole, fraction := math.Modf(x)
        if fraction >= 0.5 {
            whole++
        }
        return int(whole)
    }
    panic(fmt.Sprintf("%g is out of the int32 range", x))
}

复数

复数分为：

    complex64 的实部和虚部为32位，
    complex128 的实部和虚部为64位。

复数的简单使用：

    var c1 complex64 = 5 + 10i
    fmt.Printf("The complex64 is: %v", c1)
    // 输出： 5 + 10i

函数 real(c) 和 imag(c) 可以分别获得相应的实数和虚数部分。

byte 和 rune 类型

'
    var testRune := '国'
    var testByte := 'a'
    fmt.Printf("字符的类型为：%T",testRune)    //rune
    fmt.Printf("字符的类型为：%T",testRune)    //byte

Unicoderune

rune 类型为 int32 的别名
byte 类型为 uint8 的别名范围为 (0~255)

字符串

Gointboolfloat32float64 GoUTF-8GoASCII
    var str string = "hello，世界！”

byterunestring
helloascii104,101,108,108,111[]bytestring
    import (
        "fmt")

    func main() {
        var mystr01 string = "hello"
        var mystr02 [5]byte = [5]byte{104, 101, 108, 108, 111}
        fmt.Printf("mystr01: %s\n", mystr01)
        fmt.Printf("mystr02: %s", mystr02)
    }

输出的结果为：

    mystr01: hello
    mystr02: hello

stringbyte
    import (
        "fmt")

    func main() {
        var mystr string = "hello"
        fmt.Printf("mystr: %d\n", len(mystr))
        // 结果为：mystr: 5
    }

Go+
    import (
        "fmt"
    )
    func main() {        
        s := "hel" + "lo," 
        s += "world!" 
        fmt.Println(s) 
        //输出 “hello, world!”
    }

Gostrings.Join()bytes.Buffer()

转义字符

转义字符
  • \n：换行符
  • \r：回车符
  • \t：tab 键
  • \u 或
  • \U：Unicode 字符
  • \：反斜杠自身

例如：

    import "fmt"

    func main() {
        str := "hello \n world"
        fmt.Println(str)
        // 输出：
        //hello
        // world
    }

多行字符

 反引号
    import "fmt"

    func main() {
        str := `hello world 
    你好，世界`
        fmt.Println(str)
    }
    // 输出：
    //hello world 
    //你好，世界

细节决定成败!
个人愚见，如有不对，恳请扶正!