第1节 变量的使用
1.1 什么是变量
变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。
所以变量的本质就是一小块内存,用于存储数据,在程序运行过程中数值可以改变。
1.2 声明变量
var名称类型是声明单个变量的语法。
以字母或下划线开头,由一个或多个字母、数字、下划线组成
声明一个变量
- 第一种,指定变量类型,声明后若不赋值,使用默认值
var name type name = value
- 第二种,根据值自行判定变量类型(类型推断Type inference)
如果一个变量有一个初始值,Go将自动能够使用初始值来推断该变量的类型。因此,如果变量具有初始值,则可以省略变量声明中的类型。var name = value
- 第三种,省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时,至少保证一个是新变量),否则会导致编译错误(简短声明)
name := value // 例如 var a int = 10 var b = 10 c : = 10
这种方式它只能被用在函数体内,而不可以用于全局变量的声明与赋值
示例代码:
package main
var a = "Hello"
var b string = "World"
var c bool
func main(){
println(a, b, c)
}
运行结果:
Hello World false
多变量声明
第一种,以逗号分隔,声明与赋值分开,若不赋值,存在默认值
var name1, name2, name3 type
name1, name2, name3 = v1, v2, v3
第二种,直接赋值,下面的变量类型可以是不同的类型
var name1, name2, name3 = v1, v2, v3
第三种,集合类型
var (
name1 type1
name2 type2
)
1.3 注意事项
- 变量必须先定义才能使用
- go语言是静态语言,要求变量的类型和赋值的类型必须一致。
- 变量名不能冲突。(同一个作用域内不能冲突)
- 简短定义方式,左边的变量名至少有一个是新的
- 简短定义方式,不能定义全局变量。
- 变量的零值。也叫默认值。
- 变量定义了就要使用,否则无法通过编译。
如果在相同的代码块中,我们不可以再次对于相同名称的变量使用初始化声明,例如:a := 20 就是不被允许的,编译器会提示错误 no new variables on left side of :=,但是 a = 20 是可以的,因为这是给相同的变量赋予一个新的值。
如果你在定义变量 a 之前使用它,则会得到编译错误 undefined: a。如果你声明了一个局部变量却没有在相同的代码块中使用它,同样会得到编译错误,例如下面这个例子当中的变量 a:
func main() {
var a string = "abc"
fmt.Println("hello, world")
}
尝试编译这段代码将得到错误 a declared and not used。
此外,单纯地给 a 赋值也是不够的,这个值必须被使用,所以使用在同一个作用域中,已存在同名的变量,则之后的声明初始化,则退化为赋值操作。但这个前提是,最少要有一个新的变量被定义,且在同一作用域,例如,下面的y就是新定义的变量
package main
import (
"fmt"
)
func main() {
x := 140
fmt.Println(&x)
x, y := 200, "abc"
fmt.Println(&x, x)
fmt.Print(y)
}
运行结果:
0xc04200a2b0
0xc04200a2b0 200
abc
第2节 常量的使用
2.1 常量声明
常量是一个简单值的标识符,在程序运行时,不会被修改的量。
const identifier [type] = value
显式类型定义: const b string = "abc"
隐式类型定义: const b = "abc"
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" //多重赋值
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d", area)
println()
println(a, b, c)
}
运行结果:
面积为 : 50
1 false str
常量可以作为枚举,常量组
const (
Unknown = 0
Female = 1
Male = 2
)
常量组中如不指定类型和初始化值,则与上一行非空常量右值相同
package main
import (
"fmt"
)
func main() {
const (
x uint16 = 16
y
s = "abc"
z
)
fmt.Printf("%T,%v\n", y, y)
fmt.Printf("%T,%v\n", z, z)
}
运行结果:
uint16,16
string,abc
常量的注意事项:
- 常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型
- 不曾使用的常量,在编译的时候,是不会报错的
- 显示指定类型的时候,必须确保常量左右值类型一致,需要时可做显示类型转换。这与变量就不一样了,变量是可以是不同的类型值
2.2 iote
iota,特殊常量,可以认为是一个可以被编译器修改的常量
iota 可以被用作枚举值:
const (
a = iota
b = iota
c = iota
)
第一个 iota 等于 0,每当 iota 在新的一行被使用时,它的值都会自动加 1;所以 a=0, b=1, c=2 可以简写为如下形式:
const (
a = iota
b
c
)
iota 用法
package main
import "fmt"
func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //独立值,iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}
运行结果:
0 1 2 ha ha 100 100 7 8
如果中断iota自增,则必须显式恢复。且后续自增值按行序递增
自增默认是int类型,可以自行进行显示指定类型
数字常量不会分配存储空间,无须像变量那样通过内存寻址来取值,因此无法获取地址。
第3节 基本数据类型
以下是go中可用的基本数据类型
3.1 布尔型bool
布尔型的值只可以是常量 true 或者 false。一个简单的例子:var b bool = true
3.2 数值型
1、整数型
- int8 有符号 8 位整型 (-128 到 127) 长度:8bit
- int16 有符号 16 位整型 (-32768 到 32767)
- int32 有符号 32 位整型 (-2147483648 到 2147483647)
- int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
- uint8 无符号 8 位整型 (0 到 255) 8位都用于表示数值:
- uint16 无符号 16 位整型 (0 到 65535)
- uint32 无符号 32 位整型 (0 到 4294967295)
- uint64 无符号 64 位整型 (0 到 18446744073709551615)
int和uint:根据底层平台,表示32或64位整数。除非需要使用特定大小的整数,否则通常应该使用int来表示整数。 大小:32位系统32位,64位系统64位。
范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。
2、浮点型
- float32 IEEE-754 32位浮点型数
- float64 IEEE-754 64位浮点型数
- complex64 32 位实数和虚数
- complex128 64 位实数和虚数
3、其他
- byte 类似 uint8
- rune 类似 int32
- uint 32 或 64 位
- int 与 uint 一样大小
- uintptr 无符号整型,用于存放一个指针
3.3 字符串型
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本
var str string
str = "Hello World"
3.4 数据类型转换:Type Convert
语法格式:Type(Value)
常数:在有需要的时候,会自动转型
变量:需要手动转型 T(V)
注意点:兼容类型可以转换
3.5 复合类型(派生类型)
1、指针类型(Pointer) 2、数组类型 3、结构化类型(struct) 4、Channel 类型 5、函数类型 6、切片类型 7、接口类型(interface) 8、Map 类型
第4节 运算符
4.1 算术运算符
+ - * / %(求余) ++ --
4.2 关系运算符
== != > < >= <=
4.3 逻辑运算符
运算符 | 描述 |
---|---|
&& | 所谓逻辑与运算符。如果两个操作数都非零,则条件变为真 |
|| | 所谓的逻辑或操作。如果任何两个操作数是非零,则条件变为真 |
! | 所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真,那么逻辑非操后结果为假 |
4.4 位运算符
运算符 | 描述 | 示例 |
---|---|---|
& | 二进制与操作副本位的结果,如果它存在于两个操作数 | (A & B) = 12, 也就是0000 1100 |
| | 二进制或操作副本,如果它存在一个操作数 | (A|B) = 61, 也就是0011 1101 |
^ | 二进制异或操作副本,如果它被设置在一个操作数就是按位取非 | (A ^ B) = 49,也就是0011 0001 |
&^ | 二进制位清空&^ | (A&^B)=48,也就是0011 0000 |
<< | 二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数 | A << 2 =240,也就是1111 0000 |
>> | 二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动 | A >> 2 = 15,也就是0000 1111 |
4.5 赋值运算符
运算符 | 描述 | 示例 |
---|---|---|
= | 简单的赋值操作符,分配值从右边的操作数左侧的操作数 | C = A + B 将分配A + B的值到C |
+= | 相加并赋值运算符,它增加了右操作数左操作数和分配结果左操作数 | C += A 相当于 C = C + A |
-= | 减和赋值运算符,它减去右操作数从左侧的操作数和分配结果左操作数 | C -= A 相当于 C = C - A |
*= | 乘法和赋值运算符,它乘以右边的操作数与左操作数和分配结果左操作数 | C * = A 相当于 C = C * A |
/= | 除法赋值运算符,它把左操作数与右操作数和分配结果左操作数 | C /= A 相当于 C = C / A |
%= | 模量和赋值运算符,它需要使用两个操作数的模量和分配结果左操作数 | C %= A 相当于 C = C % A |
<<= | 左移位并赋值运算符 | C <<= 2 相同于 C = C << 2 |
>>= | 向右移位并赋值运算符 | C >>= 2 相同于 C = C >> 2 |
&= | 按位与赋值运算符 | C &= 2 相同于 C = C & 2 |
^= | 按位异或并赋值运算符 | C ^= 2 相同于 C = C ^ 2 |
|= | 按位或并赋值运算符 | C | = 2 相同于 C = C | 2 |
4.6 优先级运算符优先级
有些运算符拥有较高的优先级,二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级,由上至下代表优先级由高到低:
优先级 | 运算符 |
---|---|
7 | ~ ! ++ – |
6 | * / % << >> & &^ |
5 | + - ^ |
4 | == != < <= >= > |
3 | <- |
2 | && |
1 | || |
当然,你可以通过使用括号来临时提升某个表达式的整体运算优先级。
第5节 键盘输入和打印输出
5.1 fmt包
fmt包实现了类似C语言printf和scanf的格式化I/O。格式化verb(’verb’)源自C语言但更简单。
详见官网fmt的API:https://golang.google.cn/pkg/fmt/
导入包:
import "fmt"
5.2 常用打印函数
打印:func Print(a …interface{}) (n int, err error)
格式化打印:func Printf(format string, a …interface{}) (n int, err error)
打印后换行:func Println(a …interface{}) (n int, err error)
格式化打印中的常用占位符:
格式化打印占位符:
%v,原样输出
%T,打印类型
%t,bool类型
%s,字符串
%f,浮点
%d,10进制的整数
%b,2进制的整数
%o,8进制
%x,%X,16进制
%x:0-9,a-f
%X:0-9,A-F
%c,打印字符
%p,打印地址
。。。
示例代码:
package main
import (
"fmt"
)
func main() {
a := 100 //int
b := 3.14 //float64
c := true // bool
d := "Hello World" //string
e := Ruby //string
f := 'A'
fmt.Printf("%T,%b\n", a, a)
fmt.Printf("%T,%f\n", b, b)
fmt.Printf("%T,%t\n", c, c)
fmt.Printf("%T,%s\n", d, d)
fmt.Printf("%T,%s\n", e, e)
fmt.Printf("%T,%d,%c\n", f, f, f)
fmt.Println("-----------------------")
fmt.Printf("%v\n", a)
fmt.Printf("%v\n", b)
fmt.Printf("%v\n", c)
fmt.Printf("%v\n", d)
fmt.Printf("%v\n", e)
fmt.Printf("%v\n", f)
}
运行结果:
5.3 fmt包读取键盘输入
常用方法:
func Scan(a …interface{}) (n int, err error)
func Scanf(format string, a …interface{}) (n int, err error)
func Scanln(a …interface{}) (n int, err error)
package main
import (
"fmt"
)
func main() {
var x int
var y float64
fmt.Println("请输入一个整数,一个浮点类型:")
fmt.Scanln(&x,&y)//读取键盘的输入,通过操作地址,赋值给x和y 阻塞式
fmt.Printf("x的数值:%d,y的数值:%f\n",x,y)
fmt.Scanf("%d,%f",&x,&y)
fmt.Printf("x:%d,y:%f\n",x,y)
}
运行结果:
5.4 bufio包读取
https://golang.google.cn/pkg/bufio/
bufio包中都是IO操作的方法:
先创建Reader对象:
然后就可以各种读取了:
示例代码:
package main
import (
"fmt"
"os"
"bufio"
)
func main() {
fmt.Println("请输入一个字符串:")
reader := bufio.NewReader(os.Stdin)
s1, _ := reader.ReadString('\n')
fmt.Println("读到的数据:", s1)
}
运行结果: