编辑“︁Go 复合字面值”︁

{{Note|本文适用于Go语言初学者及需要了解复合字面值概念的程序员。}}

= Go复合字面值 =
'''复合字面值'''（Composite Literal）是Go语言中用于构造结构体（struct）、数组（array）、切片（slice）和映射（map）等复合类型的简洁语法形式。它允许开发者在单行代码中完成复杂数据结构的初始化，是Go语言类型安全与表达力平衡的典型体现。

== 基本语法 ==
复合字面值由三部分组成：
# 类型标识（如<code>[]int</code>、<code>map[string]bool</code>）
# 花括号<code>{}</code>包裹的初始化元素
# 可选的字段名（对结构体特别有用）

通用格式：
<syntaxhighlight lang="go">
Type{ InitializationElements }
</syntaxhighlight>

== 类型详解 ==
=== 数组/切片初始化 ===
<syntaxhighlight lang="go">
// 数组
primes := [5]int{2, 3, 5, 7, 11}

// 切片（动态数组）
names := []string{"Alice", "Bob", "Charlie"}

// 部分初始化（剩余元素为零值）
scores := [10]int{95, 87} // [95 87 0 0 0 0 0 0 0 0]
</syntaxhighlight>

=== 映射初始化 ===
<syntaxhighlight lang="go">
// 键值对形式
config := map[string]interface{}{
    "debug":    true,
    "logLevel": "warn",
    "retries":  3,
}

// 空映射
emptyMap := map[int]string{}
</syntaxhighlight>

=== 结构体初始化 ===
<syntaxhighlight lang="go">
type Point struct {
    X, Y int
    Label string
}

// 顺序初始化
p1 := Point{10, 20, "Origin"}

// 字段名显式指定（顺序无关）
p2 := Point{
    Label: "Center",
    X:     50,
    Y:     50,
}
</syntaxhighlight>

== 高级特性 ==
=== 动态索引初始化 ===
可在数组/切片初始化时指定特定索引的值：
<syntaxhighlight lang="go">
// 索引5处值为100，其余为0
arr := [...]int{5: 100} // [0 0 0 0 0 100]

// 混合初始化
matrix := [][]int{
    {1, 2, 3},
    5: {7, 8, 9}, // 第5行初始化
}
</syntaxhighlight>

=== 类型推导 ===
Go编译器能根据上下文推断复合字面值的类型：
<syntaxhighlight lang="go">
// 切片类型从[]float64{...}推导
vector := []float64{1.1, 2.2, 3.3}

// 结构体指针
ptr := &Point{X: 10, Y: 20} // 等价于new(Point)后赋值
</syntaxhighlight>

=== 嵌套结构 ===
复合字面值支持任意深度的嵌套：
<syntaxhighlight lang="go">
type Address struct {
    City, Country string
}

type User struct {
    Name    string
    Age     int
    Address Address
}

user := User{
    Name: "John",
    Age:  30,
    Address: Address{
        City:    "London",
        Country: "UK",
    },
}
</syntaxhighlight>

== 内存模型 ==
<mermaid>
graph TD
    A[复合字面值] --> B[栈分配]
    A --> C[堆分配]
    B -->|值类型| D[数组/结构体]
    C -->|引用类型| E[切片/映射]
    C -->|指针| F[&结构体]
</mermaid>

== 性能考量 ==
* '''值类型'''（数组/结构体）：直接在声明位置分配内存
* '''引用类型'''（切片/映射）：运行时调用<code>runtime.makemap</code>或<code>runtime.makeslice</code>
* 编译器会对逃逸分析优化内存分配位置

== 实际应用案例 ==
=== 配置加载 ===
<syntaxhighlight lang="go">
type ServerConfig struct {
    Host      string
    Port      int
    Timeout   time.Duration
    Whitelist []string
}

// 硬编码配置示例
config := ServerConfig{
    Host:    "api.example.com",
    Port:    443,
    Timeout: 30 * time.Second,
    Whitelist: []string{
        "192.168.1.1",
        "10.0.0.0/8",
    },
}
</syntaxhighlight>

=== JSON编码 ===
复合字面值与JSON格式天然对应：
<syntaxhighlight lang="go">
data := map[string]interface{}{
    "status":  "success",
    "code":    200,
    "payload": []string{"item1", "item2"},
}

jsonData, _ := json.Marshal(data)
// 输出: {"code":200,"payload":["item1","item2"],"status":"success"}
</syntaxhighlight>

== 常见错误 ==
{| class="wikitable"
! 错误示例 !! 正确形式 !! 说明
|-
| <code>Point{X:1, Y:2,}</code> || <code>Point{X:1, Y:2}</code> || 结尾多余逗号（Go 1.13+允许）
|-
| <code>[]int{1, 2, 3.0}</code> || <code>[]int{1, 2, 3}</code> || 类型不匹配
|-
| <code>map[int]string{1:"one", "two":2}</code> || <code>map[int]string{1:"one", 2:"two"}</code> || 键值类型错误
|}

== 最佳实践 ==
# 对复杂结构体始终使用字段名初始化
# 超过3个元素的初始化换行显示
# 公共API暴露的类型应提供文档化示例
# 优先使用切片而非数组（除非明确需要固定大小）

{{Tip|使用<code>go vet</code>可以检测复合字面值中的类型不匹配问题。}}

== 数学表示 ==
对于结构体初始化，可以形式化表示为：
<math>
S = \{ f_1:v_1, f_2:v_2, ..., f_n:v_n \}
</math>
其中<math>f_i</math>表示字段名，<math>v_i</math>表示对应值。

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 数据结构]]