go 变量

变量介绍

概念

 变量使用的基本步骤

1) 声明变量

2) 赋值

3) 使用

案例：

package main

import "fmt"

func main() {
	// 定义变量
	var age int
	// 为变量age赋值
	age = 18
	// var age int = 18   // 一步定义加赋值
	// 使用变量
	// fmt.Println("age=",age)
	fmt.Printf("age=%d",age)
}

变量使用注意事项

1) 变量表示内存中的一个存储区域

2) 该区域有自己的名称（变量名）和类型（数据类型）

3) Golang变量使用三种方式

第一种：指定变量类型，声明后若不赋值，使用默认值

第二种：根据值自行判定变量类型（类型推导）

第三种：省略var，注意:=左侧的变量不应该是已经声明过的，否则会导致编译器错误

示例：

总结: 变量类型一旦确定,不能改变 变量不能重复使用

4) 多变量声明

    在编程中，有时我们需要一次性声明多个变量，Golang也提供这样的语法

package main

import "fmt"

func main() {
	// 多变量声明
	var width, height int = 100, 50 // 方式一
        //var name, age = "egon", 18 //方式一也可以一次定义不同类型的变量
	//width, height := 100, 50 // 方式二
        //width, sex := 100, "man" // 方式二也可以一次定义不同类型的变量
	var  (
		name = "egon"
		age = 18
		//height int

	) // 方式三
	fmt.Println(width, height)
	fmt.Println(name, age)
} 

补充：

一次性声明多个全局变量

　

5) 该区域的数据值可以在同一类型范围内不断变化

6)变量在同一个作用域内不能重名

7)变量=变量名+值+数据类型

8)Golang的变量如果没有赋初值，编辑器会使用默认值，比如int默认值为0，string默认值为空

总结：

//变量类型在定义阶段一旦确定,不能改变


//变量不能重复使用

//变量命名规范
	-变量命令建议用驼峰，（大小写有特殊意义）
	-go文件命名建议用 下划线
    - 一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线
    -大写字母和小写字母是不同的：Name和name是两个不同的变量
    -关键字和保留字都不建议用作变量名


//关键字

break      default       func     interface   select
case       defer         go       map         struct
chan       else          goto     package     switch
const      fallthrough   if       range       type
continue   for           import   return      var


//保留字
内建常量: true false iota nil
内建类型:  int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

内建函数: make len cap new append copy close delete
          complex real imag
          panic recover

 变量的数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间

go有一下几种数据类型：

序号	类型和描述
1	布尔型 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2	数字类型 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3	字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
4	派生类型: 包括： (a) 指针类型（Pointer） (b) 数组类型 (c) 结构化类型(struct)，类似class (d) Channel 类型 (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型，类似set

 数字类型

整型：（分有符号和无符号）

序号	类型和描述
1	uint8 无符号 8 位整型 (0 到 255)
2	uint16 无符号 16 位整型 (0 到 65535)
3	uint32 无符号 32 位整型 (0 到 4294967295)
4	uint64 无符号 64 位整型 (0 到 18446744073709551615)
5	int8 有符号 8 位整型 (-128 到 127)
6	int16 有符号 16 位整型 (-32768 到 32767)
7	int32 有符号 32 位整型 (-2147483648 到 2147483647)
8	int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

整型的使用细节：

 1）Golang各整数类型分，有符号和无符号，int uint的大小和系统有关

2）Golang的整型默认声明为int形

3）如何在程序中查看某个变量的字节大小和数据类型

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	// 查看某个变量的字节大小和数据类型
	var num2 int64 = 100
	fmt.Printf("num2的数据类型：%T num2占用的字节数是：%d", num2, unsafe.Sizeof(num2)) // num2的数据类型：int64 num2占用的字节数是：8
}

补充：导入多个包的写法推荐

import (
	"fmt"
	"unsafe"
)

4）Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。

5）bit：计算机中最小的存储单位，byte：计算机中基本存储单元

浮点型

序号	类型和描述
1	float32 IEEE-754 32位浮点型数
2	float64 IEEE-754 64位浮点型数
3	complex64 32 位实数和虚数
4	complex128 64 位实数和虚数

浮点型分类

 上图说明：

1）关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位

2）尾数部分可能丢失，造成精度损失。

package main

import "fmt"

// 演示float类型
func main() {
	// 精度损失示例,-123.0000901
	var num float32 = -123.0000901
	fmt.Printf("num为：%v", num) //num为：-123.00009
	
}

3）浮点型的存储分为三部分：符号位+指数位+尾数位 在存储过程中，精度会有丢失

浮点型使用细节：

1）Golang浮点类型有固定的范围和字段长度，不受OS的影响

2）Golang的浮点型默认声明为float64类型

3）浮点型常量有两种表示形式

    十进制数形式：如：5.12  .512(这个表示0.512)（必须有小数点）

    

    科学计数法形式：如：5.1234e2 = 5.1234 * 10的2次方    5.1234E-2 = 5.1234/10的2次方

    

    

4）通常情况下，应该使用float64，因为它比float32更精确

其他数字类型

以下列出了其他更多的数字类型：

序号	类型和描述
1	byte 类似 uint8
2	rune 类似 int32
3	uint 32 或 64 位
4	int 与 uint 一样大小
5	uintptr 无符号整型，用于存放一个指针

补充：

byte演示：

注意：byte用''单引号

var a byte = 'a'
fmt.Printf("a的数据类型：%T\n", a)  //a的数据类型：uint8
fmt.Println("a=",a)  // a=97

字符类型

基本介绍

Golang中没有专门的字符类型，如果要存储单个字符（字母），一般使用byte来保存。

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的，也就是说对于传统的字符串是由字符组成的。而go的字符串不同，它是由字节组成的。

演示：

package main
import "fmt"

// 演示字符类型使用
func main()  {
	var c1 byte = 'a'
	var c2 byte = '0'   //字符0
	var c3 byte = 0
	//当我们直接输出byte值时，就是输出了对应的字符的ascii值
	fmt.Printf("c1=%v,c2=%v,c3=%v\n", c1, c2, c3)   //c1=97,c2=48,c3=0
	//如果我们希望c1,c2输出对应字符，需要使用格式化输出
	fmt.Printf("c1=%c,c2=%c\n", c1, c2)   //c1=a,c2=0
	//var c4 byte = '北'  //overflow溢出
	var c4 int = '北'
	fmt.Printf("c4=%c,c4对应的码值:%d\n", c4, c4) //c4=北,c4对应的码值:21271
}

对上面代码说明：

1）如果保存的字符在ascii表中，比如[0-1,a-z,A-Z...]直接可以保存到byte

2）如果我们保存的字符对应的码值大于255，这时可以考虑使用int类型保存

3）如果我们需要按照字符的方式输出，这时我们需要格式化输出，即 fmt.Printf("c1=%c,c2=%c\n", c1, c2)

字符类型使用细节

1）字符常量是用单引号''括起来的单个字符。如：

var c1 byte = 'a'
var c2 int = '中'
var c3 byte = '9'

2)Go中允许使用转义字符'\'来将其后的字符转变为特殊字符型常量，例如

var c3 = "\n" // \n表示换行符

3）Go语言的字符是用utf-8编码

4）在Go中字符的本质是一个整数，直接输出时，是该字符对应的utf-8编码的码值

5）可以直接给某个变量赋一个数字，然后按格式化输出%c，会输出该数字对应的unicode字符

6）字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码

字符类型的本质

1）字符类型存储到计算机中，需要将字符对应的码值（整数）找出来

    存储：字符==》对应的码值==》二进制==》存储

    读取：二进制==》码值==》字符==》读取

2）字符和码值的对应关系是通过字符编码表决定的（是规定好的）

3）Go语言的编码都统一成了utf-8，相对其它的编程语言来说，非常的方便，很统一，再也没有编码的困扰了

布尔类型：bool

基本介绍：

1）布尔类型也叫bool类型，bool类型数据只允许取值true和false

2）bool类型占1个字节

3）bool类型适用于逻辑运算，一般用于程序流程控制

例如：

if条件控制语句

for循环控制语句

布尔类型使用演示：

package main

import (
	"fmt"
	"unsafe"
)

//bool类型使用演示
func main()  {
	var b = true
	fmt.Println("b=", b)  //b= true
	//注意事项
	//1. bool类型占用空间是1个字节
	fmt.Printf("变量b占用字节大小为:%d\n", unsafe.Sizeof(b))   //变量b占用字节大小为:1
	//2. bool类型只能取true或false，例如0和1，空和非空都是不可以的
	var c bool = 1   //cannot use 1 (type untyped int) as type bool in assignment
	fmt.Println(c)
}

字符串类型：string

基本介绍：

字符串就是一串固定长度的字符连接起来的字符序列，go的字符串是由单个字节连接起来的，Go语言的字符串的字节使用utf-8编码标识Unicode文本

演示：

package main

import "fmt"

//string类型使用演示
func main()  {
	//string的基本使用
	var address string = "上海·Hello,world!" //上海·Hello,world!
	fmt.Println(address)

}

字符串注意事项和使用细节：

1）Go语言的字符串的字节使用utf-8编码标识Unicode文本，这样Golang统一使用utf-8编码，乱码问题不会再困扰程序员

2）字符串一旦赋值了，字符串就不能修改了，在Go中字符串是不可变的

3）字符串的两种表示形式

1. 双引号，会识别转义字符
2. 反引号，以字符串的原生形式输出，包括换行符和特殊字符，可以实现防止攻击、输出源代码等效果

演示：

package main

import "fmt"

//string类型使用演示
func main()  {
	//双引号和反引号的使用
	str1 := "abc\nABC"
	fmt.Println(str1)
	// 使用反引号
	str2 := `abc\nABC` //abc\nABC
	str3 := `
	////string的基本使用
	//var address string = "上海·Hello,world!" //上海·Hello,world!
	//fmt.Println(address)
	`
	fmt.Println(str2)
	fmt.Println(str3)

}

// 执行结果
abc
ABC
abc\nABC

	////string的基本使用
	//var address string = "上海·Hello,world!" //上海·Hello,world!
	//fmt.Println(address)

4）字符串拼接方式

Go基本数据默认值

基本介绍：

    在go中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在go中，默认值又叫零值。

基本数据类型默认值一览表：

 

演示：