【GO】基础速成
简单介绍一下go好处
- 编译语言，可以提前报错
- 同时又有python的一些优点，
- 自带多线程
开始学习
学习网站：学习网站
值
包含：字符串、整型、浮点型、布尔型等等
字符串可以 + 进行拼接。
需要注意的是布尔型在go里面不自动转化为int类型，不认为 true为1 false为0。布尔型是布尔型，int类型就是int类型，不可以转化
变量与常量
// 正常声明变量
// var关键字，表示要声明变量，后面加变量名
// 变量名之后加变量类型
// 最后附上初始化的值
var a int = 1
// 省略版声明变量
// 但只能作为局部变量
// 并且必须初始化
// 会自动根据初始化的值为变量设置类型
b := 1
// 能var的地方就能const
// 数值型常量没有确定的类型，直到被给定某个类型，比如显式类型转化。
const n = 123
循环
// 好像只有for 循环
// while的写法
i := 1
for i <= 3 {
i = i + 1
}
// 正常for写法
for i := 0; i <= 2 ; i ++{
//
}
// 死循环
// 只能break掉
// 支持break 与 continue语句
for {
}
if-else & switch
// 没啥好说的
if 7%2 == 0 {
} else if condition {
} else {
}
// switch 有些不一样
// c会继续自动往下执行
// go是你必须显示说明语句才会往下一个case执行
// 所以不需要添加break语句
switch i {
case 1:
// 1干啥
case 2:
// 2干啥
default:
// 最后一个情况干啥
}
数组
一般不用数组，因为跟C数组一样，固定死，不能动态改变
var a [5]int
b := [5]int{1, 2, 3, 4, 5}
c := len(b)
高级数组slice
一般用这个，类似vector的东西吧
// 声明一个slice
// make语句，第一个表示类型，第二个表示个数
s := make([]string, 3)
// 支持len()检测长度
// 支持copy
// 支持append
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("apd:", s)
c := make([]string, len(s))
copy(c, s)
fmt.Println("cpy:", c)
map
// map声明
// 使用make，中括号里面写key的type
// 后面跟上value的type
m := make(map[string]int)
range
类似for-each
nums := []int{2,3,4}
sum := 0
// 遍历数组，slice类似
// 第一个返回下标，第二个返回值
for i, num := range nums{
sum += num
}
// 遍历map
// 第一个返回key, 第二个返回value
m := make(map[string]int)
for key, value := range m {
}
函数
变量数组这些声明都挺抽象的，函数声明更抽象
// func关键字表示要声明一个函数
// 后面跟函数名
// 后面跟形参，先形参名后面跟类型
// 形参写完最后写函数返回值的类型，可以多个
// 够抽象吧？
func plus(a int, b int) int {
return a+b
}
// 多返回值
func mul(a int, b int) (int, int){
return 3,7
}
// 这是对的方式
func xxxx {
}
// 这个是错的方式
func xxx
{
}
还有一个需要极其注意的点是，go语言可以不加封号，是因为在编译时候编译器会帮你加上
前提是你括号写的方式要写对
// 变参函数，也就是说可以输入参数个数不固定，也可以是数组
func sum(nums ...int) {
fmt.Print(nums, " ")
total := 0
for _, num := range nums {
total += num
}
fmt.Println(total)
}
func main(){
sum(1,2)
sum(1,2,3)
nums := []int{1,2,3,4}
sum(nums...)
}
指针
没想到吧？go这沙比还支持指针，而且这个指针跟c感觉差不多。感觉这个语言是个缝合怪
// 直接copy了
package main
import "fmt"
func zeroval(ival int) {
ival = 0
}
func zeroptr(iptr *int) {
*iptr = 0
}
func main() {
i := 1
fmt.Println("initial:", i)
zeroval(i)
fmt.Println("zeroval:", i)
zeroptr(&i)
fmt.Println("zeroptr:", i)
fmt.Println("pointer:", &i)
}
// 最后的result
initial: 1
zeroval: 1
zeroptr: 0
pointer: 0x42131100
结构体
// 结构体声明
// type struct关键字中间加结构体名称
// 里面写成员变量
// 先名称后类型
type person struct {
name string
age int
}
// struct好像没有构造函数
// 所以好像一般使用类似工厂模式写一个方法
// 感觉有点呆
func newPerson(name string, age int) *person {
// 构造结构体对象的各个方法
// 1.按照顺序默认对应
p := person{name, age}
// 2.指明赋值
p := person{name: name, age: age}
// 返回指针
return &p
}
func main(){
s := newPerson("Bob", 23)
// 还有一个点跟C有点不一样
// go的.运算符可以自动解指针，不需要加*了
fmt.Println(s.age)
}
// go 可以对结构体编写成员函数
// func 后面跟括号，里面第一个写变量名 第二个写类型
// 一般要写成指针形式，不然调用函数修改的是你这个对象的拷贝
// 第一个变量就是调用自己这个实例，类似于this或者self
// 所以如果习惯java可以第一个叫this，习惯python可以写self
// 可以自己去试试看
// 加了这一项表名这个方法是person的成员函数
// 由于set方法不需要返回值，所以参数列表之后为空
func (p *person) setAge(age int) {
p.age = age
}
后面接口啥的就不写了，差不多到这基本大体上写写一般程序够用了。
面向对象还要学学继承跟多态，GO语言这两个有点抽象
摆烂先懒得写，后面补