Go语言
1、程序的一般结构
- go程序是通过package来组织的，
- 只有package名称为main的包可以包含main函数，
- 一个可执行程序有且仅有一个main包
2、Go导入package的格式
- 引包后若未调用其中的函数或者类型，将编译出错
第一种
import "fmt"
----------------------
第二种
import（
fm "fmt" //起别名，可以使用 fm.Println("xx")
o "math" //起别名，可以使用 o.Min()
. "fmt" // 可以省略调用 直接 Println("xxx")，不建议使用
）
3、可见性规则
- Go中由大小写决定该常量、变量、类型、接口、结构、或函数 是否可以被外部包所调用：
- 约定函数名首字母小写即为 private 大写即为public
Go的基本类型：
- bool ：1字节，true or false 和js不同，不可以用数字代表他们
- 整型 ：int / uint 根据平台可能问32或者64位
- 8位整型： int8 / uint8 长度：1字节，取值范围-128~127/0~255
- 字节型：byte(uint8别名)
- 16位整型：int16 / uint16 长度2字节，范围-32768~32767/0~65535
- 32位整型：int32（rune）/uint32 长度：4字节
- 64位整型：int64/uint64 长度：8字节
- 浮点型：float32/float64 长度：4/8字节 小数位：精确到7/15小数位
- 复数：complex64/complex128 长度：8/16字节
- 其它值类型：array、struct、string
- 引用类型：slice、map、chan
- 接口类型：inteface
- 函数类型：func
1、类型零值
零值并不等于空值，而是当变量被声明为某种类型后的默认值，通常情况下值类型的默认值为0，bool为false，string为空字符串
Go的基础类型.png
变量的声明和赋值
变量的声明方式：var 变量名 类型
var i int // 变量声明了必须要用，否则报错，同一个作用域内变量声明唯一
var a,b int // 同时声明多个变量
// 声明同时赋值
var i int = 10
//自动推导类型，必须初始化，通过初始化的值确定类型
c := 10
var c = 10 // 这也是自动推导类型
fmt.Printf("c type is %T", c ) // %T打印变量所属类型
// Printf 和Println的区别
Println("a = " ,a) //自动加换行
Printf("a = %d " ,a) // 格式化输出，(%T-输出类型) (%s-字符串输出)（%d-整型输出）（%c-字符输出）
//多重赋值和匿名变量
// 交换2个变量的值
a,b := 1,2
a,b = b, a // ----> a=2, b=1
// 匿名变量
var temp int
temp, _ = a, b // ------> temp =1,b的值就被抛弃了，_为匿名变量，要配合函数的返回值使用才有用处
eg： func test(a,b,c int)(int,int,int){
return 1,2,3
}
var c,d,e int
c,d,e = test() // c = 1, d = 2, e = 3
_,d,_ = test() // d = 2
// 多个变量不同类型的定义：
var (
a int // a int = 10 还可以赋值
b float64
c string
)
自动推导类型
var (
a = 1
b = 12.2
c = "test"
)
常量的使用
常量声明方式： const 常量名 常量类型 = 值 (写了无法改变)
const a int = 10 // 声明式
const b = 11.2 //自动推导式 没有使用 b := ,这是和 变量的推导式不一样的地方
fmt.Printf("b type is %T \n", b) // => float64因为比float32精度更高
// 多个常量不同类型的定义：
const (
a int = 1
b float64 = 11.33
c string = "test"
)
// 自动推导类型
cosnt(
a = 1
b = 11.11
)
iota 枚举
含义：iota 常量自动生成器，每个一行，自动累加1，给常量赋值使用,iota yudao const重置为0
cosnt (
a = iota // a = 0
b = iota // b= 1
c = iota // c = 2
)
cosnt (
a1 = iota // a1 = 0
b1 // b1 = 1
c1
)
const (
a1 = iota // 0
a2,a3,a4 = iota,iota,iota //全是1
a5 = iota // 2
)
字符串类型和字符类型的区别
使用内建函数len() 能得到字符串的长度。
字符串string：“” ，由字符组成
字符char：‘’
字符串都是隐藏了一个结束符' \0' // str = "a" 由'a' 和'\0'组成一个字符串可以通过 atr[0] 下标访问
复数类型
形如a+bi（a,b均为实数）的数称为复数，其中a称为实部，b称为虚部
var t complex128 // 声明
t = 1.2 + 2.34i // 赋值 = > (1.2+2.34i)
通过内建函数 real() 取实部,imag() 取虚部
fmt.Println("实部为"，real(t), "虚部为"，imag(t))
格式化输出 ------ 输入
格式化输出
a ,b := 1,2
fmt.Printf("%T,%T",a)
%T // 操作变量的所属类型
%d // 整型格式
%v // 自动匹配格式输出
%c // 字符格式
%f // 浮点数格式
%s // 字符串格式
用户输入
var a int
fmt.Scanf("%d",&a) // 别忘了 &
简单写法 fmt.Scan(&a)
类型转换
bool和int之间不能互转，因为他们是不兼容类型
byte 能转为 int，因为字符类型本质就是整型
var a byte
var b int
a = 10
b = byte( a )
fmt.Println( " b is ", b) 报错// (type byte) as type int in assignment
类型别名：
别名形式： type 类型别名 类型 eg: type bigint int64 // 使用 var a bigint === var a int64
运算符
-
、- 、 *、 / 、 %(取余)、 ++ (只有a ++ ,没有 ++a)、 -- (和++一样)
== 、!=、>、 <、 <=、 >=
！（非）、&&（与）、|| （或）
& （按位与）、|（按位或）、^（异或）、<<(左移)、>>（右移）:位运算符
运算符的优先级.png
流程控制
if
a := 1
if a == 1{
fmt.Println('ok')
}
// if支持一个初始化语句，初始化语句和判断条件以分号分割
if a :=10; a==10{
fmt.Println('ok')
}
// if-else
if a:=10; a==10{
}else{}
//if - else if -else if - else
if a:=10; a==10{
}else if a > 10{
}else if a < 10{
}else{}
switch
num := 1
switch num {
case 1:
fmt.Println("1")
break // go默认实现了break,可以写可以不写
fallthrough // 不跳出switch,后面的第一个case无条件执行
case 2,3,4:
fmt.Println("2")
....
default:
fmt.Println("xx")
}
// 支持一个初始化语句，初始化语句后用分号分割，也可以没有任何
switch num:=1; num {
}
score := 21
switch {
case score > 90:
xxxx
......
}
for 初始化条件； 判断条件； 条件变化{}
for i:=1; i<=100; i++{
}
for { // 死循环
}
// 通过for 打印每个字符：
str := "test"
for i :=0; i < len(str); i++{
fmt.Println("%s",str[i])
}
//通过迭代改写, range 默认返回2个值，一个是元素的位置，一个是元素本身
for i,v :=range str {
fmt.Println("%s",v)
}
另外种写法
for i := range str { // 类似于 for i,_ := range str
fmt.Println("%s",str[i])
}
break 和continue 和 goto
break可以用于for、switch、select，而continue仅能用于for循环
i := 1
for {
i ++
if i ==5{
break // 跳出最近的循环，continue跳过本次循环，执行下次循环
}
}
// goto关键字，aa为用户起的标签名字，goto可以任何地方使用，但是不能跨函数间使用
func main(){
goto aa
fmt.Print("11111")
aa:
fmt.Print("xxx")
}
