Go-01-基本语法与数据类型

2026-09-01

字数统计: 1.8k字 | 阅读时长≈ 9分

Go-01-基本语法与数据类型

本节目标：掌握 Go 的基本数据类型、运算符、控制流和格式化输出，能独立完成谭浩强《C 程序设计》课后习题级别的程序。

1. 第一个 Go 程序

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

Go 程序由 包（package） 组成，main 包是入口。import 引入标准库或第三方包。func 声明函数，main 函数无参数无返回值。

运行：

1 2	$ go run hello.go Hello, Go!

编译为可执行文件：

1
2
3

$ go build -o hello hello.go
$ ./hello
Hello, Go!

2. 基本数据类型

Go 是静态类型语言，类型在编译时确定。常见类型：

类型	含义	零值	示例
`bool`	布尔	`false`	`var ok bool`
`int`, `int8`/`16`/`32`/`64`	整型	`0`	`var n int = 42`
`uint`, `uint8`/`16`/`32`/`64`	无符号整型	`0`	`var b byte = 255`
`float32`, `float64`	浮点	`0.0`	`var pi float64 = 3.14`
`complex64`, `complex128`	复数	`0+0i`	`var z complex128 = 1 + 2i`
`string`	字符串（不可变）	`""`	`var s string = "Go"`
`byte` (= `uint8`)	字节	`0`	`var b byte = 'A'`
`rune` (= `int32`)	Unicode 码点	`0`	`var r rune = '中'`

类型推断：用 := 可以省略类型：

x := 42        // int
pi := 3.14     // float64
name := "Go"   // string
ok := true     // bool

常量：用 const 声明，可以是无类型常量（更灵活）：

const Pi = 3.14159         // 无类型，自动适配
const (
    StatusOK = 200
    StatusNotFound = 404
)
const (
    A = iota   // 0
    B          // 1
    C          // 2
)

3. 数学运算符

Go 的算术运算符和 C 几乎一样：

a, b := 10, 3

fmt.Println(a + b)   // 13
fmt.Println(a - b)   // 7
fmt.Println(a * b)   // 30
fmt.Println(a / b)   // 3   ← 整数除法截断
fmt.Println(a % b)   // 1

// 浮点除法
fmt.Println(10.0 / 3.0)  // 3.3333333333333335

// 自增自减（注意：Go 没有 ++a，只有 a++）
a++  // a = 11
a--  // a = 10

比较运算符：==, !=, <, <=, >, >=（返回 bool）。
逻辑运算符：&&, ||, !。
位运算符：&, |, ^（异或），&^（位清空），<<, >>。

a, b := 12, 10
fmt.Println(a & b)   // 8   (1100 & 1010 = 1000)
fmt.Println(a | b)   // 14
fmt.Println(a ^ b)   // 6
fmt.Println(a &^ b)  // 4   (1100 &^ 1010 = 0100)
fmt.Println(a << 2)  // 48
fmt.Println(a >> 1)  // 6

4. 控制流

if / else

if x > 0 {
    fmt.Println("positive")
} else if x < 0 {
    fmt.Println("negative")
} else {
    fmt.Println("zero")
}

Go 特色：可以在 if 条件前执行一个简短语句（作用域只在 if/else 内）：

1
2
3

if err := doSomething(); err != nil {
    return err
}

for 循环

Go 只有 for 一种循环关键字（没有 while / do-while）：

// 经典 for
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// while 风格
n := 0
for n < 10 {
    n++
}

// 无限循环
for {
    // break / return 退出
}

// for-range 遍历
nums := []int{1, 2, 3}
for i, v := range nums {
    fmt.Printf("index=%d value=%d\n", i, v)
}

// 忽略 index
for _, v := range nums {
    fmt.Println(v)
}

switch

Go 的 switch 自动 break，不会 fall-through（除非显式 fallthrough）：

day := "Mon"
switch day {
case "Mon", "Tue", "Wed", "Thu", "Fri":
    fmt.Println("weekday")
case "Sat", "Sun":
    fmt.Println("weekend")
default:
    fmt.Println("unknown")
}

type switch（处理 interface{} 的具体类型）：

var x interface{} = 42
switch v := x.(type) {
case int:
    fmt.Println("int:", v)
case string:
    fmt.Println("string:", v)
}

5. 格式化输出（Print 系列）

Go 的 fmt 包提供了和 C 类似但更强大的格式化输出：

name := "Go"
version := 1.22
pi := 3.14159265358979

// Print / Println
fmt.Print("Hello")             // 不换行
fmt.Println("Hello")           // 换行
fmt.Printf("Hello\n")          // 格式化

// Printf 常用动词
fmt.Printf("%s\n", name)                    // 字符串
fmt.Printf("%d\n", 42)                      // 十进制整数
fmt.Printf("%x\n", 255)                     // 十六进制  (ff)
fmt.Printf("%b\n", 10)                      // 二进制    (1010)
fmt.Printf("%f\n", pi)                      // 浮点      (3.141593)
fmt.Printf("%.2f\n", pi)                    // 2 位小数  (3.14)
fmt.Printf("%e\n", pi)                      // 科学计数  (3.141593e+00)
fmt.Printf("%t\n", true)                    // 布尔
fmt.Printf("%c\n", 'A')                     // 字符
fmt.Printf("%q\n", "Go")                    // 带引号    ("Go")
fmt.Printf("%v\n", []int{1, 2, 3})          // 默认格式 ([1 2 3])
fmt.Printf("%+v\n", struct{A int}{1})       // 带字段名 ({A:1})
fmt.Printf("%T\n", name)                    // 类型      (string)
fmt.Printf("%p\n", &name)                   // 指针
fmt.Printf("|%10s|\n", "Go")                // 宽度 10 右对齐 (|        Go|)
fmt.Printf("|%-10s|\n", "Go")               // 宽度 10 左对齐 (|Go        |)
fmt.Printf("|%010d|\n", 42)                 // 0 填充     (|0000000042|)

Sprintf：返回字符串而不是打印。

1	s := fmt.Sprintf("Hello, %s! pi=%.2f", "Go", pi)

Fprintf：写到 io.Writer（如文件、网络连接）。

1	fmt.Fprintf(os.Stderr, "error: %v\n", err)

6. 谭浩强课后习题实战

例题 1：输入两个整数，输出它们的和、差、积、商、余。

package main

import "fmt"

func main() {
    var a, b int
    fmt.Print("请输入两个整数（空格分隔）：")
    fmt.Scanln(&a, &b)

    if b == 0 {
        fmt.Println("除数不能为零")
        return
    }

    fmt.Printf("%d + %d = %d\n", a, b, a+b)
    fmt.Printf("%d - %d = %d\n", a, b, a-b)
    fmt.Printf("%d * %d = %d\n", a, b, a*b)
    fmt.Printf("%d / %d = %d\n", a, b, a/b)
    fmt.Printf("%d %% %d = %d\n", a, b, a%b)
}

例题 2：求 1+2+3+…+n。

package main

import "fmt"

func main() {
    var n int
    fmt.Print("请输入 n: ")
    fmt.Scanln(&n)

    sum := 0
    for i := 1; i <= n; i++ {
        sum += i
    }
    fmt.Printf("1+2+...+%d = %d\n", n, sum)
}

例题 3：判断一个数是否为素数。

package main

import "fmt"

func isPrime(n int) bool {
    if n < 2 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    for i := 2; i <= 100; i++ {
        if isPrime(i) {
            fmt.Printf("%d ", i)
        }
    }
    fmt.Println()
}

例题 4：打印九九乘法表。

package main

import "fmt"

func main() {
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            fmt.Printf("%d*%d=%2d  ", j, i, i*j)
        }
        fmt.Println()
    }
}

例题 5：求两个数的最大公约数（辗转相除法）。

package main

import "fmt"

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

func main() {
    fmt.Println(gcd(12, 18))  // 6
    fmt.Println(gcd(100, 75)) // 25
}

7. 类型转换

Go 不支持隐式类型转换，必须显式：

var i int = 42
var f float64 = float64(i)   // 合法
// var f2 float64 = i         // 编译错误

// 整数与字符串的转换（不能直接强转！）
n := 65
// s := string(n)   // 注意：这不是 "65"，是 ASCII 字符 'A'
// fmt.Println(s)   // 输出 "A"

字符串和数字互转用 strconv：

import "strconv"

s := strconv.Itoa(42)         // int -> string: "42"
n, err := strconv.Atoi("42")  // string -> int: 42, nil
f, _ := strconv.ParseFloat("3.14", 64)

8. 指针入门

Go 有指针，但不支持指针运算：

x := 42
p := &x         // p 是 *int，指向 x
fmt.Println(*p) // 42（解引用）
*p = 100        // 通过指针修改 x
fmt.Println(x) // 100

new 分配零值并返回指针：

1 2	p := new(int) // int，指向 0 p = 42

小结

本节覆盖了 Go 的”谭浩强习题”核心：

包/函数/入口
9 种基本类型 + 常量
算术/比较/逻辑/位运算
if/for/switch/if 简短语句
fmt 格式化输出
5 道经典课后习题
显式类型转换、指针入门

到此可以独立写控制台小程序了。下一节讲数组、切片、Map 和泛型入门。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/09/01/Go-01-基本语法与数据类型/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！