一．变量
1.变量的介绍
概念：
变量相当于内存中一个数据存储空间的标识，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量。
2.变量的使用
变量使用的基本步骤：
1）声明变量[定义变量]
2）赋值
3）使用
例1：
package main import "fmt" func main() { // 定义变量 声明变量 var i int // 给i赋值 i = 10 // 使用变量 fmt.Println("i:", i) }
3.GO语言变量使用注意事项：
1）变量表示内存中的一个存储区域
2）该区域有自己的名称（变量名）和类型（数据类型）
3）Golang变量使用的三种方式：
（1）第一种：指定变量类型，声明后若不赋值，使用默认值
int 的默认值为0
（2）根据值自行判断变量的类型，自行判断类型（类型推导）
（3）省略var,注意： = 左侧的变量不应该是已经声明过的，否则会导致编译错误
例子：
package main import "fmt" func main() { // GO语言变量使用注意事项： // 第一种：指定变量类型，声明后若不赋值，使用默认值 var i int fmt.Println("i:", i) // 第二种：根据值，自行判断类型（类型推导） var num = 10.11 fmt.Println("num:", num) // 第三种：省略var,注意： = 左侧的变量不应该是已经声明过的，否则会导致编译错误 // var name string // name = "tom" name := "tom" // 与上面两行代码等价 fmt.Println("name:", name) }
4）多变量声明
有时候需要一次性声明多个变量，Golang也想这样的语法。
package main import "fmt" func main() { // 如果一次性声明多个变量 var n1, n2, n3 int n1 = 3 n2 = 5 n3 = 7 fmt.Println("n1+n2+n3=", n1+n2+n3) // 法二： var m1, name, m3 = 100, "tom", 888 fmt.Println("m1:", m1, "name:", name, "m3:", m3) // 法三： var ( a = 1 b = 2 c = 3 ) fmt.Println("a=", a, " ", "b=", b, " ", "c=", c) }
5）该区域的数据值可以在同一类型范围内不断变化，不能改变数据类型
package main import "fmt" func main() { // 该区域的数据值可以在同一类型范围内不断变化 var i int = 10 i = 30 i = 50 fmt.Println("i=",i) }
6） 变量在同一个作用域内不能重名
可以重复赋值，但是不能重复定义
7）变量=变量名+值+数据类型 ，这一点注意
8）Golang的变量如果没有赋值，编译器会使用默认值，
比如：
int 默认值0
string 默认值空串
程序+号的使用
当左右两边都是数值类型时，则做加法运算
当左右两边都字符串类型时，则做字符串拼接
例：
package main import "fmt" func main() { // 该区域的数据值可以在同一类型范围内不断变化 var i int = 10 var j int = 20 var o = i + j // 做加法运算 fmt.Println("o=",o) var m = "zero" var n = "one" var p = m + n fmt.Println("p=",p) // 做字符串拼接 }
二．变量的数据类型
数据类型：基础数据类型 复杂数据类型
基本数据类型：
数值型(int,uint,float32,byte)，
字符型(使用byte来保存单个字符)，
布尔型(bool),
字符串(string)
complex
复杂数据类型：
指针(Pointer),数组，结构体(struct,相当于类)，管道(channel)，函数，切片(slice)，接口(interface)，map(有点像集合)
1.整数类型的使用
用于存放整数值
例：定义的类型不要超过这个类型的范围
package main
import "fmt"
func main() {
// 测是int8范围
var i int8 = -128
// var j int8 = -129 // 这个超出范围会报错
// .main.go:9:15: constant -129 overflows int8
fmt.Println("i:",i)
// fmt.Println("j:",j)
// 测试uint8的范围
var a uint8 = 255
fmt.Println("a=",a)
// .main.go:17:16: constant 256 overflows uint8
// var b uint8 = 256
// fmt.Println("b=",b)
}
整型的使用细节
（1）Golang各整数类型分：有符号和无符号，int uint 的大小和系统有关
（2）Golang的整型默认声明为int型
（3）如何在程序查看某个的字节大小和数据类型
（4）Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。
（5）bit: 计算机中的最小的存储单位，byte:计算机中基本存储单位。
例子：
package main
import "fmt"
import "unsafe"
func main() {
// 测是int8范围
var i int8 = -128
// var j int8 = -129 // 这个超出范围会报错
// .main.go:9:15: constant -129 overflows int8
fmt.Println("i:", i)
// fmt.Println("j:",j)
// 测试uint8的范围
var a uint8 = 255
fmt.Println("a=", a)
// .main.go:17:16: constant 256 overflows uint8
// var b uint8 = 256
// fmt.Println("b=",b)
// 测试数据类型 注意这个打印是：Printf
v1 := "中国你好"
v2 := 20
var v3 byte = 65
fmt.Printf("v1的数据类型为：%T
", v1)
fmt.Printf("v2的数据类型为：%T
", v2)
fmt.Printf("v2的数据类型为：%T
", v3)
// 查看某个变量的字节大小和数据类型
var v int8 = 10
fmt.Printf("v的类型 %T v占用的字节数是是%d", v, unsafe.Sizeof(v))
}
2.浮点类型(小数类型)
用户存放有小数的数据
（1）关于浮点数在机器中存放形式的简单说明，浮点数= 符号位+指数位+尾数位
（2）尾数部分可能丢失，造成精度损失
（3）浮点型的存储分为三部分: 符号位+指数位+尾数位，在存储过程中，可能精度损失
例：
package main
import "fmt"
func main() {
// 浮点类型的使用
var price float32 = 19.23
fmt.Println("price:",price)
// 尾数部分可能丢失，造成精度损失
var num3 float32 = -123.2345623456
var num4 float64 = -123.2345623456
fmt.Println("num3:",num3)
fmt.Println("num4:",num4)
// 打印结果如下：
// num3: -123.234566
// num4: -123.2345623456
}
浮点数使用细节：
（1）GOlang浮点类型有固定的范围和字段长度，不受具体操作系统的影响
（2）Golang的浮点默认声明为float64类型
// 测试浮点型的默认精度
var b = 1.11
fmt.Printf("b的类型为%T", b)
（3）浮点型常量有两种形式
十进制数形式： 如：5.12 .512 (必须有小数点)
科学计算法形式：如： 5.1234e2 = 5.12 * 10 的2次方 5.12E-2 = 5.12/10的2次方
（4）通常情况下，应该使用float64,因为比float32更精确
3.字符类型(char)
Golang中没有专门的字符类型，如果要存储单个字符（字母），一般使用byte来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。
例：
package main
import "fmt"
func main() {
// golang 字符类型的例子
var c1 byte = 'a'
var c2 byte = '0'
// 直接输出byte的值的时候，直接输出相应的码值
fmt.Println("c1:", c1)
fmt.Println("c2:", c2)
// 如果我们希望输出对于字符，需要格式化输出
// 格式化输出使用的是Printf
// 注意Printf打印不自动换行
fmt.Printf("c1=%c ", c1)
fmt.Printf("c1=%c
", c1)
// 第一个输出北 第二个输出北对应的码值
var c3 int = '北'
fmt.Printf("c3=%c c3=%d",c3,c3)
}
总结：如果保存的字符在ascii码中，直接保存到byte中，如果超过了可以使用int或者其他类型。如果需要输出码值，则使用格式化输出。
字符类型的使用细节：
（1）字符常量是用单引号(‘’) 括起来的的单个字符。
（2）Go中允许使用转义字符’’ 来将其后的字符转变为特殊字符型常量。
（3）Go语言的字符使用UTF-8编码
英文一个字节 汉字三个字节
（4）在Go中，字符的本质是一个整数，直接输出时，是该字符对应的utf-8编码的码值。
（5）可以直接给某个变量赋一个数字，然后按格式化输出时%c,会输出该数字对应的Unicode字符。
（6）字符型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。
字符的存储：字符==》对应ascii码值==》二进制==》存储
字符的读取：二进制==》码值==》字符==》读取
Go语言的编码统一是UTF-8，不会有编码乱码的问题。
4.布尔类型(bool)
bool类型占用一个字节
1) 布尔类型也叫bool类型，bool类型数据只允许取值true和false
2) bool类型占1个字节
3) bool类型适于逻辑运算，一般用于程序流程控制 [if,for]
例：
package main
import "fmt"
import "unsafe"
func main(){
// 注意事项
// 1. bool类型占用存储空间是1个字节
var b = false
fmt.Println("b=",b)
fmt.Println("b的占用空间=",unsafe.Sizeof(b))
// 2.bool类型只能去true或者false 【不能用0或1代替】
}
5.字符串类型（string）
字符串就是一串固定长度的字符连接起来的字符序列。GO的字符串是由单个字符连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
例：
package main
import "fmt"
func main(){
// string 的基本使用
var address string = "东北松花江"
fmt.Println("address:",address)
}
注意事项和使用细节：
（1）Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，乱码问题不会产生。
（2）字符串一旦赋值了，字符串就不能修改，在GO中字符串是不可变的。
（3）字符串的两种表示形式：
1)双引号，会识别转义字符
2)反引号，以字符串的原生形式输出，包括换行和特殊符号，可以实现防止攻击、输出源代码等效果。
（4）字符串拼接方式 使用加号
（5）当一行字符串太长时，需要用到多行字符串可以使用（加号放在上一行）
var str1 string = “2dpqjwdqodjqdqdq” +
“swqhsqjspqsjq”
6.基础数据类型的转换
Golang数据类型转换需要显示转换，不能自动转换。
基本语法：
表达式T(v)将值V转换成为类型T
T：就是数据类型，比如int32,int64,float32等等
V：就是需要转换的变量
例1：
package main
import "fmt"
import "reflect"
func main(){
// Goalng基本类型的数据转换
var i int = 100
// 将i转成float类型
var n1 float32 = float32(i)
fmt.Println("n1=",n1)
fmt.Println(reflect.TypeOf(n1))
var n2 int64 = int64(i)
fmt.Println("n2=",n2)
fmt.Println(reflect.TypeOf(n2))
}
注意事项：
1）Go中，数据类型的转换可以是从表示范围小--》表示范围大，也可以范围大--->范围小
2）被转换的是变量存储的数据，就是变量值，变量本身的数据类型并没有发生变化
3）在转换中，比如将int64转成int8,编译时不会出错，如果int64的值大于int8的范围，那么转换时会发生溢出处理。与想要的结果不一致。
4）如果在数据类型的计算中，一个数不等于值的范围直接编译失败，而如果在范围内是因为计算后得到的值大于这个类型，编译不出错，会发送溢出。
(1)基础数据类型和String的转换
基础类型转String类型
方式1：fmt.Sprintf(“%参数”，表达式)
1）参数需要和表达式的数据类型匹配
2）fmt.Sprintf() 会返回转换后的字符串
方式2：使用strconv包的函数
例子：
package main
import "fmt"
import "strconv"
func main() {
// 基本数据类型转String类型
var num1 int = 99
var num2 float64 = 23.234
var bool_num bool = true
var mychar byte = 'h'
var str string
// 第一种方式 fmt.Sprintf 方法
str = fmt.Sprintf("%d", num1)
fmt.Printf("str type %T str=%q
", str, str) // 输出类型和数值
str = fmt.Sprintf("%f", num2)
fmt.Printf("str type %T str=%q
", str, str) // 输出类型和数值
str = fmt.Sprintf("%t", bool_num)
fmt.Printf("str type %T str=%q
", str, str) // 输出类型和数值
str = fmt.Sprintf("%c", mychar)
fmt.Printf("str type %T str=%q", str, str) // 输出类型和数值
// 第二种方式 strconv 函数
var num3 int = 99
var num4 float64 = 23.234
var bool_num2 bool = true
// var mychar2 byte = 'g'
var str2 string
str2 = strconv.FormatInt(int64(num3),10)
fmt.Printf("str2 type %T str=%q
", str2, str2)
// fmt.Printf("str type %T str=%q
", str2, str2)
// 说明： 'f' 格式 10，表示小数位表示十位 64 表示这个小数为float64
str2 = strconv.FormatFloat(num4,'f',10,64)
fmt.Printf("str2 type %T str=%q
", str2, str2)
str2 = strconv.FormatBool(bool_num2)
fmt.Printf("str2 type %T str=%q
", str2, str2)
}
例2：
strconv.Itoa()函数的参数是一个整型数字，它可以将数字转换成对应的字符串类型的数字。
package main
import (
"fmt"
"strconv"
)
func main() {
number := 97
result := strconv.Itoa(number)
fmt.Printf("%T
", number)
fmt.Println(result)
fmt.Printf("%T
", result)
}
(2)string类型转基本数据类型
使用时strconv包的函数
例:
package main
import (
"fmt"
"strconv"
)
func main() {
var str string = "true"
var b bool
// 说明
// 1.strconv.ParseBool(str) 函数会返回两个值(varlue bool,err error)
// 2.因为我只想获取到value
// _ 下划线就是忽略错误的意思
b, _ = strconv.ParseBool(str)
fmt.Printf("b type %T b=%v
", b, b)
// 字符串转成整数类型
var str2 string = "123490"
var n1 int64
var n2 int
n1, _ = strconv.ParseInt(str2, 10, 64)
fmt.Printf("n1 type %T b=%v
", n1, n1)
n2 = int(n1)
fmt.Printf("n2 type %T b=%v
", n2, n2)
// 字符串转成float64类型
var str3 string = "123.456"
var f1 float64
f1, _ = strconv.ParseFloat(str3, 64)
fmt.Printf("f1 type %T b=%v
", f1, f1)
// 返回什么类型，就用什么类型接受，另外在转成的相同类型下的不同位
}
主要事项：
在将String类型转成基本数据类型时，要确保String类型能够转成有效的数据，比如我们
可以将”123”，转成一个整数，但是不能把”hello”转成一个整数，如果是这样Golang直接将其转成0。其实相当于没有转成功，字符串无法转成整型，所以变量为默认值。其他类型如果转换类型没有转成功，也是一样会变成默认值。
实例代码段如下：
// 注意: var str4 string = "helo" var n3 int64 n3,_ = strconv.ParseInt(str4,10,64) fmt.Printf("n3 type %T b=%v ", n3, n3)
基本数据类型的默认值：
整型 0
浮点型 0
字符串 “”
布尔类型 false
基础数据类型和string的转换
注意事项：
在将String类型转成基本类型数据时，要确保String类型能够有效的数据，比如把”123”,z转成一个整数，但是不能把”hello”转成一个整数，如果这样做，Golang直接将其转成0。