#### Go 指针,标识符命名规范,关键字,运算符
回顾了一下之前写的文章,以及考虑到后期的内容较多, 从这篇开始逐渐增加文章内容;
这篇我们主要学习一Go 中的指针,标识符关键字以及运算符
##### 指针
介绍: Go 中的指针相比于C 中的指针,弱化了;基本数据类型,变量存储的是值,也称为值类型; 获取变量的地址,使用&: 例如: var a int, 获取a 的地址为: &a;
package main
import "fmt"
func main() {
var a int = 10
fmt.Println(a)
// 获取变量a 的地址
fmt.Printf("a address is %p
",&a)//0xc000054080
// 基本数据类型a 在内存中的布局
// 变量a指向10, 10 的内存地址为: 0xc000054080
}
指针类型: 指针变量存储的是一个内存地址,这个内存地址指向的空间存的才是值;
如var b *int = &a
获取指针类型所指向的值使用*;
如: var b *int , 使用*b 获取b 指向的值;
通过指针更改基本类型的值;
如: var b *int, 使用*b = 20, 来更改基本类型的值;
package main
import "fmt"
func main() {
var a int = 10
// 变量 b 是一个指针变量,类型为*int
var b *int = &a
// 内存布局如下:
// 变量a指向10, 10 的内存地址为: 0xc000054080
// 指针变量b 指向0xc000054080, 0xc00054080 地址指向10
fmt.Printf("a address is %p
") //0xc000054080
fmt.Printf("b value is %p
") //0xc000054080
fmt.Println("b pointed value is",*b) //10
// 通过指针更改变量的值,并不会改变原来的内存地址
*b = 100
fmt.Println("a value is",a)//100
}
指针使用的细节
1. 值类型都有对应的指针类型,形式为*数据类型, 如int 类型的对应指针是*int,int32类型的对应指针为*int32;
2. ***指类型包括:基本数据类型int系列,float系列,bool,string;数组和结构体struct***
##### 值类型和引用类型
值类型:***指类型包括:基本数据类型int系列,float系列,bool,string;数组和结构体struct***
引用类型: 指针,slice 切片, map, 管道chan,接口interface都是引用类型;
1. 值类型: 变量直接存储的值,内存通常在栈中分配
2. 引用类型: 变量存储的是一个内存地址,这个地址指向的空间才真正存储的值,内存通常在堆上分配,如果没有任何变量引用这个地址时,该地址对应的
数据空间就成为一个垃圾,由GC 来回收
var a = 100
// a --> 100
var b = &a
// b --> 地址 --> 100
##### 标识符及命名规范
Go 对各种变量,方法,函数等命名时使用的字符序列称为标识符;
也可以这样说: 凡是程序员可以自己起名称的地方都叫标识符;
规则:
1. 由26 个英文字母大小写,0-9,_ 组成 ;
2. 数字不可以开头;
3. 严格区分大小写;
4. 标识符不能包含空格;
5. 不能使用系统保留的关键字作为标识符;
6. ***下划线_本身在Go中是一个特殊的标识符,称为空标识符,它可以代表任意的其它字符,但是它的值会被忽略
单一_仅能被作为占位符使用,不能作为标识符使用;***
7. 除了第6条外,与其它语言基本规则一样,在命名时注意即可;
---
标识符命名注意事项
1. 包名: 保持package 的名字和目录的名称一致,尽量采用有意思的名称,最好不和标准库冲突;
2. 变量名,函数名,常量名采用驼峰命名法;
3. 如果变量名,函数名,常量名首字母大写,则可以被其它的包访问,如果首字母小写,则只能在本包中使用(首字母大写是公开的,首字母小写是私有的,类似其它语言中的public,private 关键字)
##### 系统保留关键字(25个)
##### 预定义的标识符(36个)
包括基础数据类型和系统内嵌函数
##### 运算符
运算符是一种特殊的符号,用以表示数据的运算,赋值和比较等;
1. 算术运算符
2. 赋值运算符
3. 比较运算符/关系运算符
4. 逻辑运算符
5. 位运算符
6. 其它运算符
---
##### 算术运算符
算术运算符是对数值类型的变量进行运算,如下:
案例:
package main
import "fmt"
func main() {
var a int = 10
var b int = 3
fmt.Println(a+b) //13
fmt.Println(a-b) //7
fmt.Println(a*b) //30
// 注意: 如果运算的数全是整数,那么结果保留整数部分
fmt.Println(a/b) //3
var c float64 = 10 / 3 // 3
// 如果需要保留小数部分,则需要浮点数参与运算
var d float64 = 10.0 / 3 // 3.333333...
fmt.Println(c,d)
// % 的使用
// a % b = a- a/b*b // 这是一个公式
fmt.Println("10 %3 = ",10%3) // 1
fmt.Println("-10 %3 = ",-10%3) //(-10)-(-10)/3*3 = -1
fmt.Println("10 %-3 = ",10%-3)//10-10/(-3)*(-3) = 1
fmt.Println("-10%-3 = ",-10%-3) // (-10)-(-10)/(-3)*(-3) = -1
var e = 1
e ++
fmt.Println(e) //2
e--
fmt.Println(e) //1
}
算术运算符使用的注意事项
1. 对于除号, 它的整数除和小数除是有区别的,整数除时只保留整数部分;
2. 取模时%, 可以参考公式: a%b = a-a/b*b;
3. Go 的自增和自减只能作为独立语句使用;
4. ++ 和 -- 只能写在变量后,没有--a,和++a;
---
##### 关系型运算符(比较运算符)
关系型运算符的结果都是bool 类型的,要么是true , 要么是false, 经常使用在条件控制语句中;
package main
import "fmt"
func main() {
var a = 1
var b = 2
fmt.Println(a>b) // false
fmt.Println(a<b) // true
fmt.Println(a==b) // false
fmt.Println(a!=b) // true
fmt.Println(a<=b) // true
fmt.Println(a>=b) // false
resu := a>b
fmt.Println(resu) // false
}
---
关系型运算符使用注意事项:
1. 运算结果都是bool 类型,true or false;
2. 比较运算符"==" 不能写成"=", "=" 是赋值 ;
##### 逻辑运算符
假如: a = true, b = false
a && b = false // 两边同时为true ,结果为true,否则为false
a || b = true // 两边同时为false ,结果为false,否则为true
!a = false, !b = true // 取反,!true=false, !false=true
案例:
package main
import "fmt"
func main() {
var a = 2
// 两边不同时为true, 结果为false
fmt.Println(a > 2 && a < 3) // false
// 两边同时为true,结果为true
fmt.Println(a >1 && a <3 ) // true
// 两边有一个为true,结果为true
fmt.Println(a >2 || a < 3) // true
// 两边同时为false,结果为false
fmt.Println(a >2 || a <1 ) // false
fmt.Println(a > 2) // false
// 取反
fmt.Println(!(a>2)) // true
}
---
逻辑运算符使用注意事项
1. && 也称为短路与: 如果第一个条件为false, 则第二个条件不会判断,结果为false;
2. || 也称为短路或: 如果第一个条件为true, 则第二个条件不会判断,结果为true;
package main
import "fmt"
func test() bool {
fmt.Println("hello,world")
return true
}
func main() {
var a = 2
if a < 1 && test() { // false , test() 函数不会执行
fmt.Println("yes")
}
if a > 1 || test() { // true, test() 函数不会执行
fmt.Println("yes")
}
}
##### 赋值运算符
赋值运算符就是将运算后的值,赋值给指定的变量;
分类:
1. = , 如: a3 = a1 + a2
2. +=, 如: a3 += a1,等价于 a3 = a3 + a1
3. -=, 如: a3 -= a1,等价于 a3 = a3 - a1
4. *=, 如: a3 *= a1,等价于 a3 = a3 * a1
5. /=, 如: a3 /= a1,等价于 a3 = a3 / a1
5. %=, 如: a3 %= a1,等价于 a3 = a3 % a1
案例:
package main
import "fmt"
func main() {
var a1 = 1
var a2 = 2
a3 := a1 + a2
fmt.Println(a3)
a3 += a1 // a3 = a3 + a1 ====> 3+1
fmt.Println(a3) // 4
// 在这里演示一个小案例,用来体验一下Go 赋值运算符的使用
// 交换两个变量的值
var a = 10
var b = 20
// Go 中支持多变量赋值
a, b = b, a // 正确
fmt.Println(a, b) // 20,10
// 使用另一种方式实现
a = a + b
b = a - b // a +b -b = a
a = a - b // a +b -a = b
fmt.Println(a, b) //10,20 , 上面已经交换过,这里恢复
}
---
赋值运算符的使用注意事项
1. 运算顺序从右往左;
2. 赋值运算符的左边只能是变量,右边可以是变量,表达式,常量值;
##### 位运算符
位运算符涉及到二进制运算,实际使用过程中并不是太多,这里先不写......
##### 运算符的优先级
从高到低
1. (),++,--
2. 单目运算: !,&,*
3. 移位运算: <<,>>
4. 位运算: |,&,^
5. 算术运算: *,/,+,-
6. 关系型运算: >,<,<=,==,>=
7. 逻辑运算: &&,||
8. 赋值运算: +=,-=,*=
9. 逗号: ,
---
运算符的优先级,与其它编程语一样,不需要过多研究,实际使用中多写多练即可;
--------最近在同步更新微信公众号:"开胃咸菜",最新文章以公众号为准,可以一起学习交流;
