命名规则
- 字母、下划线、数字组成，不能以数字开头。
- 区分大小写
- 不能用关键字
|
|
|
|
|
| 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 |
|
|
|
|
|
- 不能使用预留名字
内建常量:
内建类型:
|
|
|
|
|
| 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 |
|
|
|
类型分类
|
|
|
|
|
| 类型 |
名称 |
长度 |
零值 |
说明 |
| bool |
布尔类型 |
1 |
false |
其值不为真即为家，不可以用数字代表true或false |
| byte |
字节型 |
1 |
0 |
uint8别名 |
| rune |
字符类型 |
4 |
0 |
专用于存储unicode编码，等价于uint32 |
| int, uint |
整型 |
4或8 |
0 |
32位或64位 |
| int8, uint8 |
整型 |
1 |
0 -128 ~ 127, 0 ~ 255 |
| int16, uint16 |
整型 |
2 |
0 -32768 ~ 32767, 0 ~ 65535 |
| int32, uint32 |
整型 |
4 |
0 -21亿 ~ 21 亿, 0 ~ 42 亿 |
| int64, uint64 |
整型 |
8 |
0 |
| float32 |
浮点型 |
4 |
0.0 |
小数位精确到7位 |
| float64 |
浮点型 |
8 |
0.0 |
小数位精确到15位 |
| complex64 |
复数类型 |
8 |
| complex128 |
复数类型 |
16 |
| uintptr |
整型 |
4或8 |
⾜以存储指针的uint32或uint64整数 |
| string |
字符串 |
"" |
utf-8字符串 |
|
|
|
|
|
|
|
|
变量
package main
import "fmt"
func main() {
//变量，程序运行期间，可以改变的量
// 声明格式 var 变量名 类型
// 变量声明了，必须要使用
// 只是声明没有初始化的变量，默认值为0、空或者false（根据类型而定）
// 同一个{}里，声明的变量名是唯一的(局部变量)
var a int
fmt.Println("a = ", a)
//同时声明多个变量
//var b, c int
a = 10 //变量的赋值
fmt.Println("a = ", a)
//变量的初始化：声明变量时，同时赋值
var b int = 10 //初始化，声明变量时，同时赋值（一步到位）
b = 20 //赋值， 先声明，后赋值
fmt.Println("b = ", b)
//自动推导类型，必须初始化，通过初始化的值确定类型
//:=, 自动推导类型，先声明变量b，再给b赋值为20
c := 30
//%T打印变量所属的类型
fmt.Printf("c type is %T\n", c)
}
匿名变量
格式：下划线+变量名：_a
性质：任何赋予它的值都会被丢弃
用途：回收变量，常用于接收函数的返回值，因为go的函数是可以有多个返回值的，如果只想用其中的一个， 就可以用匿名变量丢弃其他变量。
package main //必须有一个main包
import "fmt"
//go函数可以返回多个值
func test() (a, b, c int) {
return 1, 2, 3
}
func main() {
var c, d, e int
c, d, e = test() //return 1, 2, 3
fmt.Printf("c = %d, d = %d, e = %d\n", c, d, e) //三个都用
_, d, e = test() //return 1, 2, 3
fmt.Printf("d = %d, e = %d\n", d, e) //只用两个
}
常量
123
3.1415 // 浮点类型的常量
3.2+12i // 复数类型的常量
true // 布尔类型的常量
"foo" // 字符串常量
常量定义
package main //必须有一个main包
import "fmt"
func main() {
//变量：程序运行期间，可以改变的量， 变量声明需要var
//常量：程序运行期间，不可以改变的量，常量声明需要const
const a int = 10
//a = 20 //err, 常量不允许修改
fmt.Println("a = ", a)
const b = 11.2 //没有使用:=
fmt.Printf("b type is %T\n", b)
fmt.Println("b = ", b)
}
itoa
package main //必须有一个main包
import "fmt"
func main() {
//iota常量自动生成器，每个一行，自动累加1
//iota给常量赋值使用
const (
a = iota //0
b = iota //1
c = iota //2
)
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
//a = 0, b = 1, c = 2
//iota遇到const，重置为0
const d = iota
fmt.Printf("d = %d\n", d)//d = 0
//可以只写一个iota
const (
a1 = iota //0
b1
c1
)
fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1)
//a1 = 0, b1 = 1, c1 = 2
//如果是同一行，值都一样
const (
i = iota
j1, j2, j3 = iota, iota, iota
k = iota
)
fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k)
//i = 0, j1 = 1, j2 = 1, j3 = 1, k = 2
}
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
}
字符和字符串
package main //必须有一个main包
import "fmt"
func main() {
//字符
//1、单引号
//2、字符，往往都只有一个字符，转义字符除外'\n'
var ch byte
ch = 'a'
fmt.Println("ch =", ch) //ch = 97
ch = 97
//格式化输出，%c以字符方式打印，%d以整型方式打印
fmt.Printf("%c, %d\n", ch, ch)//a, 97
//其实存储的不是字符，是ASCLL码
//大写转小写，小写转大写, 大小写相差32，小写大
fmt.Printf("大写：%d， 小写：%d\n", 'A', 'a')//大写：65， 小写：97
fmt.Printf("大写转小写：%c\n", 'A'+32)
fmt.Printf("小写转大写：%c\n", 'a'-32)
//'\'以反斜杠开头的字符是转义字符, '\n'代表换行
fmt.Printf("hello go%c", '\n')
//字符串
//1、双引号
//2、字符串有1个或多个字符组成
//3、字符串都是隐藏了一个结束符，'\0'
var str string //声明变量
str = "a" // 由'a'和'\0'组成了一个字符串
fmt.Println("str = ", str)
str = "hello go"
//只想操作字符串的某个字符，从0开始操作
fmt.Printf("str[0] = %c, str[1] = %c\n", str[0], str[1])//str[0] = h, str[1] = e
//自动推导类型
str2 := "mike"
fmt.Printf("str2 类型是 %T\n", str2)
//内建函数，len()可以测字符串的长度，有多少个字符，不包含\n
fmt.Println("len(str2) = ", len(str2))//len(str2) = 4
}
复数类型
package main
import "fmt"
func main() {
var t complex128 //声明
t = 2.1 + 3.14i //赋值
fmt.Println("t = ", t) //t = (2.1+3.14i)
//自动推导类型
t2 := 3.3 + 4.4i
fmt.Printf("t2 type is %T\n", t2)//t2 type is complex128
//通过内建函数，取实部和虚部
fmt.Println("real(t2) = ", real(t2), ", imag(t2) = ", imag(t2))//real(t2) = 3.3 , imag(t2) = 4.4
}
格式化输入输出
|
|
| 格式 |
含义 |
| %% |
一个%字面量 |
| %b |
一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数 |
| %c |
字符型。可以把输入的数字按照ASCII码相应转换为对应的字符 |
| %d |
一个十进制数值(基数为10) |
| %e |
以科学记数法e表示的浮点数或者复数值 |
| %E |
以科学记数法E表示的浮点数或者复数值 |
| %f |
以标准记数法表示的浮点数或者复数值 |
| %g |
以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 |
| %G |
以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 |
| %o |
一个以八进制表示的数字(基数为8) |
| %p |
以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示 |
| %q |
使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字 |
| %s |
字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符） |
| %t |
以true或者false输出的布尔值 |
| %T |
使用Go语法输出的值的类型 |
| %U |
一个用Unicode表示法表示的整型码点，默认值为4个数字字符 |
| %v |
使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话 |
| %x |
以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示 |
| %X |
以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示 |
|
|
package main
import "fmt"
func main() {
var a int //声明变量
fmt.Printf("请输入变量a: ")
//阻塞等待用户的输入
//fmt.Scanf("%d", &a) //别忘了&
fmt.Scan(&a)
b := "abc"
c := 'a'
d := 3.14
//%T操作变量所属类型
fmt.Printf("%T, %T, %T, %T\n", a, b, c, d)//int, string, int32, float64
//%d 整型格式
//%s 字符串格式
//%c 字符个数
//%f 浮点型个数
fmt.Printf("a = %d, b = %s, c = %c, d = %f\n", a, b, c, d)//a = 14, b = abc, c = a, d = 3.140000
//%v自动匹配格式输出
fmt.Printf("a = %v, b = %v, c = %v, d = %v\n", a, b, c, d)//a = 14, b = abc, c = 97, d = 3.14
}
类型转换
Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。
不能转换的类型，叫不兼容类型
package main
import "fmt"
func main() {
var flag bool
flag = true
fmt.Printf("flag = %t\n", flag)
//bool类型不能转换为int
//fmt.Printf("flag = %d\n", int(flag))
//0就是假，非0就是真
//整型也不能转换为bool
//flag = bool(1)
var ch byte
ch = 'a' //字符类型本质上就是整型
var t int
t = int(ch) //类型转换，把ch的值取出来后，转成int再给t赋值
fmt.Println("t = ", t)
}
