Golang学习（一）：变量

1. 变量概述

1.1 三种变量声明方式

1. 指定变量类型，声明后若不赋值，使用默认值
2. 根据值自行判定变量类型(类型推导)
3. 省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误

package main
import "fmt"

func main() {
	//golang的变量使用方式1
	//第一种：指定变量类型，声明后若不赋值，使用默认值
	// int 的默认值是0 , 其它数据类型的默认值后面马上介绍
	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)

}

1.2 一次性声明多个变量

package main
import "fmt"

//定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的声明方式，也可以改成一次性声明
var (
	n3 = 300
	n4 = 900
	name2 = "mary"
)

func main() {
	
	//该案例演示golang如何一次性声明多个变量
	// var n1, n2, n3 int 
	// fmt.Println("n1=",n1, "n2=", n2, "n3=", n3)

	//一次性声明多个变量的方式2 
	// var n1, name , n3 = 100, "tom", 888
	// fmt.Println("n1=",n1, "name=", name, "n3=", n3)

	//一次性声明多个变量的方式3, 同样可以使用类型推导
	// n1, name , n3 := 100, "tom~", 888
	// fmt.Println("n1=",n1, "name=", name, "n3=", n3)

	//输出全局变量
	//fmt.Println("n1=",n1, "name=", name, "n2=", n2)
	fmt.Println("n3=",n3, "name2=", name2, "n4=", n4)

}

2. +号的使用

1. 两边都是数值型，加法运算
2. 两边字符串，拼接

package main
import "fmt"

//演示golang中+的使用
func main() {
	
	var i = 1
	var j = 2
	var r = i + j //做加法运算
	fmt.Println("r=", r)

	var str1 = "hello "
	var str2 = "world"
	var res = str1 + str2 //做拼接操作
	fmt.Println("res=", res)

}

3. 数据类型

1. uint表示无符号，表示范围更大
2. byte不能存汉字
3. 还有rune（类似int32）
   

4. 整数类型

package main
// import "fmt"
// import "unsafe"
import (
	"fmt"
	"unsafe"
)

//演示golang中整数类型使用
func main() {
	
	var i int = 1
	fmt.Println("i=", i)

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

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

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

	//整型的使用细节
	var n1 = 100 // ? n1 是什么类型
	//这里我们给介绍一下如何查看某个变量的数据类型
	//fmt.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))

	

}

总结：

1. Golang整数类型划分：有符号，无符号，int uint 大小和系统有关
2. Golang整型默认为int
3. 查看某个变量数据类型：使用 %T

fmt.Printf("n2 的 类型 %T ", n2)

4. 查看某个变量的字节大小：%d输出一个数，使用 unsafe.Sizeof()

fmt.Printf("n2占用的字节数是 %d ", unsafe.Sizeof(n2))

5. 整型变量在使用时遵守保大不保小原则，即：在保证程序正运行情况下，尽量使用占用空间小的数据。如：年龄
6. bit：计算机中最小存储单位。byte：计算机中基本存储单元。1 byte = 8 bit。

5. 浮点类型

package main
import (
	"fmt"
	"unsafe"
)

//演示golang中小数类型使用
func main() {
	
	var price float32 = 89.12
	fmt.Println("price=", price)
	var num1 float32 = -0.00089
	var num2 float64 = -7809656.09
	fmt.Println("num1=", num1, "num2=", num2)

	//尾数部分可能丢失，造成精度损失。 -123.0000901
	var num3 float32 = -123.0000901
	var num4 float64 = -123.0000901
	fmt.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
	fmt.Println("num6=", num6, "num7=", num7)

	//科学计数法形式
	num8 := 5.1234e2 // ? 5.1234 * 10的2次方
	num9 := 5.1234E2 // ? 5.1234 * 10的2次方 shift+alt+向下的箭头
	num10 := 5.1234E-2 // ? 5.1234 / 10的2次方 0.051234
	
	fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)

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

}

总结：

1. Golang 浮点类型有固定的范围和字段长度，不受OS影响
2. Golang 浮点类型默认为float64类型
3. 浮点型两种表示方法：十进制带小数点，带e或E
4. 通常情况下使用 float64 ，更精准

6. 字符类型

1. Golang没有专门类型，存储单个字符，一般byte保存
2. 字符串是一串固定长度字符拼接起来的字符序列。Go的字符串由字节组成。
   
   

package main
import (
	"fmt"
)

//演示golang中字符类型使用
func main() {
	
	var c1 byte = 'a'
	var c2 byte = '0' //字符的0

	//当我们直接输出byte值，就是输出了的对应的字符的码值
	// 'a' ==> 
	fmt.Println("c1=", c1)
	fmt.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
	fmt.Println("n1=", n1)

}

总结：

1. 要保存的字符在ASCII表，byte保存
2. 大于255，用int保存
3. 字符方式输出需要格式化， %c

7. 布尔类型

package main
import (
	"fmt"
	"unsafe"
)

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

8. String类型

package main
import (
	"fmt"
)

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

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

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

	//使用的反引号 ``
	str3 := ` 
	package main
	import (
		"fmt"
		"unsafe"
	)
	
	//演示golang中bool类型使用
	func main() {
		var b = false
		fmt.Println("b=", b)
		//注意事项
		//1. bool类型占用存储空间是1个字节
		fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
		//2. bool类型只能取true或者false
		
	}
	`
	fmt.Println(str3)

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

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

9. 基本数据类型默认值

	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)

10. 基本数据类型转换

1. 表达式T（v），将值 v 转为 T 类型
2. 转换的是值，变量本省类型没有变化

package main
import (
	"fmt"
)

//演示golang中基本数据类型的转换
func main() {

	var i int32 = 100
	//希望将 i => float
	var n1 float32 = float32(i)
	var n2 int8 = int8(i)
	var n3 int64 = int64(i) //低精度->高精度

	fmt.Printf("i=%v n1=%v n2=%v n3=%v \n", i ,n1, n2, n3)
	
	//被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
	fmt.Printf("i type is %T\n", i) // int32

	//在转换中，比如将 int64  转成 int8 【-128---127】 ，编译时不会报错，
	//只是转换的结果是按溢出处理，和我们希望的结果不一样
	var num1 int64 = 999999
	var num2 int8 = int8(num1) // 
	fmt.Println("num2=", num2)

}

11. 基本数据类型和String转换

11.1 基本数据类型转String

1. 第一种方式
   
2. 第二种 strconv 函数
   

package main
import (
	"fmt"
	_ "unsafe"
	"strconv"
)

//演示golang中基本数据练习转成string使用
func main() {

	var num1 int = 99
	var num2 float64 = 23.456
	var b bool = true
	var myChar byte = 'h'
	var str string //空的str

	//使用第一种方式来转换 fmt.Sprintf方法

	str = fmt.Sprintf("%d", num1)
	fmt.Printf("str type %T str=%q\n", str, str)

	str = fmt.Sprintf("%f", num2)
	fmt.Printf("str type %T str=%q\n", str, str)

	str = fmt.Sprintf("%t", b)
	fmt.Printf("str type %T str=%q\n", str, str)

	str = fmt.Sprintf("%c", myChar)
	fmt.Printf("str type %T str=%q\n", str, str)

	//第二种方式 strconv 函数 
	var num3 int = 99
	var num4 float64 = 23.456
	var b2 bool = true

	str = strconv.FormatInt(int64(num3), 10)
	fmt.Printf("str type %T str=%q\n", str, str)
	
	// strconv.FormatFloat(num4, 'f', 10, 64)
	// 说明： 'f' 格式 10：表示小数位保留10位 64 :表示这个小数是float64
	str = strconv.FormatFloat(num4, 'f', 10, 64)
	fmt.Printf("str type %T str=%q\n", str, str)

	str = strconv.FormatBool(b2)
	fmt.Printf("str type %T str=%q\n", str, str)

	//strconv包中有一个函数Itoa
	var num5 int64 = 4567
	str = strconv.Itoa(int(num5))
	fmt.Printf("str type %T str=%q\n", str, str)

}

11.1 String转基本数据类型

package main
import (
	"fmt"
	"strconv"
)

//演示golang中string转成基本数据类型
func main() {

	var str string = "true"
	var b bool
	// b, _ = strconv.ParseBool(str)
	// 说明
	// 1. strconv.ParseBool(str) 函数会返回两个值 (value bool, err error)
	// 2. 因为我只想获取到 value bool ,不想获取 err 所以我使用_忽略
	b , _ = strconv.ParseBool(str)
	fmt.Printf("b type %T  b=%v\n", b, b)
	
	var str2 string = "1234590"
	var n1 int64
	var n2 int
	n1, _ = strconv.ParseInt(str2, 10, 64)
	n2 = int(n1)
	fmt.Printf("n1 type %T  n1=%v\n", n1, n1)
	fmt.Printf("n2 type %T n2=%v\n", n2, n2)

	var str3 string = "123.456"
	var f1 float64
	f1, _ = strconv.ParseFloat(str3, 64)
	fmt.Printf("f1 type %T f1=%v\n", f1, f1)


	//注意：
	//不能成功转的变成默认值
	var str4 string = "hello"
	var n3 int64 = 11
	n3, _ = strconv.ParseInt(str4, 10, 64)
	fmt.Printf("n3 type %T n3=%v\n", n3, n3)

}

12. 指针

1. 基本数据类型，变量存的就是值，也叫值类型
2. 获取变量地址，用&
3. 指针变量存的是一个地址，这个地址指向的空间存的才是值
4. 使用 *ptr 获取 ptr 所指向的值

package main
import (
	"fmt"
)

//演示golang中指针类型
func main() {

	//基本数据类型在内存布局
	var i int = 10
	// i 的地址是什么,&i
	fmt.Println("i的地址=", &i)
	
	//下面的 var ptr *int = &i
	//1. ptr 是一个指针变量
	//2. ptr 的类型 *int
	//3. ptr 本身的值&i
	var ptr *int = &i 
	fmt.Printf("ptr=%v\n", ptr)
	fmt.Printf("ptr 的地址=%v", &ptr) 
	fmt.Printf("ptr 指向的值=%v", *ptr)

}

13. 值类型和引用类型

1. 值类型：int, float, string, 数组, 结构体…
   

2. 引用类型：指针，slice切片，map，管道chan，interface
   

14. 标识符命名规范

1. 数字不能开头
2. 驼峰法
3. 变量名，函数名，常量名首字母大写是public，首字母小写是private