GO语言基础笔记（一）：基本语法与数据类型

基本语法

1. 变量声明：

   • 使用 var 关键字，如 var x int 声明一个整型变量 x。
   • 简短声明方式，如 y := 0 直接初始化 y。

2. 函数定义：

   • 使用 func 关键字定义函数，如 func add(a int, b int) int { return a + b }。

3. 控制结构：

   • if 语句、for 循环等，语法类似于其他编程语言。

4. 导入包：

   • 使用 import 关键字导入包，如 import "fmt"。

package main // 定义包名，每个Go程序都是由包组成的

import "fmt" // 导入fmt包，用于格式化输出

// main函数是每个可执行程序的入口点
func main() {
    var x int = 10 // 使用var关键字声明一个整型变量x并初始化为10
    y := 20        // 简短声明方式，声明并初始化变量y为20

    sum := add(x, y) // 调用add函数，传入x和y作为参数
    fmt.Println("Sum:", sum) // 使用fmt包的Println函数打印结果

    // 使用for循环从1加到10
    for i := 1; i <= 10; i++ {
        fmt.Println(i)
    }

    // 使用if语句判断sum是否大于20
    if sum > 20 {
        fmt.Println("Sum is greater than 20")
    } else {
        fmt.Println("Sum is less than or equal to 20")
    }
}

// add函数接收两个int类型的参数，并返回它们的和
// 函数返回值的类型定义在参数列表之后
func add(a int, b int) int {
    return a + b // 返回a和b的和
}

数据类型

基本类型

1. 整型（Integers）：

   • 有符号整型：int8, int16, int32, int64
   • 无符号整型：uint8 (或 byte), uint16, uint32, uint64
   • 通用整型：int, uint（大小依赖于实现，通常为32或64位）
   • 特殊整型：uintptr（用于存储指针）

2. 浮点型（Floats）：

   • float32, float64

3. 复数型（Complex Numbers）：

   • complex64（32位实部和虚部），complex128（64位实部和虚部）

4. 布尔型（Booleans）：

   • bool（值为 true 或 false）

5. 字符串（Strings）：

   • string（使用双引号 "..." 或反引号 `...`）

复合类型

1. 数组（Arrays）：

   • 如 [4]int（含有4个整数的数组）

2. 切片（Slices）：

   • 如 []int（整数的切片，长度可变）

3. 结构体（Structs）：

   • 如 struct { Name string; Age int }

4. 映射（Maps）：

   • 如 map[string]int（键为字符串，值为整数的映射）

引用类型

1. 指针（Pointers）：

   • 如 *int（指向整数的指针）

2. 切片（Slices）：

   • 如前所述，切片是引用类型。

3. 映射（Maps）：

   • 如前所述，映射是引用类型。

4. 通道（Channels）：

   • 用于在不同Goroutines间进行通信，如 chan int

5. 函数类型（Function Types）：

   • 如 func(int) bool（接收一个整数参数，返回布尔值的函数）

接口类型（Interfaces）

• 如 interface{}（空接口，可以持有任何类型的值）

类型代码示例：

package main

import (
	"fmt"
	"math/cmplx"
	"unsafe"
)

// 定义一个结构体
type Person struct {
	Name string
	Age  int
}

// 定义一个接口
type Geometry interface {
	area() float64
}

// 主函数
func main() {
	// 整型
	var a int8 = 127
	var b uint16 = 65535
	var c int = 10000
	var ptr uintptr = uintptr(unsafe.Pointer(&c))

	// 浮点型
	var d float32 = 3.14
	var e float64 = 2.71828

	// 复数型
	var f complex64 = complex(5, 12)
	var g complex128 = cmplx.Sqrt(-5 + 12i)

	// 布尔型
	var h bool = true

	// 字符串
	var i string = "Hello, Go!"

	// 数组
	var j [4]int = [4]int{1, 2, 3, 4}

	// 切片
	k := []int{5, 6, 7, 8}

	// 结构体
	l := Person{Name: "Alice", Age: 30}

	// 映射
	m := map[string]int{"one": 1, "two": 2}

	// 指针
	n := &c

	// 通道
	o := make(chan int)

	// 函数类型
	var p func(int) bool = func(x int) bool {
		return x%2 == 0
	}

	// 接口
	var q Geometry = l

	// 打印变量值
	fmt.Println("int8:", a)
	fmt.Println("uint16:", b)
	fmt.Println("int:", c)
	fmt.Println("uintptr:", ptr)
	fmt.Println("float32:", d)
	fmt.Println("float64:", e)
	fmt.Println("complex64:", f)
	fmt.Println("complex128:", g)
	fmt.Println("bool:", h)
	fmt.Println("string:", i)
	fmt.Println("array:", j)
	fmt.Println("slice:", k)
	fmt.Println("struct:", l)
	fmt.Println("map:", m)
	fmt.Println("pointer:", *n)
	fmt.Println("function:", p(10))
	fmt.Println("interface:", q.area())

	// 使用通道
	go func() {
		o <- 123
	}()
	fmt.Println("channel:", <-o)
}

// 实现Person类型的area方法
func (p Person) area() float64 {
	return float64(p.Age) // 随意计算的“面积”
}