基本数据类型包含：整型、浮点型、布尔类型以及字符串，这几种数据类型在几乎所有的编程语言中都支持。

1、整数类型

// mac 上执行
var x int
x = 100
fmt.Println(x, reflect.TypeOf(x)) // 查看数据类型 reflect.TypeOf(变量)
//输出
100 int

// 测试超出数据范围
var x int8
x = 300
fmt.Println(x)
//输出报错
constant 300 overflows int8

2、进制转换

// 十进制转化
var a int = 10
fmt.Println("%d \n", a) //10      占位符 %d 表示十进制
fmt.Println("%b \n", a) //1010    占位符 %b 表示二进制
fmt.Println("%o \n"，a) //12      占位符 %o 表示八进制
fmt.Println("%x \n", a) //a       占位符 %x 表示十六进制
// 八进制转换
var b int = 020
fmt.Printf("%o \n", b)  // 20
fmt.Printf("%d \n", b)  // 16
fmt.Printf("%x \n", b)  // 10
fmt.Printf("%b \n", b)  // 10000
//十六进制转换
var c int = ox12
fmt.Printf("%d \n", c)  // 18
fmt.Printf("%o \n", c)  // 22
fmt.Printf("%x \n", c)  // 12
fmt.Printf("%b \n", c)  // 10010

3、浮点型

float类型

float类型分为 float32 和 float64 两种类型，这两种浮点型数据格式遵循 IEEE 754 标准。

// 正常输出
var f1 float32
f1 = 3.14
fmt.Println(f1,reflect.TypeOf(f1)) //3.14  float32
var f2 float64
f2 = 3.14
fmt.Println(f2,reflect.Typeof(f2)) //3.14  float64
f3 := 3.14
fmt.Println(f3,reflect.Typeof(f3)) //3.14 float64 默认是 64

//格式化输出
f1 := 3.1415926
fmt.Printf("f1:%f !",f1, reflect.TypeOf(f1))//默认保留6位
// 打印结果
f1:3.141593 !%!(EXTRA *reflect.rtype=float64) // 第6位值是根据第7位的大小4舍五入
// 只保留3位格式化输出
f1 := 3.1415926
fmt.Printf("f1:%.3f !",f1) // f1:3.142 !

科学计数表示

科学计数是我们经常用的，那生活中我们一般怎么弄呐：
2000 =>  2 * (10**3)
0.003 => 3 * (10**-3)

4、布尔类型

布尔类型是最基本的数据类型之一，只有两个值：true 和 false，分别代表逻辑判断中的真和假，主要应用在条件判断中。

fmt.Println(1==1) // true
fmt.Println(2<1) // false
fmt.Println(2>1) // true
b := 3 > 1
fmt.Println(b,reflect.TypeOf(b)) //true bool

5、字符串

字符串是最基本也是最常用的数据类型，是通过双引号将多个字符按串联起来的一种数据，用于展示文本。

// 只有 双引号 "" 表示字符串
var name = "hello sbhong"
fmt.Println(name, reflect.TypeOf(word)) // hello sbhong.  string
// 单引号 '' 表示单个字符
var world = 'h'
fmt.Println(word, reflect.TypeOf(word)) 
// 输出结果
104 int32  //104：字节数，表示字节

索引和切片

字符串在内存中是一段连续存储空间

索引是从0开始计数的，不支持负索引

name := "hello yuan"
fmt.Println(name) // hello yuan
// 索引取值
var v = name[1] // 101 => 字节数，表示字节
var m = string(name[1]) // e => 通过string函数强制转成 字符串
// 负索引取值，不支持
var v = name[-1] // invalid string index -1 (index must be non-negative)

// 切片 => 数据对象[start:end]
name := "hello yuan"
// 切片取值 slice[start:end] => 顾头不顾尾
a := name[2:5]
fmt.Printf(a) // llo
// 顾头又顾尾,当 end 缺省，起始位到整个连续区域末尾
b := name[2:]
fmt.Printf(b) // llo yuan
// 当开始位缺省默认为 start 默认为0
c := name[:5]
fmt.Printf(c) // hello

字符串拼接

Go语言字符串拼接 是通过 + 号方式拼接

// 字符串拼接
firstName := "hello "
lastName := "word"
fullName := firstName + lastName //通过 + 号拼接生成一个新的字符串
fmt.Println(fullName)

转义字符

1. 转义字符用 \ 表示
2. \ 后面跟一个普通符号可以赋予这个普通符号特殊功能。eg: \n
3. \ 后面跟一个特殊符号，转义符号会将其变成普通符号。 eg：\

Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示：

举个例子：

package  main
import "fmt"
func main(){   
    fmt.Println("str := \"c:\\Code\\lesson01\\go.exe\"")
}
// 打印结果
str := "c:\Code\lesson01\go.exe"

打印多行字符串

Go语言里面要定义个多行字符串，就必须使用 反引号(``) 字符：

myHobby := `
第一行语句
第二行语句
....
`
fmt.Println(myHobby)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

格式化输出

格式化输出，只能用 fmt.Printf() 函数打印

// 整形和浮点型
fmt.Printf("%b\n", 12)  // 二进制表示:1100
fmt.Printf("%d\n", 12)  // 十进制表示:12
fmt.Printf("%o\n", 12)  // 八进制表示:14
fmt.Printf("%x\n", 12)  // 十六进制表示:c
fmt.Printf("%X\n", 12)  // 十六进制表示：c
fmt.Printf("%f\n", 3.1415)  // 有小数点而无指数：3.141500
fmt.Printf("%.4f\n", 3.1415)  // 3.1415
fmt.Printf("%.3f\n", 3.1415)  // 3.142
fmt.Printf("%e\n", 1000.25)  // 科学计数法:  1.000250e+03
// 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出:  3.1415
fmt.Printf("%g\n", 3.1415)
// 布尔占位符
fmt.Printf("%t\n", true)
// 字符串
fmt.Printf("my name is %s,my age is %d","sgg",18)
// 打印数据类型  %T
fmt.Printf("%T", true) //bool
fmt.Printf("%T", 10) // int
/*用的比较多 %v 不知道要插入类型值，这个时候就要插进去
这个时候就用%v，不管什么类型都能插入进去。*/
name,age := "hello qigao", 22
fmt.Printf("%v",name) // hello qigao
fmt.Printf("%v",age) // 22

字符串常用方法

names := "sbh,sgg,xhz"
// 1. len(str) 求字符串的长度
namesLen := len(names)
fmt.Println(namesLen) // 11
//2. 分割：strings.Split，想看Split 入参条件：command + Split 看源码
namesData := strings.Split(names, ",")
fmt.Println(namesData, reflect.TypeOf(namesData)) 
// 打印结果，返回数据格式
[sbh sgg xhz] []string
//3. strings.contains：是否包含
ret := strings.Contains(names, "sbh")
fmt.Println(ret, reflect.TypeOf(ret)) //true  bool
// strings.Join(a[] string, sep string)：Join 操作 ：与Split 配合使用
namesData := []string{"sbh","sgg","xhz"}
name := strings.Join(namesData,":")
fmt.Println(name) //sbh:sgg:xhz
//strings.HasPrefix/strings.HasSuffix：前缀/后缀判断：返回bool类型
names := "sbh,sgg,xhz"
ret := strings.HasPrefix(names, "sbh") // 以sbh为前缀
fmt.Println(ret) // true
ret := strings.HasSuffix(names, "xhz") // 以xhz为后缀
fmt.Println(ret) // true
//strings.Index()/stringsLastIndex() : 字符串出现的位置
names := "sbh,sgg,xhz"
ret := strings.Index(names, "s") // s出现的第一个位置
fmt.Println(ret) // 0
ret := strings.LastIndex(names, "s") // s出现最后一个位置
fmt.Println(ret) // 4

6、类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

// go 语言，强类型，无法做到暗转换
s := "hello word"
fmt.Println(s + 2) // 会报错，两个不同的数据类型
// js 语言，弱类型，可以做到暗转换
var s = "hello" + 11
console.log(s) // hello11

强制类型转换的基本语法如下：

Type(表达式)

其中，Type表示要转换的类型。表达式包括变量、复杂算子和函数返回值。

// 把数字转换成对应的ASCII码
x := 100
fmt.Print(string(x)) //d
x := 65
fmt.Print(string(x)) //A
// 数字转换为字符串: strconv.Itoa(x)
x := 65
fmt.Println(strconv.Itoa(x), reflect.TypeOf(strconv.Itoa(x)))
//字符串转换为整型，浮点不行： strconv.Atoi()
x := "100"
y,_ := strconv.Atoi(x)
fmt.Println(strconv.Atoi(x)) // 100 <nil> => nil 表示 空值，相当月 null
fmt.Println(y,reflect.TypeOf(y)) // 100 int