第三章 Golang变量-阿里云开发者社区

3.1 为什么需要变量

程序就是一个世界，不论是那种语言程序都是其程序的基本组成单位

变量介绍

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的们牌号。通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量（值）

3.2 变量的使用基本步骤

声明变量（有人又叫：定义变量）
赋值
使用

3.3 变量快速入门案例

package main
import "fmt"
func main(){
  // 定义一个变量/声明变量
  var i int;
  // 给i 赋值
  i = 10;
  // 使用变量
  fmt.Println("i=",i)
}

3.4 变量定义方式

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

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

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

package main
import "fmt"
func main(){
  // golang的变量使用方式：
    var i int
  // 第一种：指定变量类型，声明后不赋值，使用默认值
  fmt.Println("i",i)
  // int 的默认值是0，其他再说
  // 第二种呢，根据值自行推导
  var num = 123 // int
  var num = 211.11
  fmt.Println("num",num)
  // 第三种 省略var 注意左侧的变量不应该是已经声明
  // 下面的方式等价 var 
  // :=  的：不能省略
  name := "tom"
  fmt.Println("name",name)
}

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

package main
import "fmt"
// 变量使用的注意事项
func main(){
  // 该区域的数据可以在同一范围内不断变化
  var i int = 10;
  i = 30;
  i = 50;
  fmt.Println("i=",i)
  i = 1.2// int不是字符型 原因是不能改变数据类型
}

6.在同一作用域中（在一个函数中或代码块）内不能重名

// 在同一作用域中（在一个函数中或代码块）内不能重名
  i := 99 // 错误的 和 var i=99相同

7.变量=变量名+值+数据类型，这点请大家注意

8.Golang的变量没有赋初始值，编译会使用默认值，比如int 默认值 0，小数默认值0，string默认值是空

3.5变量的声明，初始化和赋值

3.6 +号使用

如果+号两边都是数字就是运算。如果+两边都是字符串就是链接。

变量类型

3.8整数类型

例子

import "fmt"
// 演示go中整数类型使用g
func main(){
  var i int = 1
  fmt.Println("i=",i)
  // 测试一下int的范围 -128~127
  var j int8 = 127
  fmt.Println("j=",j)
}

无符号类型

int的无符号

// uint8的范围
  var k uint16 = 255
  fmt.Println("k=",k)

int 的其他区类型说明

// 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)

整数的使用细节

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

2.Golang的整型默认声明为int型

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

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

5.bit：计算机中的最小存储单位，byte：计算机中基本存储单位。【二进制再详细说】

一个byte = 8个bit

// 整数的使用细节
  var n1 = 100
  // fmt.Printf() 可以用于做格式化输出
  fmt.Printf("n1 的类型%T",n1)
  // 如何在程序中查看某个变量的字节大小和数据类型
  var n2 int64 = 10
  // unsafe.Sizeof(n1) 是unsafe包的一个函数 可以返回n2变量占用的字节数
  fmt.Printf("\nn2 的类型%T n2的字节数是%d",n2,unsafe.Sizeof(n2))
  // Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如年龄】
  var age byte = 800

3.9 浮点类型

小数类型就是用来存储小数的，比如 120.121 1.322

例子

package main
import "fmt"
// 演示golang中小数（浮点）
func main(){
  var price float32 = 321.212
  fmt.Println("price=",price)
}

小数类型的分类

对上图的说明

1.浮点数=符号位+指数位+尾数位

2.位数部分可能丢失，造成精度损失

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

package main
import "fmt"
// 演示golang中小数（浮点）
func main(){
  var price float32 = 321.212
  fmt.Println("price=",price)
  var num1 float32 = -0.0089
  var num2 float64 = -70000.09
  fmt.Println("num1=",num1,"num2=",num2)
  var num3 float32 = -13221.3212
  var num4 float64 = -13221.3212
  fmt.Println("num3=",num3,"num4=",num4)
}

说明精确度float64>float32

3.10 字符类型

基本介绍

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

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

案例

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

如果保存的字在ASCII表的，比如【0-1，a-z，A-Z】直接可以保存到byte
如果我们保存的字符对应的字符对应码大于255，这时我们可以考虑使用int类型保存
如果我们需要按照字符的方式输出，我们需要格式化输出，即fmt.Print(“%c”,c1)

字符类型使用细节

1.字符常量是用单引号来定义的

2.Go中允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量，例如：varchar = ‘a’ // ‘n’ 表示换行符

3.Go语言的字符使用utf-8编码

英文字母1个字符，汉字3个字节

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

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

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

字符类型本质讨论

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

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

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

字符和码值的关系是通过字符编码表决定的
Go语言的编码统一成了utf-8，非常方便，很统一。再也没有编码乱的困扰了

bool类型

package main
import (
  "fmt"
  "unsafe"
)
func main(){
  var b = false
  fmt.Println("b=",b)
  // 注意
  // 1. bool类型占用的空间是1个字节
  fmt.Println("b 的占用空间=",unsafe.Sizeof(b))
  // 2. bool 类型只能是true或false
  // b = 1
}

3.11 字符串类型

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

package main
import (
  "fmt"
)
func main(){
  var address string = "北京长城 12额32213212"
  fmt.Println(address)
}

3.12 string使用方法注意事项

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

2. 字符串一旦赋值就不能再改变

3. 字符串的两种表现形式

a. 双引号，会识别转义字符

b.反引号，以字符串的原生形式输出，包括注释换行等其他字符，可以防止工具，输出源码等

字符拼接方式

// 字符串拼接方式
  var str4 = "hello" + "world"
  str4 += "hell"
  fmt.Println(str4)

当字符串过长时候+ 要保存在上面

var str5 = "hello" + "world" + 
   "hello" + "world"
   fmt.Printf(str5)

3.13基本数据类型默认值

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

案例

var a int // 0
  var b float32 // 0
  var c float64 // 0
  var isMarryied bool // false
  var name string // ""
  // 这里的%v 表示按照变量的原值输出
  fmt.Printf("a=%d,b=%v,c=%v,isMarryied=%v name=%v",a,b,c,isMarryied,name)

3.14 基本数据类型的相互转换

基本介绍

表达式T（v）将值v转换为T

T:就是数据类型比如int32，int64，float32等

v：就是需要转换的变量

package main
import (
  "fmt"
)
//  演示
func main(){
  var i int32 = 100
  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",i,n1,n2,n3)
}

细节说明

Go中，数据类型的转换可以是从表示范围小->表示范围大，也可以范围大-》范围小
被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化
在转换中，比如将int64转成【-128-127】，编译时不会报错，只是转换的结果按溢出处理，和我们想要的结果不一样。

3.15 基本数据类型和string的转换

在程序开发中，我们经常讲基本数据类型转换成string或者将string转成基本数据类型。

基本类型转string

方式一：fmt.Sprintf(“%参数”，表达式）

函数的介绍：

package main 
import (
  "fmt"
)
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("%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)
  // str = strconv.FormatFloat(num,'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)

string类型基本数据类型

使用时strconv包的函数

ParseBool,ParseFloat,ParseInt,ParseUint

案例演示

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",b,b)
  var str2 string = "1234567890"
  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 = "12.323"
  var f1 float64
  f1, _= strconv.ParseFloat(str3,64)
  fmt.Printf("f1 type %T f1=%v\n",f1,f1)
}

3.16 指针

基本介绍

1.基本数据类型，变量存的就是值，也叫值类型

2.获取变量的地址，用&，比如：var num int 获取num的地址：&num

分析一下基本数据类型在内存的布局

3.指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值

比如：var ptr *int = &num

举例说明：指针存在内存的布局

package main
import (
  "fmt"
)
func main(){
  // 基本数据类型存在内存布局
  var i int = 10
  // 1 的地址是什么，&1
  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)
}

3.18 标识符的命名规范

标识符概念

1.Golang对各种变量，方法，函数等命名时使用的字符序列称为标识符

2.凡是自己可以起名字的地方都叫标识符

标识符的命名规则

1.由26个英文字母大小写，0-9，组成
2. 不可以数字开头
3. Golang中严格区分大小写
4. 标识符不能含有空格
5.下划线“”本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其他的标识符，但是它对应的值会被忽略（比如：忽略某个返回值）。所以仅能被作为站位符使用，不能作为标识符使用。

6.不能使用系统函数做标识符，比如if,break等…

标识符案例

hello // ok
hello2 // ok
1hello // error
h-b  // error
x h // error
h_4 // ok
_ab // ok
int // ok,不可以
float32 // ok,不可以
_ //error 
Abc // ok

标识符命名注意事项

1.包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库不要冲突fmt

2.变量名，函数名，常量名：采用驼峰法。

3.如果变量名，函数名，常量名首字母大写，则可以被其他的包访问：如果首字母小写，则只能在本包中使用（注：可以简单的理解成，首字母大写是公有的，首字母小写是私有的）

3.19 系统保留关键字

保留关键字介绍：在Go中，为了简化代码编译过程中对代码的解析，其定义的保留关键字只有25个，详见如下

系统预定义标识符

感谢大家观看，我们下次见

第三章 Golang变量

3.1 为什么需要变量

变量介绍

3.2 变量的使用基本步骤

3.3 变量快速入门案例

3.4 变量定义方式

3.5变量的声明，初始化和赋值

3.6 +号使用

变量类型

3.8整数类型

整数的使用细节

3.9 浮点类型

3.10 字符类型

bool类型

3.11 字符串类型

3.12 string使用方法注意事项

3.13基本数据类型默认值

3.14 基本数据类型的相互转换

细节说明

3.15 基本数据类型和string的转换

3.16 指针

3.18 标识符的命名规范

3.19 系统保留关键字

热门文章

最新文章

相关课程

相关电子书

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

第三章 Golang变量

3.1 为什么需要变量

变量介绍

3.2 变量的使用基本步骤

3.3 变量快速入门案例

3.4 变量定义方式

3.5变量的声明，初始化和赋值

3.6 +号使用

变量类型

3.8整数类型

整数的使用细节

3.9 浮点类型

3.10 字符类型

bool类型

3.11 字符串类型

3.12 string使用方法注意事项

3.13基本数据类型默认值

3.14 基本数据类型的相互转换

细节说明

3.15 基本数据类型和string的转换

3.16 指针

3.18 标识符的命名规范

3.19 系统保留关键字

热门文章

最新文章

相关课程

相关电子书

推荐镜像