第3课：Go 基本语法 - 努努力教程

：Go 基本语法

Go程序结构

基本程序结构

package main           // 包声明

import "fmt"          // 导入包

func main() {         // 主函数
    fmt.Println("Hello, World!")
}

程序组成部分

包声明：每个Go文件都必须以包声明开始
导入语句：导入需要使用的包
函数：程序的基本执行单元
变量：存储数据的容器
语句和表达式：程序的执行逻辑

包（Package）

包的概念

Go程序由包组成
main包是程序的入口点
包名通常与目录名相同

包的声明

package main        // 可执行程序
package utils       // 库包
package models      // 模型包

导入包

// 单个导入
import "fmt"
import "os"

// 批量导入
import (
    "fmt"
    "os"
    "strings"
)

// 别名导入
import (
    f "fmt"
    "os"
)

// 匿名导入（只执行包的init函数）
import _ "database/sql/driver"

变量

变量声明

方式一：var关键字

var name string
var age int
var isStudent bool

// 带初始值
var name string = "张三"
var age int = 20
var isStudent bool = true

// 类型推断
var name = "张三"
var age = 20
var isStudent = true

// 批量声明
var (
    name      string = "张三"
    age       int    = 20
    isStudent bool   = true
)

方式二：短变量声明

name := "张三"
age := 20
isStudent := true

// 多变量声明
name, age := "张三", 20

变量的零值

var i int       // 0
var f float64   // 0.0
var b bool      // false
var s string    // ""
var p *int      // nil

变量作用域

package main

import "fmt"

var globalVar = "全局变量"  // 包级别变量

func main() {
    var localVar = "局部变量"  // 函数级别变量
    
    if true {
        var blockVar = "块级变量"  // 块级别变量
        fmt.Println(blockVar)
    }
    
    fmt.Println(globalVar)
    fmt.Println(localVar)
    // fmt.Println(blockVar)  // 错误：超出作用域
}

常量

常量声明

const PI = 3.14159
const NAME = "Go语言"

// 批量声明
const (
    PI   = 3.14159
    E    = 2.71828
    NAME = "Go语言"
)

// 类型化常量
const PI float64 = 3.14159
const NAME string = "Go语言"

iota枚举器

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

// 跳过某些值
const (
    _ = iota         // 跳过0
    KB = 1 << (10 * iota)  // 1024
    MB                     // 1048576
    GB                     // 1073741824
)

数据类型

基本数据类型

1. 整型

// 有符号整型
var i8 int8 = 127        // -128 到 127
var i16 int16 = 32767    // -32768 到 32767
var i32 int32 = 2147483647
var i64 int64 = 9223372036854775807

// 无符号整型
var ui8 uint8 = 255      // 0 到 255
var ui16 uint16 = 65535  // 0 到 65535
var ui32 uint32 = 4294967295
var ui64 uint64 = 18446744073709551615

// 平台相关
var i int = 42           // 32位或64位
var ui uint = 42         // 32位或64位
var ptr uintptr = 0      // 指针大小

2. 浮点型

var f32 float32 = 3.14
var f64 float64 = 3.141592653589793

// 科学计数法
var big float64 = 1.23e9    // 1.23 * 10^9
var small float64 = 1.23e-9 // 1.23 * 10^-9

3. 复数型

var c64 complex64 = 1 + 2i
var c128 complex128 = 1 + 2i

// 使用complex函数
var c = complex(1, 2)  // 1+2i

// 获取实部和虚部
real := real(c)  // 1
imag := imag(c)  // 2

4. 布尔型

var isTrue bool = true
var isFalse bool = false

// 布尔运算
var result bool = true && false  // false
var result2 bool = true || false // true
var result3 bool = !true         // false

5. 字符串

var str string = "Hello, Go!"
var str2 string = `这是一个
多行字符串`

// 字符串操作
length := len(str)           // 字符串长度
char := str[0]              // 获取字节
substr := str[0:5]          // 子字符串
concat := str + " World"    // 字符串连接

6. 字符类型

var char byte = 'A'         // byte是uint8的别名
var unicode rune = '中'      // rune是int32的别名

// Unicode字符
var emoji rune = '😀'

复合数据类型

1. 数组

// 声明数组
var arr [5]int
var arr2 = [5]int{1, 2, 3, 4, 5}
var arr3 = [...]int{1, 2, 3, 4, 5}  // 自动推断长度

// 访问数组元素
arr[0] = 10
value := arr[0]

// 数组长度
length := len(arr)

2. 切片

// 声明切片
var slice []int
var slice2 = []int{1, 2, 3, 4, 5}

// 从数组创建切片
arr := [5]int{1, 2, 3, 4, 5}
slice3 := arr[1:4]  // [2, 3, 4]

// 使用make创建切片
slice4 := make([]int, 5)      // 长度为5
slice5 := make([]int, 5, 10)  // 长度为5，容量为10

// 切片操作
slice = append(slice, 1, 2, 3)  // 添加元素
length := len(slice)            // 长度
capacity := cap(slice)          // 容量

3. 映射（Map）

// 声明映射
var m map[string]int
m = make(map[string]int)

// 直接初始化
var m2 = map[string]int{
    "apple":  5,
    "banana": 3,
    "orange": 8,
}

// 映射操作
m["apple"] = 5              // 设置值
value := m["apple"]         // 获取值
value, ok := m["apple"]     // 检查键是否存在
delete(m, "apple")          // 删除键值对

4. 指针

var x int = 42
var p *int = &x    // p指向x的地址

fmt.Println(*p)    // 解引用，输出42
*p = 100          // 通过指针修改值
fmt.Println(x)    // 输出100

// 零值指针
var p2 *int       // nil

运算符

算术运算符

a, b := 10, 3

sum := a + b      // 13 加法
diff := a - b     // 7  减法
product := a * b  // 30 乘法
quotient := a / b // 3  除法
remainder := a % b // 1  取余

比较运算符

a, b := 10, 20

equal := a == b        // false 等于
notEqual := a != b     // true  不等于
less := a < b          // true  小于
lessEqual := a <= b    // true  小于等于
greater := a > b       // false 大于
greaterEqual := a >= b // false 大于等于

逻辑运算符

a, b := true, false

and := a && b    // false 逻辑与
or := a || b     // true  逻辑或
not := !a        // false 逻辑非

位运算符

a, b := 12, 25  // 二进制：1100, 11001

and := a & b     // 8   按位与
or := a | b      // 29  按位或
xor := a ^ b     // 21  按位异或
not := ^a        // -13 按位取反
leftShift := a << 2   // 48  左移
rightShift := a >> 2  // 3   右移

赋值运算符

a := 10

a += 5    // a = a + 5  (15)
a -= 3    // a = a - 3  (12)
a *= 2    // a = a * 2  (24)
a /= 4    // a = a / 4  (6)
a %= 5    // a = a % 5  (1)

其他运算符

// 地址运算符
var x int = 42
ptr := &x    // 获取x的地址

// 解引用运算符
value := *ptr  // 获取指针指向的值

// 自增自减
i := 5
i++    // i = 6
i--    // i = 5

类型转换

基本类型转换

var i int = 42
var f float64 = float64(i)  // int转float64
var u uint = uint(f)        // float64转uint

// 字符串转换
var s string = string(65)   // "A"
var b []byte = []byte("Hello")  // 字符串转字节切片
var s2 string = string(b)   // 字节切片转字符串

类型断言

var i interface{} = "Hello"

// 类型断言
s := i.(string)        // 断言i是string类型
s, ok := i.(string)    // 安全的类型断言

// 类型选择
switch v := i.(type) {
case string:
    fmt.Printf("字符串: %s\n", v)
case int:
    fmt.Printf("整数: %d\n", v)
default:
    fmt.Printf("未知类型: %T\n", v)
}

控制结构

if语句

age := 18

if age >= 18 {
    fmt.Println("成年人")
} else if age >= 13 {
    fmt.Println("青少年")
} else {
    fmt.Println("儿童")
}

// if语句的初始化
if num := 10; num > 5 {
    fmt.Println("num大于5")
}

switch语句

grade := "A"

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

// 多值case
switch grade {
case "A", "B":
    fmt.Println("优秀或良好")
case "C":
    fmt.Println("及格")
default:
    fmt.Println("不及格")
}

// 无表达式switch
score := 85
switch {
case score >= 90:
    fmt.Println("优秀")
case score >= 80:
    fmt.Println("良好")
case score >= 60:
    fmt.Println("及格")
default:
    fmt.Println("不及格")
}

for循环

// 基本for循环
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// while风格
i := 0
for i < 10 {
    fmt.Println(i)
    i++
}

// 无限循环
for {
    // 无限循环
    break  // 使用break跳出
}

// range循环
slice := []int{1, 2, 3, 4, 5}
for index, value := range slice {
    fmt.Printf("索引: %d, 值: %d\n", index, value)
}

// 只要值
for _, value := range slice {
    fmt.Printf("值: %d\n", value)
}

// 只要索引
for index := range slice {
    fmt.Printf("索引: %d\n", index)
}

跳转语句

// break：跳出循环
for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Println(i)
}

// continue：跳过当前迭代
for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue
    }
    fmt.Println(i)  // 只打印奇数
}

// goto：跳转到标签
func example() {
    i := 0
Loop:
    if i < 5 {
        fmt.Println(i)
        i++
        goto Loop
    }
}

函数基础

函数定义

// 基本函数
func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

// 带返回值的函数
func add(a, b int) int {
    return a + b
}

// 多返回值
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

// 命名返回值
func calculate(a, b int) (sum, product int) {
    sum = a + b
    product = a * b
    return  // 自动返回命名的返回值
}

函数调用

greet("Go语言")

result := add(3, 5)
fmt.Println(result)

quotient, err := divide(10, 3)
if err != nil {
    fmt.Printf("错误: %v\n", err)
} else {
    fmt.Printf("结果: %.2f\n", quotient)
}

总结

本课我们学习了Go语言的基本语法：

程序结构：包、导入、函数
变量和常量：声明、初始化、作用域
数据类型：基本类型和复合类型
运算符：算术、比较、逻辑、位运算
控制结构：if、switch、for循环
函数基础：定义和调用

下一课预告

在下一课中，我们将深入学习Go语言的数据类型，包括：

数组和切片的高级用法
映射的详细操作
结构体的定义和使用
接口的概念和实现

💡 小贴士：Go语言的语法简洁明了，多练习是掌握的关键。建议每学完一个概念就动手编写代码验证。

📚 文章对你有帮助？请关注我的公众号，万分感谢！

获取更多优质技术文章，第一时间掌握最新技术动态

关注公众号

第一时间获取最新技术文章

添加微信

技术交流 · 问题答疑 · 学习指导

当前课程

标签

Go程序结构

基本程序结构

程序组成部分

包（Package）

包的概念

包的声明

导入包

变量

变量声明

方式一：var关键字

方式二：短变量声明

变量的零值

变量作用域

常量

常量声明

iota枚举器

数据类型

基本数据类型

1. 整型

2. 浮点型

3. 复数型

4. 布尔型

5. 字符串

6. 字符类型

复合数据类型

1. 数组

2. 切片

3. 映射（Map）

4. 指针

运算符

算术运算符

比较运算符

逻辑运算符

位运算符

赋值运算符

其他运算符

类型转换

基本类型转换

类型断言

控制结构

if语句

switch语句

for循环

跳转语句

函数基础

函数定义

函数调用

总结

下一课预告

📚 文章对你有帮助？请关注我的公众号，万分感谢！

评论讨论