基本数据类型

Golang 数据类型

• Golang 程序中整形变量在使用时，遵守保大不保小的原则，即：在保证程序正确运行的前提下，尽量使用占用空间小的数据类型
• Golang 数据类型默认值 ```golang var a int // 0 var b float32 // 0 var c float64 // 0 var isMarried bool // false var name string // "" //这里的%v 表示按照变量的值输出 fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v", a, b, c, isMarried, name) }

```

类型分类

• 值类型：变量直接存储值，内存通常在栈中分配
• 基本数据类型 int 、float 、bool、string、数组、结构体(struct)
• 引用类型：变量存储的是一个地址，这个地址对应的空间才是真正存储的数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收。
• 指针、切片(slice)、map、管道(chan)、interface

标识符的命名规范

标识符概念

• 1）Golang 对各种变量、方法等命名时使用的字符序列称为标识符
• 2）凡是自己可以起名字的地方都叫标识符

标识符的命名规则

• 1）由26个英文字母大小写，0-9，_组成
• 2）数字不可以开头。
• 3）Golang中严格区分大小写。
• 4）标识符不能包含空格。
• 5）下划线"_"本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用。
• 6）不能以系统保留关键字作为标识符，关键字如下：
• break case chan const continue
• default defer else fallthrough for
• func go goto if import
• interface map package range return
• select struct switch type var

package main
import "fmt"

//演示golang中标识符的使用
func main() {

    //Golang中严格区分大小写
    //golang 中 认为 num 和 Num是不同的变量
    var num int = 10
    var Num int = 20
    fmt.Printf("num=%v Num=%v\n", num, Num)

    //标识符不能包含空格
    //var ab c int = 30

    //_ 是空标志符，用于占用
    // var _ int = 40 //error
    // fmt.Println(_)

    var int int = 90
    fmt.Println(int)
}

int 整数类型

类型	有无符号	占用存储空间	表示范围	备注
int8	有	1字节	-128～127
int16	有	2字节	-2^15~2^15-1
int32	有	4字节	-2^31~2^31-1
int64	有	8字节	-2^63~2^63-1
uint8	无	1字节	0～255
uint16	无	2字节	0~2^16-1
uint32	无	4字节	0~2^32-1
uint64	无	8字节	0~2^64-1
int	有	4/8字节	-2^31~2^31-1 / -2^63~2^63-1	取决于操作系统是32/64位
uint	无	4/8字节	0~2^32-1 / 0~2^64-1	取决于操作系统是32/64位
rune	有	4字节	-2^31~2^31-1	等价于int32 表示一个unicode
byte	无	1字节	0～255	等价uint8 存储字符时选用

package main

// import "unsafe"
import (
    "fmt"
    "unsafe"
)

// 演示golang中整数类型使用
func main() {

    var i int = 1
    println("i=", i)

    //测试一下int8的范围 -128~127,
    //其它的 int16, int32, int64,类推。。。
    var j int8 = 127
    println("j=", j)

    //测试一下 uint8的范围(0-255),其它的 uint16, uint32, uint64类推即可
    var k uint16 = 255
    println("k=", k)

    //int , uint , rune , byte的使用
    var a int = 8900
    println("a=", a)
    var b uint = 1
    var c byte = 255
    println("b=", b, "c=", c)

    //整型的使用细节
    var n1 = 100 // ? n1 是什么类型
    //这里我们给介绍一下如何查看某个变量的数据类型
    //printf() 可以用于做格式化输出。
    fmt.Printf("n1 的 类型 %T \n", n1)

    //如何在程序查看某个变量的占用字节大小和数据类型 （使用较多）
    var n2 int64 = 10
    //unsafe.Sizeof(n1) 是unsafe包的一个函数，可以返回n1变量占用的字节数
    fmt.Printf("n2 的 类型 %T  n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2))

}

float 浮点型

• 浮点数 = 符号位 + 指数位 + 尾数位
• 浮点类型有固定的范围和字段长度，不受OS影响
• 默认声明位 float64 类型，通常推荐使用 float64

package main

import (
    "fmt"
    "unsafe"
)

// 演示golang中小数类型使用
func main() {

    var price float32 = 89.12
    println("price=", price)
    var num1 float32 = -0.00089
    var num2 float64 = -7809656.09
    println("num1=", num1, "num2=", num2)

    //尾数部分可能丢失，造成精度损失。 -123.0000901
    var num3 float32 = -123.0000901
    var num4 float64 = -123.0000901
    println("num3=", num3, "num4=", num4)

    //Golang 的浮点型默认声明为float64 类型
    var num5 = 1.1
    fmt.Printf("num5的数据类型是 %T \n", num5)

    //十进制数形式：如：5.12       .512   (必须有小数点）
    num6 := 5.12
    num7 := .123 //=> 0.123
    println("num6=", num6, "num7=", num7)

    //科学计数法形式
    num8 := 5.1234e2   // ? 5.1234 * 10的2次方
    num9 := 5.1234e2   // ? 5.1234 * 10的2次方
    num10 := 5.1234e-2 // ? 5.1234 / 10的2次方 0.051234

    println("num8=", num8, "num9=", num9, "num10=", num10)

    var c1 rune = '北'
    println("c1=", c1, unsafe.Sizeof(c1))

}

bool 布尔类型

package main

import (
    "unsafe"
)

// 演示golang中bool类型使用
func main() {
    var b = false
    println("b=", b)
    //注意事项
    //1. bool类型占用存储空间是1个字节
    println("b 的占用空间 =", unsafe.Sizeof(b))
    //2. bool类型只能取true或者false，不能是其他的任何值

}

byte 字节类型

• 单引号表示的是码值，双引号表示字符，注意赋值时的使用
• Golang 中字符默认使用UTF-8编码

package main

import (
    "fmt"
)

// 演示golang中字符类型使用
func main() {

    var c1 byte = 'a'
    var c2 byte = '0' //字符的0

    //当我们直接输出byte值，就是输出了的对应的字符的码值
    // 'a' ==>
    println("c1=", c1)
    println("c2=", c2)
    //如果我们希望输出对应字符，需要使用格式化输出
    fmt.Printf("c1=%c c2=%c\n", c1, c2)

    //var c3 byte = '北' //overflow溢出
    var c3 int = '北' //overflow溢出
    fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3)

    //可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode 字符
    var c4 int = 22269 // 22269 -> '国' 120->'x'
    fmt.Printf("c4=%c\n", c4)

    //字符类型是可以进行运算的，相当于一个整数,运输时是按照码值运行
    var n1 = 10 + 'a' //  10 + 97 = 107
    println("n1=", n1)

}

string 字符串类型

• 字符串就是一串固定长度连接起来的字符序列。
• Golang的字符串是由单个字节连接起来的。
• Golang中的字符串的字节使用UTF-8编码表示标识Unicode文本

package main

import (
    "fmt"
)

//演示golang中string类型使用
func main() {
    //string的基本使用
    var address string = "北京长城 110 hello world!"
    println(address)

    //字符串一旦赋值了，字符串就不能修改了：在Go中字符串是不可变的
    //var str = "hello"
    //str[0] = 'a' //这里就不能去修改str的内容，即go中的字符串是不可变的。

    //字符串的两种表示形式(1) 双引号, 会识别转义字符 (2) 反引号，
    //以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、
    //输出源代码等效果  【案例演示】
    str2 := "abc\nabc"
    println(str2)

    //使用的反引号 ``
    str3 := ` 
    package main
    import (
        "fmt"
        "unsafe"
    )

    //演示golang中bool类型使用
    func main() {
        var b = false
        println("b=", b)
        //注意事项
        //1. bool类型占用存储空间是1个字节
        println("b 的占用空间 =", unsafe.Sizeof(b) )
        //2. bool类型只能取true或者false

    }
    `
    println(str3)

    //字符串拼接方式
    var str = "hello " + "world"
    str += " haha!"

    println(str)
    //当一个拼接的操作很长时，怎么办，可以分行写,但是注意，需要将+保留在上一行.
    str4 := "hello " + "world" + "hello " + "world" + "hello " +
        "world" + "hello " + "world" + "hello " + "world" +
        "hello " + "world"
    println(str4)

array 数组类型

struct 结构体类型