go里面的基本知识

一、函数

1、函数传参默认是传值
2、指针：在函数内对数据进行修改，能够对函数外产生影响
3、函数的定义：

func funcname(argslist type) [return_types]{}
1

4、函数可以传入多个参数，多个返回值
5、可变长参数的函数定义：

func add4(nums ...int){}
1

二、go的数据类型

1、变量定义

1、var a int = 1
2、a := 1
1
2

2、基本的数据类型

int
float
string
byte
bool
1
2
3
4
5

3、nil --》零值
4、指针类型：

1、存放内存地址
2、指针也是有类型的
3、var p *string
	定义了一个string指针
	p中存放一个字符串的地址
1
2
3
4
5

三、go与python的区别：

1、go与python在模块与包上的区别

go：⼀个⽂件夹可以作为 package，同⼀个 package 内部变量、类型、⽅法等定义可以相互看到。
python：必须导入模块里面的包，也就是py文件，才能使用那个模块里面的变量、方法
1
2

2、注意：一般文件中声明的package要与目录同名
3、如果导入的包有同名的情况，可以给他命别名–》import 别名 “导入路径”

四、模块与包

1、package–》目录：

⼀般来说，⼀个⽂件夹可以作为 package，同⼀个 package 内部变量、类型、⽅法等定义可以相互看到
1

1.同一个package中定义的内容是共享的（可见的），不同的包中相互使用通过import “xxx/xxx/包名”导入
2.如何指定是否为同一个包：
	同一个目录下、指定的package相同；
3.如果导入的包有同名的情况，可以给它命别名-->import 别名 "导入路径"
1
2
3
4

2、modules–》包管理的模式：

Go 语⾔也有 Public 和 Private 的概念，粒度是包。如果类型/接⼝/⽅法/函数/字段的⾸字⺟⼤写，则是 Public的，对其他 package 可⻅，如果⾸字⺟⼩写，则是 Private 的，对其他 package 不可⻅
1

共有的--》Public：内容以大写字母开头
私有的--》Private：内容以小写字母开头
1
2

五、流程控制

1、选择结构：

1.1、if–》if/ if else

age := 18
if age < 18 {
    fmt.Printf("Kid")
} else {
    fmt.Println("Adult")
}
​
// 可以简写为：
if age := 18; age < 18 {
    fmt.Println("Kid")
} else {
    fmt.Println("Adult")
}
1
2
3
4
5
6
7
8
9
10
11
12
13

1.2、switch：用于基于不同条件执行不同动作。
同c，但是不需要break，匹配到某个 case，执行完该 case 定义的行为后，默认不会继续往下执行。

// 使用了`type` 关键字定义了一个新的类型 Gender
type Gender int8
​
// 使用 const 定义了 MALE 和 FEMALE 2 个常量
// Go 语言中没有枚举(enum)的概念，一般可以用常量的方式来模拟枚举。
const (
    MALE   Gender = 1
    FEMALE Gender = 2
)
​
gender := MALE
​
switch gender {
    case FEMALE:
        fmt.Println("female")
    case MALE:
        fmt.Println("male")
    default:
        fmt.Println("unknown")
// male
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

如果需要继续往下执行，需要使用 fallthrough

switch gender {
    case FEMALE:
      fmt.Println("female")
      fallthrough
    case MALE:
      fmt.Println("male")
      fallthrough
    default:
      fmt.Println("unknown")
    }
// 输出结果
// male
// unknown
1
2
3
4
5
6
7
8
9
10
11
12
13

2、循环结构

2.1、for循环：
格式：for 初始化数据；条件判断；自增/自减{xxxxx}

sum := 0
for i := 0; i < 10; i++ {
    if sum > 50 {
        break
    }
    sum += i
}
​
fmt.Println(sum)
// 注意这里的i是临时变量，用完回收了
1
2
3
4
5
6
7
8
9
10

2.2、死循环：for true{}和for{}是一个意思

package main
​
import "fmt"
​
func main() {
  for true {
    fmt.Println("这是无限循环。**\n**");
  }
  
  for {
     fmt.Println("这是无限循环。**\n**");
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.3、for range{}：迭代数据

nums := []int{10, 20, 30, 40}
for i, num := range nums {
    fmt.Println(i, num)
}
// 0 10
// 1 20
// 2 30
// 3 40
m2 := map[string]string{
    "Sam":   "Male",
    "Alice": "Female",
}
​
for key, value := range m2 {
    fmt.Println(key, value)
}
// Sam Male
// Alice Female

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

六、go的结构体

1、结构体：由一系列具有相同类型或不同类型的数据构成的数据集合。
2、结构体的组成

1.数据：各种变量
2.方法：函数
1
2

3、结构体定义
需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员

# 例如：定义结构体 Student，并为 Student 添加 name，age 字段
type Student struct {
    name string
    age  int
}
1
2
3
4
5

4、方法定义
实现方法与实现函数的区别在于，func 和函数名hello 之间，加上该方法对应的实例名 stu 及其类型 *Student，可以通过实例名访问该实例的字段name和其他方法了

func (name Student)方法名（参数列表）返回值{
	函数体
}
1
2
3

# 为结构体Student实现 hello() 方法
func (stu *Student) hello(person string) string {
    return fmt.Sprintf("hello %s, I am %s", person, stu.name)
}
1
2
3
4

5、结构体的使用
5.1、实例化结构体语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
1

指针结构体：
    1、stu = &Student{name = "cali",age=18}
    2、stu = new(Student)
普通结构体
	1、stu = Student{name="cali",age=18}
1
2
3
4
5

5.2、案例：

//调用方法通过 实例名.方法名(参数) 的方式。
 // 创建一个实例
    stu := &Student{
        name: "Tom",
    }
    // 调用实例方法
    msg := stu.hello("Jack")
    fmt.Println(msg) // hello Jack, I am Tom
    
    // 使用New实例化
    stu2 := new(Student)
    stu2.name = "Cali"
    fmt.Println(stu2.hello("Alice")) // hello Alice, I am  , name 被赋予默认值""
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6、结构体嵌套

type person struct{
    Name string
    Age int
    Contact struct {
        Phone, City string
        Code int           // 门牌号
    }
}
func main() {
    a := person{Name:"Corwien", Age:15}
    a.Contact.Phone = "10086"
    a.Contact.City = "Guangzhou"
    a.Contact.Code = 2007
  
    fmt.Println(a)
​
}

//结果：
go run struct.go
	{Corwien 15 {10086 Guangzhou 2007}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7、结构体的组合

package main
​
import "fmt"  
​
// 嵌入结构作为匿名字段
type human struct {
    Sex int
}
​
type teacher struct {
    human            // Go会将嵌入字段默认作为属性名,所以在赋值时需要这样写：human: human{Sex: 1}
    Name string
    Age int
}
​
type student struct {
    human
    Name string
    Age int
}
​
func main() {
​
    a := teacher{Name:"Corwien", Age:25, human: human{Sex: 1}}
    b := student{Name:"mark", Age:12, human: human{Sex: 1}}
    
    a.Name = "Jack"
    a.Age = 10
    // a.human.Sex = 0
    a.Sex = 0
    fmt.Println(a, b)
}

//结果：
go run struct.go
	{{0} Jack 10} {{1} mark 12}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38