【3w字吐血总结 | 新手必看】全网最详细Go笔记

package main
import "fmt"
func main() {
   fmt.Println("Hello, World!")
}//Println不能写作println

package main
import "fmt"
func main() {
   /* 输出 */
   fmt.Println("Hello, World!")
}

func main()  
{  // 错误，{ 不能在单独的行上
    fmt.Println("Hello, World!")
}

以下是无效的标识符：
1aht（以数字开头）
case（Go 语言的关键字）
a+3（运算符是不允许的）

fmt.Println("Hello, World!")

1. fmt
2. .
3. Println
4. (
5. "Hello, World!"
6. )

package main
import "fmt"
func main() {
    var a = 10; var b = 20; fmt.Println(a + b)
}

package main
import "fmt"
func main() {
    fmt.Println("Qiu" + "Shuo")
}

var a float
const Pi float64 = 3.14159265358979323846

if x<20 {
    // do something
}

result = add(2, 3)

func Sprintf(format string, a ...interface{}) string

package main
import "fmt"
func main() {
    var code = 1
    var date = "2020"
    var url = "Code=%d&date=%s"
    var a = fmt.Sprintf(url, code, date)
    fmt.Println(a)
}

package main
import "fmt"
func main() {
    var code = 2
    var date = "1990"
    var url = "code=%d&date=%s"
    fmt.Printf(url,code,date)
}

1. 整数类型：
   - int：根据程序运行的平台，可以是 32 位或 64 位整数类型。
   - int8、int16、int32、int64：固定长度的有符号整数类型。
   - uint、uint8、uint16、uint32、uint64：固定长度的无符号整数类型。
2. 浮点数类型：
   - float32：单精度浮点数类型，占用 32 位。
   - float64：双精度浮点数类型，占用 64 位。
3. 复数类型：
   - complex64：包含实部和虚部为 float32 类型的复数。
   - complex128：包含实部和虚部为 float64 类型的复数。
4. 布尔类型：
   - bool：表示逻辑值，只能取 true 或 false。
5. 字符串类型：
   - string：表示文本数据，由一系列 Unicode 字符组成。
6. 字符类型：
   - rune：表示单个 Unicode 字符，类型别名为 int32，常用于处理 Unicode 字符串。
7. 字节类型：
   - byte：表示单个字节的数据，类型别名为 uint8，常用于处理二进制数据。
8. 指针类型：
   - *T：表示指向类型 T 的指针，用于间接引用变量。
9. 数组类型：
   - [n]T：表示具有固定长度 n 的同类型元素的数组。
10. 切片类型：
    - []T：表示可变长度的同类型元素序列。
    - 切片可以动态增长和缩减，通常比数组更灵活和方便。
11. 映射类型：
    - map[K]V：表示键值对的无序集合。
    - K 表示键的类型，V 表示值的类型。
    - 常用于实现字典、关联数组等数据结构。
12. 结构体类型：
    - struct：表示用户自定义的复合数据类型。
    - 可以包含不同类型的字段来组成一个结构。
13. 函数类型：
    - func：表示函数类型。
    - 在 Go 语言中，函数是一等公民，可以作为参数、返回值等。
14. 接口类型：
    - interface：表示一组方法的抽象集合。
    - 可以通过实现接口来达到多态的效果。

var a string

var b, c int

a := 1
a, b, c := 5, 7, "abc"

var s string = "qiushuo"
等同于
s:="qiushuo"

例如：
a := 20
a = 24

package main
import "fmt"
func main() {
    // 声明一个变量并初始化
    var a = "Qiushuo" 
    //变量 a 的类型被推断为字符串类型，所以不需要显式地指定它为 string 类型。
    //编译器会根据赋值的值来确定变量的类型。
    fmt.Println(a)
    // 没有初始化就为零值
    var b int
    fmt.Println(b)
    // bool 零值为 false
    var c bool
    fmt.Println(c)
    var d string
    fmt.Println(d)
}

Qiushuo
0
false
""

package main
import "fmt"
var globalVariable int // 定义一个全局变量：globalVariable
func main() {
    globalVariable = 10 // 在主函数中访问和修改全局变量
    fmt.Println(globalVariable)
    someFunction()
}
func someFunction() {
    fmt.Println(globalVariable) // 在其他函数中访问全局变量
}

package main
import "fmt"
func main() {
    someFunction()
}
func someFunction() {
    localVariable := 20 // 局部变量
    fmt.Println(localVariable)
}

package main
import "fmt"
func main() {
    someFunction()
    fmt.Println(localVariable) // 在函数外部尝试访问局部变量，会导致编译错误
}
func someFunction() {
    localVariable := 10 // 声明并初始化局部变量
    fmt.Println(localVariable) // 在函数内部可以访问局部变量
}

package main
import "fmt"
/* 声明全局变量 */
var a int = 20
func main() {
   /* 声明局部变量 */
   var a int = 10
   fmt.Printf ("a=%d",a)
}

a=10

const identifier [type] = value

const Name1, Name2 = value1, value2

const Pi = 3.14 // 定义一个浮点数常量
const MaxSize int = 100 // 定义一个整数常量
const truth = true // 定义一个布尔常量

const (
    Monday    = 0
    Tuesday   = 1
    Wednesday = 2
    Thursday  = 3
    Friday    = 4
    Saturday  = 5
    Sunday    = 6
)

const Greeting = "Hello, world!" // 定义一个字符串常量

package main
import "unsafe"
import "fmt"
func main() {
    const (
        strLen   = len("hello")                 // 使用 len() 函数计算字符串长度
        arrayLen = len([3]int{1, 2, 3})         // 使用 len() 函数计算数组长度
        size     = unsafe.Sizeof(int(0))        // 使用 unsafe.Sizeof() 函数计算整数类型的大小
    )
    sliceLen := len([]int{1, 2, 3})            // 使用 len() 函数计算切片长度
    capacity := cap(make(chan int, 10))        // 使用 cap() 函数计算通道容量
    fmt.Println(strLen, sliceLen, arrayLen, capacity, size)
}

package main
import "fmt"
const (
  Red    = iota // 0
  Green         // 1
  Blue          // 2
)
func main() {
  fmt.Println(Red, Green, Blue)
}

0 1 2

package main
import "fmt"
func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "qiu"   //独立值，iota += 1， iota变为3
            e          
//e是显式赋值的常量声明，它们不会影响 iota 的自增。因此 e 的值仍然是 "qiu"，同时iota += 1， iota变为4 
            f = 100    //iota +=1，iota变为5
            g          //100  iota +=1，iota变为6
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

0 1 2 qiu qiu 100 100 7 8

if condition {
    // 当条件为真时执行的代码块
} else {
    // 当条件为假时执行的代码块（可选）
}

num := 10
if num%2 == 0 {
    fmt.Println("num是偶数")
} else {
    fmt.Println("num是奇数")
}

if condition {
    // 当条件为真时执行的代码块
}

if num := 10; num > 0 {
    fmt.Println("num大于0")
}

switch expression {
case value1:
    // 当expression等于value1时执行的代码块
case value2:
    // 当expression等于value2时执行的代码块
default:
    // 当expression不等于任何已匹配的值时执行的代码块（可选）
}

grade := "C"
switch grade {
case "A":
    fmt.Println("优秀")
case "B":
    fmt.Println("良好")
case "C":
    fmt.Println("及格")
default:
    fmt.Println("不及格")
}

for 初始化语句; 条件表达式; 迭代语句 {
    // 循环体
}

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

for 条件表达式 {
    // 循环体
}

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

for {
    // 循环体
    if !条件表达式 {
        break
    }
}

i := 0
for {
    fmt.Println(i)
    i++
    if i >= 5 {
        break
    }
}

arr := []int{1, 2, 3, 4, 5}
for index, value := range arr {
    fmt.Println(index, value)
}//在每次循环时，range 返回两个值：当前元素的下标 index 和对应的值 value

for i := 0; i < 5; i++ {
    if i == 2 {
        continue
    }
    fmt.Println(i)
}

0
1
3  //i==2时，跳出当前循环，进入下一次循环
4

package main
import "fmt"
func main() {
  i := 0
Loop:
  for i < 5 {
    fmt.Println(i)
    i++
    if i == 3 {
      goto Loop
    }
  }
}

0
1
2
3
4

func function_name( [parameter list] ) [return_types] {
   函数体
}

package main
import "fmt"
// 定义一个计算两个整数之和的函数
func add(x int, y int) int {
  return x + y
}
func main() {
  result := add(3, 5)
  fmt.Println(result) // 输出结果为 8
}

var arrayName [size]dataType

var a [10]float64

var numbers [5]int

var numbers = [5]int{1, 2, 3, 4, 5}

numbers := [5]int{1, 2, 3, 4, 5}

var a = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

//  将索引为 1 和 3 的元素初始化
a := [5]float32{1:9.9,3:7.7}

var b float32 = a[9]

var ptr *Type

ptr = &variable

value = *ptr

*ptr = newValue

package main
import "fmt"
func main() {
    // 定义一个整数变量
    var num int = 42
    // 声明一个指向整数的指针，并将其初始化为num的内存地址
    var ptr *int = &num
    // 输出指针的值和所指向的变量的值
    fmt.Println("指针的值:", ptr) // 输出: 指针的值: 0xc000096068
    fmt.Println("指针所指向的变量的值:", *ptr) // 输出: 指针所指向的变量的值: 42
    // 修改所指向的变量的值
    *ptr = 100
    // 输出被修改后的变量的值
    fmt.Println("被修改后的变量的值:", num) // 输出: 被修改后的变量的值: 100
}

type StructName struct {
    field1 fieldType1
    field2 fieldType2
    // ...
}

var obj StructName

obj.field = value

package main
import "fmt"
// 定义一个结构体类型
type Person struct {
    name string
    age  int
}
func main() {
    // 创建一个结构体对象p1
    var p1 Person
    // 访问结构体字段并赋值
    p1.name = "Alice"
    p1.age = 20
    // 输出结构体字段的值
    fmt.Println("姓名:", p1.name)
    fmt.Println("年龄:", p1.age)
    // 创建结构体对象并初始化
    p2 := Person{name: "Bob", age: 25}
    // 输出结构体字段的值
    fmt.Println("姓名:", p2.name)
    fmt.Println("年龄:", p2.age)
}

package main
import "fmt"
type Person struct {
    name string
    age  int
}
func updateName(p Person) {
    p.name = "Alice"
}
func main() {
    p := Person{name: "Bob", age: 25}
    fmt.Println("修改前:", p)
    updateName(p)
    fmt.Println("修改后:", p)
}
//输出
修改前: {Bob 25}
修改后: {Bob 25}

package main
   import "fmt"
   type Person struct {
       name string
       age  int
   }
   func updateName(p *Person) {
       p.name = "Alice"
   }
   func main() {
       p := &Person{name: "Bob", age: 25}
       fmt.Println("修改前:", p)
       updateName(p)
       fmt.Println("修改后:", p)
   }

var struct_pointer *Person

struct_pointer = &Person1

struct_pointer.title

package main
import "fmt"
type Person struct {
   name string
   age int
}
func main() {
   var Person1 Person        /* 声明 Person1 为 Person  类型 */
   var Person2 Person      /* 声明 Person2 为 Person  类型 */
   /* Person 1 描述 */
   Person1.name="秋说"
   Person1.age="1"
   /* Person 2 描述 */
   Person2.name="花无缺"
   Person2.age="2"
   /* 打印 Person1 信息 */
   printPerson(&Person1)
   /* 打印 Person2 信息 */
   printPerson(&Person2)
}
func printPerson( Person *Person ) {
   fmt.Printf( "Person name : %s\n", Person.name)
   fmt.Printf( "Person age : %d\n", Person.age)
}

slice := array[start:end]

arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // 创建一个切片，包含arr索引1到索引3的元素，即[2, 3, 4]

slice := make([]T, length, capacity)

slice := make([]int, 3, 5)  // 创建一个长度为3，容量为5的切片

slice := []T{element1, element2, ..., elementN}

slice := []int{1, 2, 3, 4, 5}  // 直接创建一个切片，包含元素1到5

length := len(slice)  // 获取切片的长度
capacity := cap(slice)  // 获取切片的容量

slice = append(slice, 6)  // 在切片的末尾追加元素6

for index, value := range slice {
    // 遍历切片的索引和对应的值
}

newSlice := slice[1:3]  // 对切片进行切割，创建新的切片包含索引1到2的元素

slice = append(slice, element1, element2, ..., elementN)

slice := []int{1, 2, 3}
slice = append(slice, 4, 5)  // 追加元素 4 和 5

copy(destSlice, srcSlice)

srcSlice := []int{1, 2, 3}
destSlice := make([]int, len(srcSlice))
copy(destSlice, srcSlice)  // 复制 srcSlice 到 destSlice

package main
import "fmt"
func main() {
    // 创建切片
    numbers := []int{1, 2, 3, 4, 5}
    // 获取切片长度和容量
    fmt.Println("Length:", len(numbers))   // 输出：Length: 5
    fmt.Println("Capacity:", cap(numbers))  // 输出：Capacity: 5
    // 追加元素
    numbers = append(numbers, 6)
    fmt.Println(numbers)  // 输出：[1 2 3 4 5 6]
    // 遍历切片
    for index, value := range numbers {
        fmt.Println(index, value)
    }
    // 切割切片
    newSlice := numbers[1:4]
    fmt.Println(newSlice)  // 输出：[2 3 4]
}

for index, value := range collection {
    // 使用 index 和 value 来处理元素
}

for _, value := range collection {
    // 只使用 value 处理元素，忽略索引
}

package main
import "fmt"
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
 func main() {
   for i, v := range pow {
    fmt.Printf("2**%d = %d\n", i, v)
   }
 }

2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16
2**5 = 32
2**6 = 64
2**7 = 128

package main
import "fmt"
 func main() {
   map1 := make(map[int]float32)
   map1[1] = 1.0
   map1[2] = 2.0
   map1[3] = 3.0
   map1[4] = 4.0
   // 读取 key 和 value
   for key, value := range map1 {
    fmt.Printf("key is: %d - value is: %f\n", key, value)
   }
   // 读取 key
   for key := range map1 {
    fmt.Printf("key is: %d\n", key)
   }
   // 读取 value
   for _, value := range map1 {
    fmt.Printf("value is: %f\n", value)
   }
 }

key is: 4 - value is: 4.000000
key is: 1 - value is: 1.000000
key is: 2 - value is: 2.000000
key is: 3 - value is: 3.000000
key is: 1
key is: 2
key is: 3
key is: 4
value is: 1.000000
value is: 2.000000
value is: 3.000000
value is: 4.000000

// 定义一个键为string类型，值为int类型的map
var m map[string]int
// 初始化map
m = map[string]int{"foo": 1, "bar": 2}
// 或者可以使用make函数初始化map
m = make(map[string]int)

m := make(map[string]int)
// 添加元素
m["foo"] = 1
m["bar"] = 2

delete(m, "bar") // 删除键为"bar"的元素

for key, value := range m {
    fmt.Println(key, value)
}

package main
import "fmt"
func main() {
  // 定义一个string类型的键，int类型的值的map
  scores := make(map[string]int)
  // 添加学生的成绩
  scores["张三"] = 90
  scores["李四"] = 85
  scores["王五"] = 98
  // 循环遍历map中的每个元素
  for name, score := range scores {
    fmt.Printf("%s的成绩是：%d\n", name, score)
  }
  // 删除指定的元素
  delete(scores, "李四")
  // 输出删除后的map
  fmt.Println("删除李四之后的成绩：", scores)
  // 判断指定的键是否存在
  if score, ok := scores["张三"]; ok {
    fmt.Printf("张三的成绩是：%d\n", score)
  } else {
    fmt.Println("找不到张三的成绩")
  }
}

张三的成绩是：90
李四的成绩是：85
王五的成绩是：98
删除李四之后的成绩： map[王五:98 张三:90]
张三的成绩是：90

func recursion() {
   recursion() /* 函数调用自身 */
}
func main() {
   recursion()
}

package main
import "fmt"
// 计算n的阶乘
func factorial(n int) int {
  if n <= 1 {
    return 1
  }
  return n * factorial(n-1)
}
func main() {
  num := 5
  result := factorial(num)
  fmt.Printf("%d的阶乘是：%d\n", num, result)
}

5的阶乘是：120

package main
import "fmt"
func fibonacci(n int) int {
  if n < 2 {
   return n
  }
  return fibonacci(n-2) + fibonacci(n-1)
}
func main() {
    var i int
    for i = 0; i < 10; i++ {
       fmt.Printf("%d\t", fibonacci(i))
    }
}

0    1    1    2    3    5    8    13    21  34

package main
import "fmt"
func main() {
  // 整数类型转换
  var x int = 10
  var y float64 = float64(x)
  fmt.Println(y)
  // 数字类型转换
  var a float64 = 3.14
  var b int = int(a)
  fmt.Println(b)
  // 字符串类型转换
  var s string = "100"
  var c int = int(s) // 错误示例，无法直接将字符串转换为整数
  fmt.Println(c)
  // 使用strconv包进行字符串转换
  import "strconv"
  var s string = "100"
  c, _ := strconv.Atoi(s) // 将字符串转换为整数
  fmt.Println(c)
}

go
type 接口名称 interface {
  方法1() 返回类型
  方法2() 返回类型
  // ...
}

package main
import "fmt"
// 定义接口
type Shape interface {
  Area() float64
  Perimeter() float64
}
// 定义结构体 Circle，并实现 Shape 接口的方法
type Circle struct {
  Radius float64
}
func (c Circle) Area() float64 {
  return 3.14 * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
  return 2 * 3.14 * c.Radius
}
// 定义结构体 Rectangle，并实现 Shape 接口的方法
type Rectangle struct {
  Width  float64
  Height float64
}
func (r Rectangle) Area() float64 {
  return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
  return 2 * (r.Width + r.Height)
}
func main() {
  // 创建一个 Circle 实例
  circle := Circle{Radius: 5}
  fmt.Println("Circle Area:", circle.Area())
  fmt.Println("Circle Perimeter:", circle.Perimeter())
  // 创建一个 Rectangle 实例
  rectangle := Rectangle{Width: 3, Height: 4}
  fmt.Println("Rectangle Area:", rectangle.Area())
  fmt.Println("Rectangle Perimeter:", rectangle.Perimeter())
}

type error interface {
    Error() string
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

result, err:= Sqrt(-1)
if err != nil {
   fmt.Println(err)
}

package main
import (
    "fmt"
)
// 定义一个 DivideError 结构
type DivideError struct {
    dividee int
    divider int
}
// 实现 `error` 接口
func (de *DivideError) Error() string {
    strFormat := `
    Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0
`
    return fmt.Sprintf(strFormat, de.dividee)
}
// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
    if varDivider == 0 {
            dData := DivideError{
                    dividee: varDividee,
                    divider: varDivider,
            }
            errorMsg = dData.Error()
            return
    } else {
            return varDividee / varDivider, ""
    }
}
func main() {
    // 正常情况
    if result, errorMsg := Divide(100, 10); errorMsg == "" {
            fmt.Println("100/10 = ", result)
    }
    // 当除数为零的时候会返回错误信息
    if _, errorMsg := Divide(100, 0); errorMsg != "" {
            fmt.Println("errorMsg is: ", errorMsg)
    }
}

100/10 =  10
errorMsg is:  
    Cannot proceed, the divider is zero.
    dividee: 100
    divider: 0

go 函数名( 参数列表 )

go f(x, y, z)

f(x, y, z)

package main
import (
        "fmt"
        "time"
)
func say(s string) {
        for i := 0; i < 5; i++ {
                time.Sleep(100 * time.Millisecond)
                fmt.Println(s)
        }
}
func main() {
        go say("world")
        say("hello")
}