Go笔记

基本概念与用例

数据类型

  • 数字
  • 字符串
  • 布尔
  • 其他派生类型

数组

go中的数组长度固定,不能动态扩展大小

数组声明

1
2
3
4
5
6
// 格式
var name [size] type
// 初始化
var number = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
// 声明中size可以使用...自动计算所填入的元素个数尺寸来计算size可以使用
var number = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

访问元素

通过索引访问数组元素

1
2
var arr [5]int (1,2,3,4,5)
var number = arr[2] // -> 3

指针

使用&操作符可以获取变量在内存中存放的地址

1
2
3
var a int = 10
fmt.Printf("变量的地址: %x\n", &a)
// -> 变量的地址: 20818a220

声明指针

1
2
// 格式
var name *type

初始化与使用

1
2
3
4
var a int = 20
var ip *int
ip = &a // -> 给指针赋值,值为a变量的内存地址
*ip // -> 使用指针访问值

结构体

声明结构体

1
2
3
4
5
6
type struct_variable_type struct {
member definition;
member definition;
...
member definition;
}

访问结构体成员

使用”.”操作符

1
2
3
4
5
6
7
8
9
10
11
12
package main
import "fmt"
type Book struct {
title string
author string
}
func main() {
var book1 Book
book1.title = "Go语言权威指南"
book1.author = "yrq110"
fmt.Printf( "Book title : %s\n", book1.title);
}

切片

切片相当于一种动态数组,它可以添加与删除元素

声明切片

切片无需设置长度

1
var slice []type

或使用make()创建

1
2
3
var slice1 []type = make([]type, len)
// 或
slice1 := make([]type, len)

初始化

1
s :=[] int {1,2,3}

len()和cap()

使用len()方法获取长度,使用cap()方法获取容量

切片截取

使用[start_index, end_index]进行切片的截取

1
2
numbers := []int{0,1,2,3,4,5,6,7,8}
slice := numbers[2:5] // ->slice=[2 3 4]

append()和copy()

append方法用于添加切片内的元素,copy()用于复制一个切片的内容到另一个切片

变量和常量

变量

声明变量

  1. 指定类型,若不赋值则为默认值

    1
    2
    var a int
    a = 3
  2. 根据值判断类型

    1
    var b = 3
  3. 使用”:=”可以省略var和类型

    1
    name := "yrq110"
  4. 多变量声明
    不同变量使用”,”分隔开

    1
    var name, sex, class string

值类型和引用类型

这一部分类似JS中的原始类型与引用类型,不过JS中的原始类型的变量值是存储在堆中。

值类型

  • int、float、bool和string均属于值类型,直接指向内存中存储的数据
  • 值类型的变量值存储在栈中
  • 使用&i可获得变量i的内存地址

引用类型

  • 引用类型的变量值为指向内存中数据的指针

小技巧

交换两个变量值

1
a, b = b, a

使用”_”抛弃值

下面这个例子中7被抛弃了

1
a, _, b = 5, 7, 6

常量

定义常量

  1. 显式声明

    1
    const name string = "yrq110"
  2. 隐式声明

    1
    const name = "yrq110"
  3. 多重赋值

    1
    const name, class, pass = "yrq110", 8, true

常量的值可以是一个常量计算表达式的值。

特殊常量iota

当const第一次出现时,iota为0,之后每次出现就递增1

1
2
3
4
5
6
const {
a = iota
b
c
}
// -> a = 0 ,b = 1, c = 2

语句

逻辑语句

  • if
  • if…else
  • if嵌套
  • switch
  • select

循环语句

  • for
  • 循环嵌套

循环控制语句

  • break
  • continue
  • goto

无限循环

1
2
3
for true {
fmt.Printf("I'm infinite loop. \n")
}

函数与作用域

函数

格式

1
2
3
func function_name( [parameter list] ) [return_types] {
function_body
}

调用

1
2
3
4
5
6
7
8
9
10
11
12
package main
import "fmt"
func main() {
var a int = 5
var b int = 7
var sum int
sum = add(a, b)
fmt.Printf("the sum is %d\n.", sum)
}
func add (num1, num2 int) int {
return num1 + num2
}

返回多个值

1
2
3
4
5
6
7
8
9
10
11
12
package main
import "fmt"
func main() {
a, b := swap("yrq110", "rizu")
fmt.Printf(a, b)
}
func swap (x, y string) (string, string) {
return y, x
}

参数与用法

  • 值参数与引用参数
  • 函数作为值、闭包与方法

作用域

局部变量

函数内声明的变量时局部变量,作用在函数作用域内,参数与返回值变量也是局部变量

全局变量

在函数体外声明的变量称之为全局变量,全局变量可以在整个包甚至外部包(被导出后)使用。全局变量可以在任何函数中使用。

初始化默认值

类型 初始化默认值
int 0
float32 0
pointer nil
文章目录
  1. 1. 数据类型
    1. 1.1. 数组
      1. 1.1.1. 数组声明
      2. 1.1.2. 访问元素
    2. 1.2. 指针
      1. 1.2.1. 声明指针
      2. 1.2.2. 初始化与使用
    3. 1.3. 结构体
      1. 1.3.1. 声明结构体
      2. 1.3.2. 访问结构体成员
    4. 1.4. 切片
      1. 1.4.1. 声明切片
      2. 1.4.2. 初始化
      3. 1.4.3. len()和cap()
      4. 1.4.4. 切片截取
      5. 1.4.5. append()和copy()
  2. 2. 变量和常量
    1. 2.1. 变量
      1. 2.1.1. 声明变量
      2. 2.1.2. 值类型和引用类型
        1. 2.1.2.1. 值类型
        2. 2.1.2.2. 引用类型
      3. 2.1.3. 小技巧
    2. 2.2. 常量
      1. 2.2.1. 定义常量
      2. 2.2.2. 特殊常量iota
  3. 3. 语句
    1. 3.1. 逻辑语句
    2. 3.2. 循环语句
      1. 3.2.1. 循环控制语句
      2. 3.2.2. 无限循环
  4. 4. 函数与作用域
    1. 4.1. 函数
      1. 4.1.1. 格式
      2. 4.1.2. 调用
      3. 4.1.3. 返回多个值
      4. 4.1.4. 参数与用法
    2. 4.2. 作用域
      1. 4.2.1. 局部变量
      2. 4.2.2. 全局变量
      3. 4.2.3. 初始化默认值
|