常用数据类型
基本类型：
- 空 nil
- 布尔 boolean
- 字符串 string
- 整数 int int8 int16 int32 int64
- 无符号整数 uint uint8 uint16 uint32 uint64 uintptr
- 浮点数 float32 float64
- 复数 complex64 complex128
聚合类型
- 数组 array
- 结构体 struct
引用类型
- 指针 pointer
- 切片 slice
- 集合 map
- 函数 function
- 通道 channel
接口类型
- 接口 interface
go文件结构
package main
import ( // 包引入
"fmt"
)
func test() {
}
func main() { // 主go程 入口函数
fmt.Println("Hello World!")
}
变量定义
声明定义变量
var 变量名 变量类型 = 变量值
// 例子
var str string = "sss"// 字符串
var num1 int = 123 // 整数型
var num2 float32 = 123.21 // 32位浮点数
var num3 float64 = 123.12// 64位浮点数
var x complex128 = complex(1, 2) // 1+2i 复数
简便定义(会自动识别定义数据类型)
str1 := "www"
num4 := 123
x1 := complex(1, 2)
指针类型
num := 32
var p *int = &num // 定义一个指针类型的p变量 指向num的地址
fmt.Println(p)
类型转换
类型 B 的值 = 类型 B(类型 A 的值)
// 例子
a := 5.0
b := int(a) // b = 5
流程控制
条件判断
if 判断条件1 {
...
} else if 判断条件2 {
...
} else {
...
}
// 特殊写法
// 可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断
if err := Connect(); err != nil {
fmt.Println(err)
return
}
循环
// for 循环
for i:= 0; i< 10; i++ {
...
}
// 无限循环
sum := 0
for {
sum++
if sum > 100 {
break
}
}
// 键值循环
arr := []int{1, 2, 3, 4}
for key, val := range arr {
fmt.Printf("key:%d value:%d\n", key, val)
}
// 遍历字符串
str := "hello 你好"
for key, val := range str {
fmt.Printf("key:%d value:0x%x\n", key, val)
}
// 遍历map
m := map[string]int{
"hello": 100,
"world": 200,
}
for key, value := range m {
fmt.Println(key, value)
}
// 匿名变量
for key, _ := range []int{1, 2, 3, 4} {
fmt.Printf("key:%d \n", key)
}
switch语句
var a = "hello"
switch a {
case "hello":
fmt.Println(1)
case "world":
fmt.Println(2)
default:
fmt.Println(0)
}
函数
func 函数名(形式参数列表)(返回值列表){
函数体
}
func sum(a, b int) int {
return a + b
}
sum(1, 2)
// 没有返回值的函数
func noRes() {
fmt.Println("没有返回值")
}
// 已知参数类型，未知参数数量
func myfunc1(args ...int) {
for _, arg := range args {
fmt.Println(arg)
}
}
// 若不知参数类型 interface{}表示任意类型
func myfunc2(args ...interface{}) {
fmt.Println(args)
}
// 匿名函数
func (name string) {
fmt.Println("Hello", name)
}("华住")
// 结构体函数（方法）后面讲
结构体
type 类型名 struct {
字段1 字段1类型
字段2 字段2类型
…
}
// 定义person 结构体
type person struct {
name string
age int
}
// 初始化结构体
/**
p := new (person)
p.name = "mm"
p.age = 10
fmt.Println(p) // &{mm, 10}
fmt.Printf("name is %s, age is %d\n", p.name, p.age)
*/
p := person{"小明", 18} // 顺序初始化，必须全部字段
// p:=person{age: 19} // 命名初始化 不必按照顺序 不必全部字段
fmt.Println(p) // {小明, 18}
fmt.Printf("name is %s, age is %d\n", p.name, p.age)
方法
package main
import "fmt"
type rect struct {
width int
height int
}
func (r *rect) area() int {
return r.width * r.height
}
func (r *rect) perim() int {
return 2*r.width + 2*r.height
}
func main() {
r := rect{20, 10}
fmt.Printf("area is %d, perim is %d\n", r.area(), r.perim())
}
接口
接口 是方法特征的命名集合
type 接口类型名 interface{
方法名1( 参数列表1 ) 返回值列表1
方法名2( 参数列表2 ) 返回值列表2
...
}
接口的实现
首先，我们定义了一个接口 InterfaceName，该接口有两个方法，分别为 func1 和 func2。接着，我们为类型 T 定义了两个方法，func1 和 func2 因为，T 的方法 func1 和 func2 的方法签名和接口 InterfaceName 中的一模一样，并且 T 实现了 InterfaceName 中所有的方法 因此，我们就说 T 实现了接口 InterfaceName
package main
import (
"fmt"
)
type Personer interface {
Eat()
Sleep(duration int)
}
type Student struct {
Name string
Age int
}
func (stu Student)Eat(){
fmt.Println("Student is eating")
}
func (stu Student)Sleep(duration int){
fmt.Println("Sleep duration:", duration, "hours")
}
func main() {
var person Personer
var stu Student
person = stu
person.Eat()
person.Sleep(8)
}
一个类型可以实现多个接口,一个接口也可以被多个类型实现
