Go语言の变量

本文章主要写Go语言中使用的变量类型以及其知识点

为什么需要变量

因为变量是高级程序语言的程序的基本组成单位，如下面的代码的实例：

func getVal(num1 int, num2 int) (int, int) {
    sum := num1 + num2
    sub := num2 - num1
    return sum, sub
}

func main() {
    sum, sub := getVal(30,30)
    fmt.Println("sum=", sum,"sub=", sub)
    sum2, _ := getVal(10,30)//只取出第一个返回值
    fmt.Println("sum=", sum2)
}

以上代码中的sum,sub都是变量。

变量的介绍

变量的概念

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

变量的使用步骤

  1. 声明变量（也叫定义变量）
  2. 非变量赋值
  3. 使用变量

变量快速入门案例

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

输出结果：

变量使用注意事项

  1. 变量表示内存中的一个存储区域
  2. 该区域有自己的名称（变量名）和类型（数据类型）

示意图:

  1. Golang变量使用的三种方式

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

  2. 多变量声明

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

    package main
import "fmt"

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

    ​ 如何一次性声明多个全局变量【在go中函数外部定义变量就是全局变量】：

    //定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的声明方式，也可以改成一次性声明
var (
    n3 = 300
    n4 = 900
    name2 = "mary"
)
    1. 该区域的数据值可以在同一类型范围内不断变化（重点）
package main
import "fmt"

//变量使用的注意事项
func main(){
    //该区域的数据值可以在同一类型范围内不断变化
    var i int = 10
    i = 30
    i = 50
    fmt.Println("i=", i)
    i = 1.2//int， 原因是不能改变数据类型
}
  1. 变量在同一个作用域（在一个函数或者代码块）内不能重名
var i int = 59
i := 99//错误!

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

  • 声明变量

    • 基本语法： var 变量名 数据类型
    var a int //这就是声明了一个变量，变量名为a

var num1 float32 //这也是声明了一个变量，表示一个单精度类型的小数，变量名是num1

  • 初始化变量

    //在声明变量的时候，就给值
var a int = 45 //这就是初始化变量a
//使用细节，如过声明时就直接赋值，可以省略数据类型
var b = 400

  • 给变量赋值

    //先声明变量
var num int //默认0
//赋值
num = 780 //这就是赋值

程序中”+“号的使用

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

数据类型的基本介绍

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

整数类型

基本介绍

​ 简单地说，就是用于存放整数值的，比如0，-1，2345等等。

案例演示

//演示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)
}

整数的各个类型

  • 整形的类型
类型 有无符号 占用存储空间 表数范围
int8 有 1字节 -128~127
int16 有 2字节 -215~215-1
int32 有 4字节 -231~231-1
int64 有 8字节 -263~263-1
  • 整形的无符号类型
类型 有无符号 占用存储空间 表数范围
uint8 无 1字节 0~255
uint16 无 2字节 0~216-1
uint32 无 4字节 0~232-1
uint64 无 8字节 0~264-1 
//测试一下uint8的范围（0~255），其他的uint16,uint32,uint64类推即可
var k uint16 = 255
fmt.Println("k=", k)
  • int的其他类型的说明：
类型 有无符号 占用存储空间 表数范围 备注
int 有 32位系统4个字节
64位系统8个字节		 -231231-1
-263263-1
uint 无 32位系统4个字节
64位系统8个字节		 -0232-1
0264-1
rune 有 与int32一样 -231~231-1 等价int32，表示一个Unicode码
byte 无 与uint8等价 0~255 当要存储字符时选用byte 
//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型
//整形的使用细节
var n1 = 100 //? n1是什么类型
//这里我们给大家介绍如何查看某个变量的数据类型
//fmt.Println() 可以用于做格式化输出。
fmt.Println("n1 的类型 %T \n", n1)
  1. 如何在程序查看某个变量的字节大小和数据类型 （使用较多）
//如何在程序查看某个变量的占用字节大小和数据类型 （使用较多）
var n2 int64 = 10
//unsafe.Sizeof(n1) 是unsafe包的一个函数，可以返回n1变量占用的字节数
fmt.Printf("n2 的 类型 %T	n2占用的字节数是 %d", n2, unsafe.Sizeof(n2))
  1. Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如：年龄】
//Golang程序中整型变量在使用时，遵守保小不保大的原则，
//即：在保证程序正确运行下，尽量使用占用空间小的数据类型。
var age byte = 90
  1. bit:计算机中的最小存储单位。byte：计算机中基本存储单元。1 byte = 8 bit

小数类型/浮点型

基本介绍

顾名思义，小数类型就是用于存放小数的，如1.2，0.23，-1.91

案例演示

package main
import (
	"fmt"
)
//演示golang中小数类型使用
func main() {
	var price float32 = 89.12
	fmt.Println("price=", price)
}

运行结果如下图

小数类型分类

类型 占用存储空间 表数范围
单精度float32 4字节 -3.403E38~3.403E38
双精度float64 8字节 -1.798E308~1.798E308

说明:

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

  1. 尾数部分可能丢失，造成精度损失。 -123.0000901

说明：

  • float64的精度比float32的要准确
  • 如果我们要保存一个精度高的数，则应该选用float64
  1. 浮点型的存储分为三部分：符号位+指数位+尾数位 在存储过程中，精度会有丢失哦

浮点型使用细节

  1. Golang浮点类型有固定的范围和字段长度，不受具体的操作系统的影响。

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

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

    • 十进制数形式：如：5.12 .512（必须有小数点）
    • 科学计数法形式：如： 5.1234e2 = 5.12 * 10 ^ 2 5.12E-2 = 5.12/(10^2)

  4. 通常情况下，应该使用float64，因为它精度更高。

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

//科学计数法形式：如： 5.1234e2 = 5.12 * 10 ^ 2      5.12E-2 = 5.12/(10^2)
num8 := 5.1234e2 // 5.1234 * 10 ^ 2
num8 := 5.1234E2 // 5.1234 * 10 ^ 2

字符类型

基本介绍

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

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而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)
}

运行结果：

对上述代码的说明

  1. 如果我们保存的字符在ASCII表中，比如[0-1，a-z,A-Z] 我们可以直接保存到byte中
  2. 如果我们要保存的字符的对应码值大于255，这时我们可以考虑使用int类型保存
  3. 如果我们需要按照字符的方式输出，此时就需要进行格式化输出，即fmt.Printf("%c",c1)

字符类型使用细节

  1. 字符常量是用单引号（”)括起来的单个字符。例如var c1 byte = 'a',car c2 int = '中',var c3 byte = '9'
  2. Go中允许使用转义字符’\‘来将其后面的字符转变为特殊字符型常量。例如：var c3 char = '\n' （\n表示换行符）
  3. Go语言的字符使UTF-8编码，如果想查询字符对应的utf8码值，请点击[链接](查看字符编码（UTF-8） (mytju.com)). 英文字母占1个自己，汉字占3个字节
  4. 在Go中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8编码的码值。
  5. 可以直接给某个变量赋一个数字，然后按格式化输出%c,会输出该数字对应的Unicode字符，如
var c4 int = 22269 //22269 -> '国'
fmt.Printf("c4 = %c\n", c4)
  1. 字符类型可以进行运算，它相当于一个整数，因为每个字符都有对应的Unicode码。
var n1 = 10 + 'a'   // 10+97 = 107
fmt.Printf("n1 = %c\n", n1) //输出为k

字符类型本质探讨

  1. 字符型存储到计算机中，需要将字符对应的码值（整数）找出来
    • 存储： 字符 –> 对应码值 –> 二进制 –> 存储
    • 读取： 二进制 –> 码值 –> 字符 –> 读取
  2. 字符和码值的对应关系是通过字符编码表决定的（这是规定）
  3. Go语言的编码都统一成了UTF-8。这非常的方便，再也没有编码乱码的困扰了。

布尔类型

基本介绍

  1. 布尔类型，又名bool类型，bool类型数据只允许取值true和false
  2. bool类型占1个字节
  3. bool类型适用于逻辑运算，一般用于程序流程控制（之后会详细了解）
    • if条件控制语句
    • for循环控制语句

案例演示

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
}

运行结果

string类型

基本介绍

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

案例演示

package main
import (
	"fmt"
)
//演示Golang中string类型的使用
func main() {
	//string的基本使用
	var address string = "北京长城 厉害了1234 hello world！"
	fmt.Println(address)
}

string的注意事项和细节

  1. Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，中文乱码问题不会再困扰程序员。
  2. 字符串一旦赋值了，字符串就不能修改了：在Go中字符串是不可变的。
var str = "hello"
str[0] = 'a'    //这里不能修改str的内容，也就是说Go中的字符串是不可变的
  1. 字符串的两种表示形式
    1. 双引号，会识别转义字符
    2. 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击，输出源代码等效果。

【案例演示】

package main
import (
	"fmt"
)
//演示Golang中string类型的使用
func main() {
	//string的基本使用
	address := "abc\nabc"
	fmt.Println(address)

	str2 := `
	package main
	import (
		"fmt"
	)
	//演示Golang中string类型的使用
	func main() {
		//string的基本使用
		var address string = "北京长城 厉害了1234 hello world！"
		fmt.Println(address)
	}
	`
	fmt.Println(str2)
}

运行结果:

  1. 字符串拼接方式
//字符串拼接方式
var str = "hello" + "world"
str += " haha!"
  1. 当一行字符串太长时，需要用到多行字符串，可以如下处理
//当一个拼接的操作很长时，怎么办？可以分行写，但是注意，需要将+保留在上一行。
str4 := "hello" + "world" + "hello" + "world" + "hello" + 
"world" + "hello" + "world" + "hello" + "world" +
"hello" + "world"
fmt.Println(str4)

基本数据类型的默认值

基本介绍

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

基本数据类型的默认值

数据类型 默认值
整形 0
浮点型 0
字符串 “”
布尔类型 false

基本数据类型的相互转换

基本介绍

Golang和java/C不同，Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中的数据类型不能自动转换。

基本语法

表达式T(v)将值v转换为类型T

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

v：就是需要转换的变量

案例演示

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)

注意事项

  1. Go中，数据类型的转换可以是从 表示范围小–>表示范围大，也可以从 表示范围大–>表示范围小
  2. 被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化！
var i int32 = 100
//被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
fmt.Printf("i type is %T\n", i) // int32
  1. 在转换中，比如将 int64 转换成 int8 【-128~127】，编译时不会报错，只是转换的结果按溢出处理。和我们希望的结果不一样。因此在转换时，需要考虑范围。
//在转换中，比如将 int64  转成 int8 【-128---127】 ，编译时不会报错，
//只是转换的结果是按溢出处理，和我们希望的结果不一样
var num1 int64 = 999999
var num2 int8 = int8(num1) // 
fmt.Println("num2=", num2)

课堂练习

  • 练习1

如何修改一下代码，使之正确

func main() {
    var n1 int32 = 12
    var n2 int64
    var n3 int8
    n2 = n1 + 20
    n3 = n1 + 20
}

答案：

func main() {
    var n1 int32 = 12
    var n2 int64
    var n3 int8
    n2 = (int64)(n1) + 20     //int32 --> int64错误
    n3 = (int8)(n1) + 20      //int32 --> int8 错误
}
  • 练习2
var n1 int32 = 12
var n3 int8
var n4 int8
n4 = int8(n1) + 127 //编译通过，值溢出
n3 = int8(n1) + 128 //编译不通过
fmt.Println(n4)

基本数据类型和string的转换

基本介绍

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

基本类型转string类型

  • 方式1：fmt.Sprintf(“%参数”，表达式) 【这个比较灵活】

    • 函数的介绍：

      //func Sprintf
func Sprintf(format string,a ...interface{}) string
//Sprintf根据format参数生成格式化的字符串并返回该字符串。

      参数需要和表达式的数据类型相匹配

    • 案例演示

    package main
import (
	"fmt"
)
//演示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("%d", num2)
	fmt.Printf("str type %T str=%q\n", str, str)
	
	str = fmt.Sprintf("%d", b)
	fmt.Printf("str type %T str=%q\n", b, b)

	str = fmt.Sprintf("%d", mychar)
	fmt.Printf("str type %T str=%q\n", mychar, mychar)
}
    • 运行结果
    str type string str="99"
str type string str="%!d(float64=23.456)"
str type bool str=%!q(bool=true)
str type uint8 str='h'

  • 方式2：使用strconv包的函数

    func FormatBool(b bool) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
func FormatInt(i int64, base int) string
func FormatUint(i uint64, base int) string
    • 案例说明
    package main
import (
	"fmt"
	"strconv"
)
//第二种方式strconv函数
func main() {
	var num3 int = 99
	var num4 float64 = 23.456
	var b2 bool = true
	var str string //空str
	str = strconv.FormatInt(int64(num3), 10)
	fmt.Printf("str type %T str=%q\n", str, str)

	//strconv.FormatFloat(num3, '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)
}
    • 运行结果
    str type string str="99"
str type string str="23.4560000000"
str type string str="true"
str type string str="4567"

string类型转基本数据类型

  • 使用时strconv包的函数
func ParseBool(str string)(value bool,err error)
func ParseFloat(s string,bitSize int)(f float64, err error)
func ParseInt(s string, base int, bitSize int)(i int64,err error)
func ParseUint(s string, b int, bitSize int)(n uint64,err error)

  • 案例演示

    package main
import (
	"fmt"
	"strconv"
)
//第二种方式strconv函数
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)
}
    • 运行结果
    b type bool b=true
n1 type int64 n1=1234590
n2 type int n2=1234590
f1 type float64 f1=123.456

  • 说明一下

    因为返回的是int64或者float64，所以如果希望得到int32，float32等，要进行如下处理：

    var num5 int 32
num5 = int32(num)

string转基本数据类型的注意事项

​ 在将string类型转成基本数据类型时，要确保string类型能够转成有效的数据，比如我们可以把“123”，转成一个整数，但是我们不能将”hello”转成一个整数，如果这样做，Golang直接将其转成0，其他类型也是一样的道理.float–>0 bool –> false

  • 案例说明：
//注意
var str4 string = "hello"
var n3 int64 = 11
n3, _ = strconv.ParseInt(str4, 10, 64)
fmt.Printf("n3 type %T n3=%v\n", n3, n3)

指针

基本介绍

  1. 基本数据类型，变量存的就是值，也叫值类型
  2. 获取变量的地址，用&，比如: var num int, 获取num的地址： &num
  • 分析一下基本数据类型在内存的布局

  1. 指针类型，指针变量保存的是一个地址，这个地址指向的空间存的才是值，比如：var ptr *int = &num ，指针在内存的布局如图所示：
  2. 获取指针类型所指向的值，使用：，比如:var ptr *int，使用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\n", &ptr)
	fmt.Printf("ptr 指向的值=%v\n", *ptr)

}

运行结果：

ptr=0xc000014090
ptr 的地址=0xc000006030
ptr 指向的值=10
  1. 一个案例再说明

案例演示

  1. 写一个程序，获取一个int变量num的地址，并显示到终端
  2. 将num的地址赋给指针ptr，并通过ptr去修改num的值
package main
import (
	"fmt"
)
//案例演示
func main() {
	var num int = 9
	fmt.Printf("num's address=%v\n",&num)
	var ptr *int
	ptr = &num
	*ptr = 10
	fmt.Printf("num=%d\n",num)
}

运行结果：

num's address=0xc000014090
num=10

指针的课堂练习

  1. 这个代码中有无错误？
func main() {
    var a int = 300
    var ptr *int = a//错误
    //应该改成 var ptr *int = &a(取地址)
}
func main() {
    var a int = 300
    var ptr *float32 = &a //错误 类型不匹配！
}
func main() {
    var a int = 300
    var b int = 400
    var ptr *int = &a //OK
    *ptr = 100 //等价于a = 100
    ptr = &b // OK
    *ptr = 200 //b = 200
    fmt.Printf("a=%d,b=%d,*ptr=%d",a,b,*ptr)
}//输出什么内容？
/*
输出a=100,b=200,*ptr=200
*/

指针的使用细节

  1. 值类型，都有对应的指针类型，形式为 数据类型，比如说int的对应的指针就是int,float32对应的指针类型就是 *float32 依次类推。
  2. 值类型包括：基本数据类型，int 系列，float系列， bool,string，数组和结构体struct

值类型和引用类型

值类型和引用类型的说明

  1. 值类型：基本数据类型，int 系列，float系列， bool,string，数组和结构体struct
  2. 引用类型：指针、slice切片、map、管道chan、interface等都是引用类型

值类型和引用类型的使用特点

  1. 值类型：变量直接存储值，内存通常在栈中分配

示意图：

  1. 引用类型：变量存储是一个地址，这个地址对应的空间才真正存储数据（值），内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收

示意图：

  1. 内存的栈区和堆区示意图

标识符的命名规范

标识符概念

  1. Golang对各种变量，方法，函数等命名时使用的字符序列称为标识符
  2. 凡是自己可以取名字的地方都叫标识符

标识符的命名规则

  1. 由26个英文字母大小写，0-9，_ 组成
  2. 数字不可以开头。var num int //ok var 3num int // error
  3. Golang中严格区分大小写。
var num int
var Num int

说明：在Golang中，num和Num是两个不同的变量

  1. 标识符不能包含空格。
//这样8行！
var ab c int = 30
  1. 下划线”_”本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略（比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用。
// _ 是空标识符，用于占用
var _ int = 40 //error
fmt.Println(_) //错的！8行！
  1. 不能以系统保留关键字作为标识符（一共有25个），比如 break, if 等等…

标识符的案例

hello //ok
hello12 //ok
1hello //error 数字开头不可取！
h-b //error 不能使用！
x h //error 不能含有空格
h_4 //ok
_ab //ok
int //ok 但是最好别这样使用
float32 //ok 但是最好别这样使用
_ //error 不行！
Abc // ok

标识符命名注意事项

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

  1. 变量名、函数名、常量名：采用驼峰法
//举例
var stuName string = "tom"   //形式： xxxYyyZzz...
var goodPrice float32 = 1234.5
  1. 如果变量名、函数名、常量名首字母大写，则可以被其他的包访问：如果首字母小写，则只能在本包中使用（注:可以简单的理解成，首字母大写是公开的，首字母小写是私有的），在golang没有public，private等关键字。
  • 案例演示：
//路径:../main/main.go
package main
import(
	"fmt"
    //为了使用utils.go,引入该文件所在的包(注意你的环境变量)
	"go_code/chapter03/demo10/model"
)
//变量的使用事项
func main() {
	//该区域的数据值可以在同一类型范围内不断变化
	var i int = 10
	i = 30
	i = 50
	fmt.Println("i=",i)
	//i = 1.2 //int 原因是不能改变数据类型

	//变量在同一个作用域（在一个函数或者在代码块内）不能重名
	//var i int = 59
	//i := 99
	// 我们使用utils.go 的heroName 包名，标志符
	fmt.Println(model.HeroName)
}
/***********************************************/
// 路径： ../model/utils.go
package model

var HeroName string = "吴用"

系统保留关键字

保留关键字介绍

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

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

系统的预定义标识符

预定义标识符介绍

除了保留关键字外，Go还提供了36个预定的标识符，其包括基础数据类型和系统内嵌函数

append bool byte cap close complex
complex64 complex128 uint16 copy false float32
float64 imag int int8 int16 uint32
int32 int64 iota len make new
nil panic uint64 print println rea
recover string true uint uint8 uintprt

Go语言の变量这节结束啦！辛苦啦！