跳到主要内容

Go 基础语法

本章将介绍 Go 语言的基础语法，包括变量、数据类型和运算符。

第一个程序​

package main

import "fmt"

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

代码解释​

  • package main：声明包名，每个 Go 文件都属于一个包
  • import "fmt"：导入标准库中的 fmt 包，用于格式化 I/O
  • func main()：主函数，程序入口
  • fmt.Println()：打印内容并换行

变量​

声明变量​

// 方式一：声明变量并指定类型
var name string = "张三"
var age int = 25

// 方式二：声明变量，编译器推断类型
var name = "张三"
var age = 25

// 方式三：简短声明（只能在函数内使用）
name := "张三"
age := 25

多个变量声明​

// 多个变量
var (
    name string = "张三"
    age  int    = 25
    city string = "北京"
)

// 多个简短声明
name, age, city := "张三", 25, "北京"

常量​

// 单个常量
const Pi float64 = 3.14159

// 多个常量
const (
    StatusOK    = 200
    StatusNotFound = 404
)

// iota 枚举
const (
    Red   = iota // 0
    Green       // 1
    Blue        // 2
)

变量命名规则​

  1. 由字母、数字和下划线组成
  2. 不能以数字开头
  3. 区分大小写
  4. 不能使用 Go 关键字

数据类型​

基本类型​

整数​

// 有符号整数
var a int8   // -128 ~ 127
var b int16  // -32768 ~ 32767
var c int32  // -2147483648 ~ 2147483647
var d int64  // -9223372036854775808 ~ 9223372036854775807
var e int    // 平台相关，通常是 int64

// 无符号整数
var f uint8   // 0 ~ 255
var g uint16  // 0 ~ 65535
var h uint32  // 0 ~ 4294967295
var i uint64  // 0 ~ 18446744073709551615
var j uint    // 平台相关

// 别名
var k byte    // uint8 的别名
var l rune    // int32 的别名

浮点数​

var a float32 // 32位浮点数
var b float64 // 64位浮点数（默认）

// 声明并赋值
price := 19.99  // float64

复数​

var c1 complex64  // 32位复数
var c2 complex128 // 64位复数（默认）

c := 3 + 4i
fmt.Println(real(c), imag(c)) // 3 4

布尔值​

var isActive bool = true
var isDeleted bool = false

// 简短声明
isActive := true

字符串​

// 双引号
str1 := "Hello, Go!"

// 反引号（原始字符串）
str2 := `第一行
第二行
第三行`

// 空字符串
var str3 string = ""
str4 := ""

类型转换​

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

var a int = 10
var b float64 = float64(a)  // int 转 float64

var c float64 = 3.14
var d int = int(c)          // float64 转 int（丢失小数部分）

// 字符串和字节切片
str := "Hello"
bytes := []byte(str)
str2 := string(bytes)

零值​

变量声明但未赋值时，会被赋予零值：

var i int       // 0
var f float64   // 0
var b bool      // false
var s string    // ""
var arr [5]int  // [0 0 0 0 0]

运算符​

算术运算符​

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  - 取余

比较运算符​

a, b := 10, 3

fmt.Println(a == b) // false - 等于
fmt.Println(a != b) // true  - 不等于
fmt.Println(a > b)  // true  - 大于
fmt.Println(a < b)  // false - 小于
fmt.Println(a >= b) // true  - 大于等于
fmt.Println(a <= b) // false - 小于等于

逻辑运算符​

a, b := true, false

fmt.Println(a && b) // false - 逻辑与
fmt.Println(a || b) // true  - 逻辑或
fmt.Println(!a)     // false - 逻辑非

位运算符​

a, b := 5, 2 // 101, 010

fmt.Println(a & b)  // 0   - 按位与
fmt.Println(a | b)  // 7   - 按位或
fmt.Println(a ^ b)  // 7   - 按位异或
fmt.Println(a &^ b) // 5   - 位清除
fmt.Println(a << b) // 20  - 左移
fmt.Println(a >> b) // 1   - 右移

赋值运算符​

a := 10

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

字符串操作​

长度和访问​

str := "Hello, Go!"

// 长度
fmt.Println(len(str)) // 9

// 访问字节
fmt.Println(str[0]) // 72 (H 的 ASCII)

// 访问字符
fmt.Println(string(str[0])) // H

字符串切片​

str := "Hello, Go!"

// 切片
fmt.Println(str[0:5])   // Hello
fmt.Println(str[7:])    // Go!
fmt.Println(str[:5])    // Hello

常用函数​

import "strings"

str := "Hello, Go!"

// 大小写转换
fmt.Println(strings.ToUpper(str))   // HELLO, GO!
fmt.Println(strings.ToLower(str))   // hello, go!

// 包含判断
fmt.Println(strings.Contains(str, "Go"))   // true
fmt.Println(strings.HasPrefix(str, "Hello")) // true
fmt.Println(strings.HasSuffix(str, "Go!"))   // true

// 查找和替换
fmt.Println(strings.Index(str, "Go"))       // 7
fmt.Println(strings.Replace(str, "Go", "World", 1)) // Hello, World!

// 分割和拼接
parts := strings.Split("a,b,c", ",")     // [a b c]
fmt.Println(strings.Join(parts, "-"))    // a-b-c

字符串构建​

import "strings"

// 方式一：+
str := "Hello" + ", " + "Go!"

// 方式二：fmt.Sprintf
str := fmt.Sprintf("Hello, %s!", "Go")

// 方式三：strings.Builder（推荐，性能好）
import "strings"

var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(", ")
builder.WriteString("Go!")
fmt.Println(builder.String()) // Hello, Go!

// 方式四：bytes.Buffer
import "bytes"

var buffer bytes.Buffer
buffer.WriteString("Hello")
buffer.WriteString(", ")
buffer.WriteString("Go!")
fmt.Println(buffer.String()) // Hello, Go!

输出和输入​

fmt 包​

import "fmt"

// 打印
fmt.Print("Hello")        // 不换行
fmt.Println("Hello")      // 换行
fmt.Printf("Hello %s\n", "Go")  // 格式化打印

// 格式化占位符
name := "张三"
age := 25
fmt.Printf("姓名: %s, 年龄: %d\n", name, age)

// 输出到字符串
str := fmt.Sprint("Hello")
str = fmt.Sprintf("Hello %s", "Go")
str = fmt.Sprintln("Hello")

读取输入​

import "fmt"

var name string
fmt.Print("请输入姓名: ")
fmt.Scan(&name)
fmt.Println("你好,", name)

// 读取多个值
var name string
var age int
fmt.Scan(&name, &age)

// 读取一行
reader := bufio.NewReader(os.Stdin)
line, _ := reader.ReadString('\n')

注释​

// 单行注释

/*
  多行注释
  可以跨越多行
*/

// 文档注释（导出函数和类型使用）
// Add 返回两个整数的和
func Add(a, b int) int {
    return a + b
}

小结​

  1. 包声明：每个文件属于一个包
  2. 导入：使用 import 导入需要的包
  3. 主函数：main 包中的 main 函数是程序入口
  4. 变量声明：var 和 := 两种方式
  5. 数据类型：整数、浮点数、字符串、布尔值
  6. 类型转换：必须显式转换
  7. 运算符：算术、比较、逻辑、位运算
  8. 字符串：使用双引号或反引号

练习​

  1. 创建一个程序，声明不同类型的变量并打印
  2. 实现两个数的加减乘除运算
  3. 编写一个程序，输入你的名字并打印问候语
  4. 实现字符串的大小写转换
  5. 计算一个字符串的长度（注意中文字符）