【3.0】Go语言基础之变量
【零】注释语法
- 注释就是对代码的解释和说明，其目的就是让人们更加轻松的了解代码。注释是开发人员的一个重要的习惯。
- 单行注释使用
//开头 - 多行注释使用
/*开头*/结尾
- 单行注释使用
// package 定义包名 main 包名
package main
// import 引用库 fmt 库名
import "fmt"
// func 定义函数 main 函数名
func main() {
// fmt 包名 . 调用 Print 函数,并且输出定义的字符串
fmt.Print("Hello Golang From dream")
// 这是单行注释
/*
这是多行注释
*/
}
【一】变量声明
- Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。
- 我们从计算机系统的角度来讲，变量就是一段或者多段内存，用于存储数据
【0】25个关键字和37个保留字
（1）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
// func 定义函数
// import 导入包
// package 声明包名
// var 定义变量的关键字
// 不能作为变量的名字
（2）37个保留字(应内建的常量、类型和内置函数)
内建常量: 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
【2】变量命名语法
-
变量的命名规则遵循驼峰命名法，即首个单词小写，每个新单词的首字母大写，例如： startDate
-
以后定义变量时，不能以数字开头，可以使用数字字母下划线组成的字符串来定义
-
变量的大小写，有特殊含义，区分大小写
-
变量定义推荐用驼峰体
- AgeOfPerson go语言和java语言推荐，python不推荐
- age_of_person 下划线方式，不推荐（go不推荐，python推荐）
-
go文件的名字，建议使用下划线（参照源码）
- java语言中：变量和文件名都推荐用驼峰
- Python中：变量名和文件名都推荐用下划线
【3】变量的定义
package main
import "fmt"
// 【1】定义变量
func main() {
// 方式一 : 完整定义 -----> var 关键字 变量名
//变量类型 = 变量值
// 定义变量名 nameOfDream ：驼峰式命名法
// 定义变量类型 string ： 文本类型
// 定义变量值 "Dream" ： 必须用双引号引起来
var nameOfDream string = "Dream"
// 定义变量后 必须使用 ，否则不会编译 ，会报错
fmt.Println(nameOfDream) // Dream
// 方式二 ： 类型推导 ----> 自动推导出变量的类型
// var关键字 变量名 = 变量值
// 没有写类型，是自动推导出来的，变量也有类型，并且是固定类型，以后不能随意改变
var age = 19 // 没有指定是 int 类型，默认是int类型
fmt.Println(age) // 19
// 查看变量名的类型
fmt.Printf("变量的类型是 :>> %T,变量的值是 :>> %d \n", age, age) // 变量的类型是 :>> int,变量的值是 :>> 19
var nameOfHope = "Hope" // 没有指定是 string 类型，但是默认是 string 类型
fmt.Println(nameOfHope) // Hope
// 查看变量名的类型
fmt.Printf("变量的类型是 :>> %T,变量的值是 :>> %s \n", nameOfHope, nameOfHope) //变量的类型是 :>> string,变量的值是 :>> Hope
// 方式三 ：简略声明 ----> 尽可能少写代码
// 变量名 := 变量值
//age = 19 // 如果上面没有定义过就会报错，这句话的意思是修改变量值
height := 180 // 变量名 := 变量值 是定义变量
fmt.Println(height) // 180
// 查看变量名的类型
fmt.Printf("变量的类型是 :>> %T,变量的值是 :>> %d \n", height, height) //变量的类型是 :>> int,变量的值是 :>> 180
}
【二】变量使用
package main
import "fmt"
// 定义全局变量
var school = "DreamCity"
// 变量支持先定义再初始化赋值，但是只支持第一种方法才能初始化
//即 var school string = ""
var height int
// 【2】变量使用
func main() {
// 变量的使用 ：修改值 / 打印值
var name string = "Dream"
fmt.Println(name) // Dream
// 修改值 ：只能修改相同类型
name = "Hope" // 修改值
// name = 19 // 这句话是会报错的,在定义阶段就固定了,以后不能随意修改变量的类型
fmt.Println(name) // Hope
fmt.Println(school) // DreamCity
school = "HopeCity"
fmt.Println(school) // HopeCity
height = 180
fmt.Println(height) // 180
}
【三】同时定义多个变量
package main
import "fmt"
// 【3】同时定义多个变量
func main() {
// 方式一 ： 逐个定义变量 (一般不用)
var name string = "Dream"
var age = 18
var gender = "男"
fmt.Println(name, age, gender) // Dream 18 男
// 方式二 ： 使用一行定义
// 支持定义同一行的多个 变量 为同一个类型
//var name1, age1, gender1 string = "Dream", 18, "男"
// 不支持定义同一行的多个 变量 属于 不同 类型 (会报错)
//var name1, age1, gender1 string,int,string = "Dream", 18, "男"
var name1, age1, gender1 = "Dream", 18, "男"
fmt.Println(name1, age1, gender1) // Dream 18 男
// 方式三 ：使用一行定义 自动推导 --- 推荐使用
name2, age2, gender2 := "Dream", 18, "男"
fmt.Println(name2, age2, gender2) // Dream 18 男
}
【四】变量要先定义，再使用
package main
import "fmt"
// 【3】变量需要先定义再使用且只能定义一次
func main() {
// 1 变量需要先定义才能使用
//name = "Dream" // 这样写是使用变量，但是没有定义
//fmt.Println(name) // 会报错，因为变量没有定义
// 2 变量只能定义一次，不能定义两次
//var name string
//var name = "Dream" // Unused variable 'name' 不能重复定义两次变量
//fmt.Println(name)
// 例外 ：使用简略声明除外
var age = 18 // 定义了变量 age
name, age := "Dream", 20 // 定义了变量name ， 但是可以写 age，表示使用/修改值，而不是定义
fmt.Println(name, age)
var age1 = 18 // 定义了变量 age
var name1, age1 = "Dream", 20 // 'age' redeclared in this block
fmt.Println(name1, age1)
}
【五】变量类型
-
基础数据类型
-
数字
-
整型
- int
- int8
- int16
- int32
- int64
-
正整数：无符号整数
- uint
- uint8
- uint16
- uint32
- uint64
-
浮点数
- float32
- float64
-
复数(正常开发中用不到)
- complex64
- complex128
-
-
字符串
- string
- 双引号或三引号包裹(不能用单引号包裹，单引号表示数字)
-
布尔
- bool
- true/false (必须小写)
-
byte
- uint8 的别名
-
rune
- int32 的别名
-
【1】数字类型
（1）整型
package main
import "fmt"
func main() {
// 【1】整型(表示正负和0)
var age int = 18
fmt.Println(age)
// [1]int8 和其他的区别在于，表示的整数的范围不一样
// 一个 int8 占 8 个比特位 即 一个 字节
// 分为 8 个小格 ， 这 8 个 小格只能放0 或 1
// 它有 2 的8次方中变化，其中第一个小格用来表示正负，所以表示数字的大小 2的7次方-1种变化
// 范围 ：2的7次方-1 -128 ~ 127
var age1 int8 = 18
fmt.Println(age1)
// [2] int16 -> 2的15次方-1
// [3] int32 -> 2的31次方-1
// [4] int64 -> 2的63次方-1
// [5] int : 分平台 (32位机器默认就是 int32 ， 同理 64 位是 int64)
}
（2）正整数(无符号整数)
package main
import "fmt"
func main() {
// 【2】无符号整型
// [1] uint8 -> 2的8次方-1 0 ~ 255
var age uint8 = 19
fmt.Println(age)
// [2] uint16 -> 2的16次方-1
// [3] uint32 -> 2的32次方-1
// [4] uint64 -> 2的64次方-1
// [5] uint : 分平台 (32位机器默认就是 uint32 ， 同理 64 位是 uint64)
}
（3）浮点型
package main
import "fmt"
func main() {
// 【3】浮点型 (小数) ： 表示的精度不一样
var salary float32 = 10.123456789 // 精确到小数点后 6 位
var salary1 float64 = 10.123456789123456789 // 精确到小数点后 15 位
fmt.Println(salary) // 10.123457
fmt.Println(salary1) // 10.123456789123457
}
（4）复数
package main
import "fmt"
func main() {
// 【4】复数
var c complex64 = 6 + 7i // 实部为 6 虚部为 7
var d complex64 = 2 + 3i // 实部为 2 虚部为 3
fmt.Println(c + d) // (8+10i)
}
【2】字符串类型
package main
import "fmt"
func main() {
// 【5】字符串 --- 只能用双引号或反引号包裹 (反引号支持换行,并且保留原来的格式)
var name = "Dream " + // 双引号这种是字符串相加
"is " +
"handsome"
var name_new = `Dream
is
handsome`
fmt.Println(name) // Dream is handsome
fmt.Println(name_new) // Dream
// is
// handsome
}
【3】布尔类型
package main
import "fmt"
func main() {
// 【7】布尔类型 -- 判断中常用
var a = true // true / false 才是布尔类型
var b = false // true / false 才是布尔类型
var c = 0 // 0 / 1 属于是数字类型，而不是布尔类型
var d = 1 // 0 / 1 属于是数字类型，而不是布尔类型
fmt.Printf("a的类型是 %T \n", a) // a的类型是 bool
fmt.Printf("b的类型是 %T \n", b) // b的类型是 bool
fmt.Printf("c的类型是 %T \n", c) // c的类型是 int
fmt.Printf("d的类型是 %T \n", d) // d的类型是 int
}
【4】byte和rune
package main
import "fmt"
func main() {
// 【8】byte 和 rune
// byte : uint8 的别名
// rune : int32 的别名
var a byte = '1'
// var a byte = '你' // 最大长度 1个字节，8个比特位，255种变化，只能表示ascii码，不能表示汉字你
//var b rune = '1'
var b rune = '你' // 最大长度 4个字节，表示一个字符，unicode编码，可以放所有的象形文字
fmt.Println(a) // 49
fmt.Println(b) // 20320
}
【5】常量和iote
（1）常量的定义和使用
package main
import "fmt"
// 常量 ：恒定不变的量，一旦定义赋值后，就不能再被更改
// 常量定义方式 ： const 关键字
// 方式一 ： const 常量名 类型 = 值
const name string = "Dream"
// 方式二 ： const 常量名 = 值
const age = 19
func main() {
fmt.Println(name) // Dream
fmt.Println(age) // 19
// name = "Hope" // Cannot assign to name --- 常量不可修改
}
（2）iota
package main
import "fmt"
// iota : 自增常量
// 同时定义多个常量
// 方式一
const name, age = "Dream", 19
// 方式二
const (
gender = "male"
class = 20
)
// 多个值赋初值
const (
a = 1 // 1
b // 如果不写赋值，则默认按照上面的赋值 即 b = 1 下面同理
c // 1
d // 1
)
// 多个值赋初值
const (
e = 1 // 1
f // 如果不写赋值，则默认按照上面的赋值 即 f = 1 下面同理
g = 99 // 99
h // 如果不写赋值，则默认按照上面的赋值 即 h = 99 下面同理
)
const (
i = iota // iota 等同于 0 即 i = 0 iota 为一个自增常量
j // 初识值为 iota 会自增 即 j = 1
k // 初识值为 iota 会自增 即 k = 2
l // 初识值为 iota 会自增 即 l = 3
)
const (
m = iota // iota 等同于 0 即 m = 0 iota 为一个自增常量
n // 初识值为 iota 会自增 即 n = 1
o = 100 // 初识值为 100
p // 初识值 跟随上面 的 100
q = iota // 初识值为 iota 会自增 每一行都会自增，即 q = 4
)
const (
r, s, t = iota, iota, iota // 初识值为 iota 会自增 每一行都会自增，但是现在是在同一行 所有是 0 0 0
u = iota
v = iota
)
const (
w = 4 // 显式的指定值
x = 5 // 显式的指定值
y = iota // c = 2，因为这里的 iota 位于第3个ConstSpec，2=3-1
z = iota // d = 3，因为iota递增了1，等价于 d = iota
)
const (
aa = 0 // a = 0
bb = 1
_ // 跳过这个ConstSpc，但是iota会加1
cc, dd = iota, iota * 2 // iota=2
)
func main() {
fmt.Println(a, b, c, d) // 1 1 1 1
fmt.Println(e, f, g, h) // 1 1 1 1
fmt.Println(i, j, k, l) // 0 1 2 3
fmt.Println(m, n, o, p, q) // 0 1 100 100 4
fmt.Println(r, s, t, u, v) // 0 0 0 1 2
fmt.Println(w, x, y, z) // 4 5 2 3
fmt.Println(aa, bb, cc) // 0 1 3
}
【补充】单引号表示数字
package main
import "fmt"
func main() {
// 【6】单引号 --- 数字类型 (int32) , 这个字符对应的 unicode 编码对应的数字，所以单引号只能放一个字符
var param = '1' // 类型是 int32 ， 只能表示一个字符
var name = '你' // 类型是 int32 ， 表示 unicode 编码对应的数字
fmt.Printf("param的类型是 :>>>%T , param的值是 :>>> %d \n", param, param) //param的类型是 :>>>int32 , param的值是 :>>> 49
fmt.Printf("param的类型是 :>>>%T , param的值是 :>>> %s \n", name, name) //param的类型是 :>>>int32 , param的值是 :>>> %!s(int32=20320)
}
【补充】Java和Go中的基本数据类型的比较
java: byte short int long float double
go: int8 int16 int32 int64 float32 float64
python：int float 不是基础数据类型，是对象
【补充】
【一】变量声明
- Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。
- 我们从计算机系统的角度来讲，变量就是一段或者多段内存，用于存储数据
【1】标准格式
var 变量名 变量类型
变量声明以关键字var开头，变量类型后置，行尾无须分号
- 举个例子
package main
import "fmt"
// 【1】定义变量
func main() {
// 方式一 : 完整定义 -----> var 关键字 变量名
//变量类型 = 变量值
// 定义变量名 nameOfDream ：驼峰式命名法
// 定义变量类型 string ： 文本类型
// 定义变量值 "Dream" ： 必须用双引号引起来
var nameOfDream string = "Dream"
// 定义变量后 必须使用 ，否则不会编译 ，会报错
fmt.Println(nameOfDream) // Dream
// 方式二 ： 类型推导 ----> 自动推导出变量的类型
// var关键字 变量名 = 变量值
// 没有写类型，是自动推导出来的，变量也有类型，并且是固定类型，以后不能随意改变
var age = 19 // 没有指定是 int 类型，默认是int类型
fmt.Println(age) // 19
// 查看变量名的类型
fmt.Printf("变量的类型是 :>> %T,变量的值是 :>> %d \n", age, age) // 变量的类型是 :>> int,变量的值是 :>> 19
var nameOfHope = "Hope" // 没有指定是 string 类型，但是默认是 string 类型
fmt.Println(nameOfHope) // Hope
// 查看变量名的类型
fmt.Printf("变量的类型是 :>> %T,变量的值是 :>> %s \n", nameOfHope, nameOfHope) //变量的类型是 :>> string,变量的值是 :>> Hope
// 方式三 ：简略声明 ----> 尽可能少写代码
// 变量名 := 变量值
//age = 19 // 如果上面没有定义过就会报错，这句话的意思是修改变量值
height := 180 // 变量名 := 变量值 是定义变量
fmt.Println(height) // 180
// 查看变量名的类型
fmt.Printf("变量的类型是 :>> %T,变量的值是 :>> %d \n", height, height) //变量的类型是 :>> int,变量的值是 :>> 180
}
- 如果你学过C语言，就会体会到这样声明的好处
- 比如C语言这样声明：int* a, b ，那么只有a是指针，b不是，这样会使人迷惑
- 如果想要两个变量都为指针，需要这样定义：
int *a,*b。- 在go语言中，我们使用这样的声明方式：
var a,b *int，就可以轻松的将a，b都声明为指针。
【2】基本类型
-
计算机中数据存储的最小单位为bit（位），0或者1
-
byte：计算机中数据的基本单元，1字节=8bit，数据在计算机中存储或者计算，至少为1个字节
-
bool
-
string
-
int（随系统，一般是占用4个字节）、int8(占一个字节)、int16(占两个字节)、int32(占4个字节)、int64（占8个字节）
-
uint（无符号整数）、uint8、uint16、uint32、uint64、uintptr
-
byte //
uint8 的别名 -
rune //
int32 的别名 代表一个 Unicode 码 -
float32、float64
-
complex64、complex128
-
- 有符号和无符号的区别：int8 范围 -128-127，uint8 范围：0-255
-
当一个变量被声明之后，系统自动赋予它该类型的零值：
int 为 0float 为 0.0bool 为 false- ``string 为空字符串`
- 指针为 nil `
-
所有的内存在 Go 中都是经过初始化的。
package main
import "fmt"
var age int
func main() {
fmt.Println(age);
}
【3】不指明变量类型
//设置游戏中角色的初始等级为1
var level = 1;
-
像上面这种声明变量的方式，并没有指明类型，Go语言中，
在编译时会自动推导类型 -
我们可以使用
fmt.Printf("%T", level)
- 进行类型输出。
package main
import "fmt"
var level = 1
func main() {
fmt.Printf("%T",level)
}
【4】批量格式
- 觉得每行都用 var 声明变量比较烦琐？
- Go语言提供了批量声明的方式
var (
a int
b string
c []float32
)
package main
import "fmt"
var (
a int
b string
c []float32
)
func main() {
//%d 整数占位符，%s 字符串占位符， %f 浮点数占位符(默认精度为6)
fmt.Printf("%d,%s,%f",a,b,c)
}
【5】简短格式
- 我们可以省略
var关键字，这样写起来更加便捷
//i是变量名 1 是值（或者表达式）
i := 1
-
上面讲过，如果不指明类型，直接赋值，Go会自动推导类型
-
使用简短格式有以下限制：
-
定义变量，同时显式初始化
-
不能提供数据类型
-
只能用在函数内部
-
package main
import "fmt"
//不能
//aa :=1
func main() {
aa :=1
fmt.Println(aa)
}
- 简短变量声明被广泛用于大部分的局部变量的声明和初始化，var 形式的声明语句往往用于需要显式指定变量类型的地方
【二】初始化变量
【1】引入
- 创建了一个游戏角色 初始等级为1
var level int = 1
- 短变量声明
level := 1
- 以下的代码会出错：
package main
func main() {
var level int = 1
// 再次声明并赋值 会报错 no new variables on left side of := （左边的变量已经被声明了，不能重复声明）
level := 1
}
【2】特例
- 比如：
net.Dial提供按指定协议和地址发起网络连接，这个函数有两个返回值，一个是连接对象（conn），一个是错误对象（err）
（1）正常的写法
package main
import (
"fmt"
"net"
)
func main() {
var conn net.Conn
var err error
conn, err = net.Dial("tcp", "127.0.0.1:8080")
fmt.Println(conn)
fmt.Println(err)
}
（2）短变量的写法
package main
import (
"fmt"
"net"
)
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:8080")
conn1, err := net.Dial("tcp", "127.0.0.1:8080")
fmt.Println(conn)
fmt.Println(conn1)
fmt.Println(err)
}
- 在多个短变量声明和赋值中，至少有一个新声明的变量出现在左值中，即便其他变量名可能是重复声明的，编译器也不会报错
【三】小demo
- 变量交换，比如a=100，b=200，交换之后 a=200，b=100
- 如果是你，你会怎么样进行实现呢？
第一种
package main
import "fmt"
func main() {
a := 100
b := 200
var c int
c = b
b = a
a = c
fmt.Printf("a=%d,b=%d",a,b)
}
第二种
package main
import "fmt"
func main() {
a := 100
b := 200
a = a^b
b = b^a
a = a^b
fmt.Printf("a=%d,b=%d",a,b)
}
第三种
package main
import "fmt"
func main() {
a := 100
b := 200
b,a = a,b
fmt.Printf("a=%d,b=%d",a,b)
}
- 应该有点体会到Go语言编程的快捷，方便以及强大了吧
【四】匿名变量
-
使用
多重赋值时，如果不需要在左值中接受变量，可以使用匿名变量 -
比如上面的例子:
package main
import (
"fmt"
"net"
)
func main() {
//conn, err := net.Dial("tcp", "127.0.0.1:8080")
//如果不想接收err的值，那么可以使用_表示，这就是匿名变量
conn, _ := net.Dial("tcp", "127.0.0.1:8080")
fmt.Println(conn)
}
匿名变量以“_”下划线表示
匿名变量不占用命名空间，也不会分配内存。匿名变量可以重复声明使用
- “_”本身就是一个特殊的标识符，被称为空白标识符。
- 它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃
- 因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。
package main
import (
"fmt"
"net"
)
func main() {
conn, _ := net.Dial("tcp", "127.0.0.1:8080")
//匿名变量可以重复声明
conn1, _ := net.Dial("tcp", "127.0.0.1:8080")
// 匿名变量不可以直接开头
// _ :=1
fmt.Println(conn)
fmt.Println(conn1)
}
【五】作用域
- 一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为
作用域。
-
了解变量的作用域对我们学习Go语言来说是比较重要的
- 因为
Go语言(静态语言)会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。
- 因为
-
如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。
-
根据变量定义位置的不同，可以分为以下三个类型：
-
函数内定义的变量称为局部变量
-
函数外定义的变量称为全局变量
-
函数定义中的变量称为形式参数
-
【1】局部变量
-
在函数体内声明的变量称之为
局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。 -
局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。
package main
import (
"fmt"
)
func main() {
//声明局部变量 a 和 b 并赋值
var a int = 3
var b int = 4
//声明局部变量 c 并计算 a 和 b 的和
c := a + b
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}
【2】全局变量
- 在函数体外声明的变量称之为
全局变量- 全局变量只需要在
一个源文件中定义，就可以在所有源文件中使用 - 当然，不包含这个全局变量的源文件需要使用“import”关键字引入全局变量所在的源文件之后才能使用这个全局变量。
- 全局变量只需要在
- 全局变量声明
必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。
package main
import "fmt"
//声明全局变量
var c int
func main() {
//声明局部变量
var a, b int
//初始化参数
a = 3
b = 4
c = a + b
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}
- Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。
package main
import "fmt"
//声明全局变量
var bb float32 = 3.14
func main() {
bb := 3
fmt.Println(bb)
}
//执行结果 3
【3】形式参数
- 在定义函数时函数名后面括号中的变量叫做
形式参数（简称形参）。- 形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参
并不占用实际的存储单元，也没有实际值。
- 形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参
- 形式参数会作为
函数的局部变量来使用。
package main
import (
"fmt"
)
//全局变量 a
var a int = 13
func main() {
//局部变量 a 和 b
var a int = 3
var b int = 4
fmt.Printf("main() 函数中 a = %d\n", a)
fmt.Printf("main() 函数中 b = %d\n", b)
c := sum(a, b)
fmt.Printf("main() 函数中 c = %d\n", c)
}
func sum(a, b int) int {
fmt.Printf("sum() 函数中 a = %d\n", a)
fmt.Printf("sum() 函数中 b = %d\n", b)
num := a + b
return num
}
- 至此，Go语言变量相关的知识，我们就掌握了
本文来自博客园，作者：Chimengmeng，转载请注明原文链接：https://www.cnblogs.com/dream-ze/p/17825653.html
