第一章：Go语言开发环境搭建与基础语法概览
安装Go运行时与配置环境变量
前往官方站点 https://go.dev/dl/ 下载对应操作系统的安装包（如 macOS 的 go1.22.4.darwin-arm64.pkg 或 Linux 的 go1.22.4.linux-amd64.tar.gz）。Linux 用户可执行以下命令完成解压与路径配置：
# 解压至 /usr/local
sudo tar -C /usr/local -xzf go*.tar.gz
# 将 /usr/local/go/bin 加入 PATH（写入 ~/.zshrc 或 ~/.bashrc）
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.zshrc
source ~/.zshrc验证安装：运行 go version 应输出类似 go version go1.22.4 darwin/arm64。
初始化首个Go模块
创建项目目录并初始化模块（Go 1.16+ 默认启用 module）：
mkdir hello-go && cd hello-go
go mod init hello-go # 生成 go.mod 文件，声明模块路径此时 go.mod 内容为：
module hello-go
go 1.22基础语法核心要素
Go 是静态类型、编译型语言，强调简洁与显式性。关键特性包括：
- 包声明：每个
.go文件首行必须是package main（可执行程序）或package xxx（库）； - 导入方式：使用
import声明依赖，支持分组与点号别名（谨慎使用）； - 变量声明：支持
var name type、短变量声明name := value（仅函数内），且未使用的变量会导致编译失败； - 函数定义：形参与返回值类型均置于右侧，支持多返回值（常见于错误处理）；
示例 main.go：
package main
import "fmt" // 标准库 fmt 提供格式化 I/O
func main() {
name := "Go" // 短变量声明
fmt.Printf("Hello, %s!\n", name) // 输出：Hello, Go!
}执行 go run main.go 即可运行。Go 工具链自动解析依赖、编译并执行，无需手动管理构建文件。
常用开发工具推荐
| 工具 | 用途说明 |
|---|---|
go fmt |
自动格式化代码（遵循官方风格） |
go vet |
静态检查潜在错误（如未使用的变量） |
gopls |
语言服务器，支持 VS Code/Neovim 的智能提示与跳转 |
delve |
调试器，支持断点、变量查看与步进执行 |
第二章：Go核心语法深度解析与官方规范对照
2.1 变量声明与类型推断：课件简化写法 vs 官方文档显式约束
简化写法的常见实践
课件中常采用 let x = 42 或 const users = []，依赖 TypeScript 的上下文类型推断：
let count = 100; // 推断为 number
const isActive = true; // 推断为 boolean
const names = ["Alice", "Bob"]; // 推断为 string[]✅ 逻辑分析：编译器基于初始值字面量自动推导最窄类型（如 "Alice" → string，而非 any）；参数 count 无显式注解，但后续赋值 count = "hello" 将触发类型错误。
显式约束的健壮性保障
官方文档强调接口契约优先：
| 场景 | 简化写法 | 显式约束写法 |
|---|---|---|
| 数组 | let list = [] |
let list: string[] = [] |
| 对象结构 | const conf = { port: 3000 } |
const conf: { port: number; host?: string } = { port: 3000 } |
类型收敛路径
graph TD
A[字面量初始化] --> B[基础类型推断]
B --> C[上下文类型传播]
C --> D[隐式联合/字面量类型]
D --> E[显式注解覆盖或加固]显式约束在大型协作项目中避免推断偏差，尤其对可选属性、联合类型及泛型参数至关重要。
2.2 函数与方法签名：接收者语义差异与Go 1.22 method set更新适配
接收者类型决定方法集归属
Go 中，值接收者和指针接收者定义的方法不属于同一方法集：
T的方法集仅包含func (T) M()；*T的方法集包含func (T) M()和func (*T) M()。
Go 1.22 关键变更：嵌入接口方法集收敛
Go 1.22 调整了嵌入接口（embedded interface）的方法集计算规则，使 interface{ io.Reader } 现在隐式包含 io.Reader 的全部方法（含指针接收者定义的 Read()），不再要求显式实现。
type Reader interface {
io.Reader // Go 1.22+：此嵌入 now grants full io.Reader method set
}逻辑分析：此前需手动实现
Read([]byte) (int, error)；1.22 后，只要底层类型满足io.Reader方法集（无论func (T) Read(...)或func (*T) Read(...)），即自动满足Reader接口。参数说明：io.Reader是标准接口，其Read方法接收者为*T或T均可——但方法集归属仍受原始定义约束。
适配建议清单
- 检查所有嵌入接口声明，移除冗余方法重声明；
- 对泛型约束中使用嵌入接口的代码，验证类型推导是否因方法集扩大而更宽松；
- 运行
go vet -vettool=...检测潜在方法集误用。
| 场景 | Go ≤1.21 行为 | Go 1.22 行为 |
|---|---|---|
var r Reader = &MyStruct{} |
需 *MyStruct 实现 Read |
MyStruct 或 *MyStruct 实现均满足 |
graph TD
A[定义接口嵌入] --> B{Go版本 ≥1.22?}
B -->|是| C[自动继承嵌入接口完整方法集]
B -->|否| D[仅继承值接收者方法，指针方法需显式实现]2.3 接口实现机制：隐式实现的边界条件与课件案例中的常见误用
隐式接口实现要求类型完全匹配签名，包括返回类型、参数名（C# 12+）、可空性注解及泛型约束。课件中常误将 IComparable<T> 隐式实现为 int CompareTo(object)，导致运行时 InvalidCastException。
常见误用场景
- 忽略
ref readonly修饰符一致性 - 在
record struct中遗漏IEquatable<T>.Equals(T)的显式声明 - 将
IAsyncEnumerable<T>的GetAsyncEnumerator()返回Task<AsyncEnumerator<T>>而非ValueTask<AsyncEnumerator<T>>
正确实现示例
public readonly partial struct Point : IComparable<Point>
{
public int X, Y;
// ✅ 隐式实现：签名严格匹配 IComparable<Point>.CompareTo(Point)
public int CompareTo(Point other) => X == other.X ? Y.CompareTo(other.Y) : X.CompareTo(other.X);
}逻辑分析：
CompareTo(Point)方法必须接受Point（而非object），否则不满足IComparable<Point>的隐式契约；参数名other与接口定义一致，确保编译器能正确绑定。
| 错误模式 | 编译结果 | 运行时行为 |
|---|---|---|
int CompareTo(object o) |
✅ 通过（但未实现接口） | ❌ is IComparable<Point> 返回 false |
int CompareTo(Point? p) |
❌ 编译失败（可空性不匹配） | — |
graph TD
A[类型声明] --> B{是否含 public non-virtual 方法？}
B -->|是| C[检查签名完全匹配]
B -->|否| D[视为未实现]
C --> E[参数类型/数量/顺序/可空性/约束]
E --> F[全部一致 → 隐式绑定]
E --> G[任一不符 → 绑定失败]2.4 错误处理范式：error wrapping在课件中的实践模式 vs 官方推荐的%w标准用法
课件中常见的非标准包装方式
许多教学课件为简化理解，采用 fmt.Errorf("failed to parse: %v", err) 直接拼接错误字符串：
func parseConfig(path string) error {
data, err := os.ReadFile(path)
if err != nil {
return fmt.Errorf("parseConfig: read file %s failed: %v", path, err) // ❌ 丢失原始类型与堆栈
}
// ...
}该写法破坏了 errors.Is/errors.As 的可判定性，且无法通过 errors.Unwrap() 提取底层错误。
官方 %w 的语义契约
使用 %w 标志符显式声明包装关系，保留错误链完整性：
func parseConfig(path string) error {
data, err := os.ReadFile(path)
if err != nil {
return fmt.Errorf("parseConfig: read file %s failed: %w", path, err) // ✅ 可展开、可匹配
}
// ...
}%w 参数必须是 error 类型，运行时自动调用 Unwrap() 方法，使错误具备可追溯性与结构化诊断能力。
关键差异对比
| 维度 | %v（课件常见） |
%w（官方标准） |
|---|---|---|
| 类型保留 | 否 | 是 |
errors.Is |
不支持 | 支持 |
| 堆栈可追溯性 | 丢失 | 保留（依赖底层实现） |
graph TD
A[原始 error] -->|fmt.Errorf with %w| B[包装 error]
B -->|errors.Unwrap| A
B -->|errors.Is| C[特定错误类型]2.5 并发原语对比：channel缓冲策略与Go 1.22 runtime/trace增强特性联动分析
数据同步机制
Go 中 channel 的缓冲策略直接影响调度行为与 trace 可观测性。无缓冲 channel 触发 goroutine 阻塞与唤醒的精确配对，而带缓冲 channel（如 make(chan int, 8)）延迟同步点，模糊生产者-消费者时序边界。
trace 观测粒度升级
Go 1.22 扩展 runtime/trace，新增 chan send/recv 事件元数据，包含缓冲区剩余容量、goroutine 等待队列长度等字段：
ch := make(chan string, 3)
go func() { ch <- "a" }() // trace 记录：cap=3, len=1, waitq=0
<-ch // 触发 recv 事件，含缓冲水位变化 delta逻辑分析：
ch <- "a"在 trace 中标记为GoCreate+ChanSend复合事件；cap和len字段由运行时原子读取，无需额外锁开销；等待队列长度揭示潜在调度争用。
缓冲策略与 trace 联动效果对比
| 缓冲类型 | trace 中同步事件密度 | goroutine 阻塞可见性 | 典型适用场景 |
|---|---|---|---|
| 无缓冲 | 高（每次收发均记录） | 强（精确阻塞点） | RPC 响应配对、信号通知 |
| 缓冲大小=1 | 中（部分非阻塞） | 中（仅满/空时阻塞） | 简单解耦生产消费 |
| 缓冲大小>1 | 低（批量缓冲掩盖） | 弱（阻塞被延迟隐藏） | 流式日志暂存、背压缓解 |
性能权衡路径
graph TD
A[选择缓冲策略] --> B{是否需 trace 精确诊断？}
B -->|是| C[优先无缓冲或小缓冲]
B -->|否| D[按吞吐需求选大缓冲]
C --> E[利用 Go 1.22 新增 chan.len 字段做实时水位告警]第三章：Go模块化与工程化实践差异剖析
3.1 Go Modules版本控制：课件中go.mod精简写法与官方语义化版本严格校验差异
Go Modules 要求版本号严格遵循 Semantic Versioning 2.0.0，但课件常简化为 v1 或 v2，而 go mod tidy 实际校验时会拒绝非法格式。
精简写法 vs 官方校验
- ✅ 合法：
v1.15.0,v2.3.1+incompatible - ❌ 课件常见非法写法：
v1,v2.0,latest
go.mod 片段对比
// 课件常见（不推荐）：
require github.com/example/lib v2 // 缺少主版本号后缀，go build 失败
// 正确写法（带主版本路径）：
require github.com/example/lib/v2 v2.3.1
v2单独出现时，Go 工具链无法解析模块路径——必须显式声明/v2子路径，否则触发invalid version: malformed semver错误。
| 写法 | 是否通过 go list -m -f '{{.Version}}' |
原因 |
|---|---|---|
v1.2.0 |
✅ | 符合 semver 格式 |
v2 |
❌ | 缺少次版本与修订号，非标准语义化版本 |
graph TD
A[go get github.com/example/lib/v2] --> B[解析 module path]
B --> C{是否含 /v2 后缀？}
C -->|否| D[报错：no matching versions]
C -->|是| E[匹配 v2.x.y tag]3.2 包导入路径规范：相对路径陷阱与Go 1.22 workspace mode兼容性说明
相对路径为何失效？
Go 工具链（包括 go build 和 go list）始终以模块根目录为绝对基准解析导入路径，不支持 ./ 或 ../ 开头的相对导入。以下写法是非法的：
// ❌ 编译失败：invalid import path
import "./utils" // 错误：非标准导入路径
import "../shared" // 错误：越界且无模块声明Go 规范要求所有导入路径必须是完整、可解析的模块路径（如
github.com/myorg/project/utils），工具链不会执行文件系统相对路径解析——这是设计使然，而非 bug。
Go 1.22 workspace mode 的新约束
启用 go work init 后，workspace 中各模块仍需各自声明 go.mod，且跨模块导入必须使用其正式模块路径，不能依赖 workspace 目录结构“隐式可见”。
| 场景 | 是否允许 | 原因 |
|---|---|---|
replace github.com/a => ./a（本地路径） |
✅ | replace 是显式重映射，合法 |
import "a"（未声明 module 名） |
❌ | 缺失 module a 声明，无法解析 |
import "github.com/a/utils"（实际路径匹配） |
✅ | 符合模块路径语义 |
兼容性关键点
- Workspace 不改变导入路径解析逻辑，仅扩展多模块协同开发能力；
- 所有
import语句仍须指向有效模块路径，且该路径必须在对应go.mod中注册或通过replace显式绑定。
graph TD
A[go build] --> B{解析 import path}
B --> C[是否为合法模块路径？]
C -->|否| D[报错：invalid import path]
C -->|是| E[查找 go.mod 中 module 声明或 replace 规则]
E --> F[定位代码位置]3.3 测试驱动开发：课件中testing.T使用模式与官方test coverage工具链集成要点
testing.T 的核心使用模式
*testing.T 不仅是测试上下文载体，更是控制流枢纽：
t.Fatal()终止当前测试函数，不执行后续断言；t.Log()输出非失败日志（仅-v时可见）；t.Run()支持子测试命名与并行控制。
func TestParseURL(t *testing.T) {
tests := []struct {
name, input string
wantErr bool
}{
{"valid", "https://example.com", false},
{"invalid", "htp://", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := url.Parse(tt.input)
if (err != nil) != tt.wantErr {
t.Errorf("ParseURL(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
}
})
}
}该模式实现用例隔离与错误定位精准化：t.Run 创建独立作用域，避免变量污染；t.Errorf 自动携带文件/行号，无需手动拼接位置信息。
coverage 工具链集成关键点
| 工具 | 作用 | 必要参数 |
|---|---|---|
go test -cover |
生成覆盖率数值（%） | -coverprofile=coverage.out |
go tool cover |
可视化报告生成（HTML/func-level） | -html=coverage.out |
graph TD
A[go test -coverprofile=c.out] --> B[go tool cover -func=c.out]
B --> C[go tool cover -html=c.out]启用 -race 与 -covermode=count 可同时捕获竞态与精确行覆盖数据。
第四章：Go运行时与性能调优实战对照
4.1 GC行为观测：课件pprof采样方式 vs Go 1.22 new runtime/metrics API迁移指南
Go 1.22 引入 runtime/metrics API，以无侵入、低开销方式替代传统 pprof GC 采样，显著提升可观测性精度与时效性。
采样机制对比
| 维度 | pprof（如 /debug/pprof/gc） |
runtime/metrics（/gc/heap/allocs:bytes） |
|---|---|---|
| 数据来源 | 周期性堆快照（采样触发） | 运行时原子计数器实时更新 |
| 开销 | 高（STW 影响、内存拷贝） | 极低（仅读取 uint64） |
| 时间分辨率 | 秒级（依赖 HTTP 请求时机） | 纳秒级（可每毫秒轮询） |
迁移示例代码
// Go 1.22+ 推荐方式：metrics API
import "runtime/metrics"
func observeGC() {
m := metrics.Read([]metrics.Sample{
{Name: "/gc/heap/allocs:bytes"},
{Name: "/gc/heap/allocs:objects"},
})
fmt.Printf("Allocated bytes: %d\n", m[0].Value.(uint64))
}逻辑分析：
metrics.Read()直接读取运行时内置指标，无需 HTTP handler 或 goroutine 协程调度；/gc/heap/allocs:bytes表示自程序启动以来的总分配字节数，类型为uint64，避免了pprof中需解析 profile 文件的序列化开销。
迁移路径示意
graph TD
A[旧模式：pprof.StartCPUProfile] --> B[HTTP 触发 /debug/pprof/gc]
B --> C[生成 pprof 格式堆快照]
C --> D[解析 Profile → 提取 GC 次数/暂停时间]
E[新模式：runtime/metrics] --> F[轮询 metrics.Read]
F --> G[直接获取 /gc/heap/pauses:seconds]4.2 内存逃逸分析：课件中go tool compile -m输出解读与官方文档新增逃逸分类说明
Go 1.30 起，go tool compile -m 新增 escape=reason 分类标签，明确区分逃逸动因：
heap：必须分配在堆上（如返回局部指针）closure：被闭包捕获的变量interface：类型擦除导致动态调度需堆分配global：全局变量引用导致生命周期延长
$ go build -gcflags="-m=2" main.go
# main
./main.go:5:6: moved to heap: x # 原始提示
./main.go:5:6: x escapes to heap via interface{}(x) (escape=interface) # 新格式新输出直接标注逃逸分类，替代模糊的“moved to heap”。
| 分类 | 触发条件 | 示例场景 |
|---|---|---|
interface |
类型断言/赋值给空接口 | any(x) 或 fmt.Println(x) |
closure |
变量被匿名函数捕获且函数逃逸 | func() { return &x }() |
func New() *int {
x := 42
return &x // escape=heap: returned pointer
}该函数中 x 逃逸至堆，因返回其地址，生命周期超出栈帧。-m=2 输出会追加 (escape=heap) 标签，精准定位根源。
4.3 Goroutine调度器演进：课件P、M、G模型图示与Go 1.22 preemption优化实测对比
Go调度器从早期的GM模型演进为P（Processor）、M（OS Thread）、G（Goroutine）三层协作架构，P作为调度上下文绑定本地运行队列，M执行G，G在P间迁移实现负载均衡。
P、M、G核心关系
- P数量默认等于
GOMAXPROCS，可动态调整 - 每个M必须绑定一个P才能执行G
- G在
_Grunnable状态时排队于P的本地队列或全局队列
// runtime/schedule.go（简化示意）
func schedule() {
gp := getg() // 当前G
mp := getm() // 当前M
pp := mp.p.ptr() // 关联的P
// 尝试从本地队列偷取G
if gp := runqpop(pp); gp != nil {
execute(gp, false)
}
}该函数体现P本地队列优先调度策略；runqpop原子读取pp.runq头节点，避免锁竞争，execute将G切换至M栈执行。
Go 1.22抢占式调度增强
| 版本 | 抢占触发点 | 平均延迟（μs） | 长循环敏感度 |
|---|---|---|---|
| 1.21 | 仅在系统调用/通道操作处 | ~150 | 高 |
| 1.22 | 新增定时器驱动软抢占点 | ~22 | 显著降低 |
graph TD
A[Go 1.22 M] -->|每10ms检查| B[是否需抢占]
B -->|yes| C[插入preemptMark]
C --> D[下一次函数调用入口检查]
D --> E[安全点触发G切换]实测显示：含for{}空循环的G在1.22中平均被抢占延迟下降85%，提升公平性与响应性。
4.4 unsafe包安全边界：课件中Pointer转换案例与官方文档新增unsafe.Sizeof对齐要求解析
Pointer转换的典型陷阱
以下课件中常见但危险的转换模式：
type Header struct {
Len int
Data []byte
}
func badConvert(p *int) []byte {
return *(*[]byte)(unsafe.Pointer(&p)) // ❌ 非法：未验证内存布局与对齐
}逻辑分析：&p 是 **int 类型地址，强制转为 *[]byte 指针后解引用，绕过类型系统；但 int 和 []byte 的底层结构（header size、字段偏移）不兼容，且未校验 unsafe.Alignof(p) 是否满足 []byte 的 8 字节对齐要求。
官方文档新增约束
Go 1.22+ 明确要求：
unsafe.Sizeof(x)返回值必须与unsafe.Alignof(x)整除，否则unsafe.Pointer转换视为未定义行为- 所有
reflect.SliceHeader/StringHeader使用前需显式校验对齐
| 类型 | Sizeof (bytes) | Alignof (bytes) | 是否可安全用于 Pointer 转换 |
|---|---|---|---|
int64 |
8 | 8 | ✅ |
struct{byte;int64} |
16 | 8 | ✅（填充后对齐） |
struct{byte;int32} |
8 | 4 | ❌（Sizeof % Alignof ≠ 0） |
对齐校验流程
graph TD
A[获取变量地址] --> B{Alignof == Sizeof % Alignof ?}
B -->|否| C[拒绝转换，panic]
B -->|是| D[执行 Pointer 转换]
D --> E[验证 header 字段偏移一致性]第五章：课程总结与Go生态演进趋势展望
Go语言在云原生基础设施中的深度落地案例
2023年，某头部金融云平台将核心API网关从Java迁移至Go，QPS提升3.2倍，内存占用下降67%。关键改造包括：使用net/http定制中间件链替代Spring Cloud Gateway的Filter机制；通过sync.Pool复用HTTP header map和request context对象；采用golang.org/x/net/http2启用HPACK压缩与服务端推送。迁移后，单节点可稳定承载12万并发连接，GC停顿时间从平均45ms降至≤1.8ms（P99）。
主流开源项目对Go 1.22+特性的采纳现状
| 项目名称 | Go版本升级进度 | 关键特性应用实例 |
|---|---|---|
| Kubernetes 1.30 | 已切换至1.22 | 使用range over func() iter.Seq[any]重构资源遍历逻辑 |
| TiDB 8.1 | 采用1.23 beta | 利用go:build多平台条件编译分离ARM64优化路径 |
| Grafana Backend | v10.3.0起支持 | 基于embed.FS打包静态资源，镜像体积减少210MB |
eBPF与Go协同开发的新范式
Cilium团队在v1.15中引入cilium-go/bpf库，允许Go代码直接生成BPF字节码：
prog := bpf.NewProgram(&bpf.ProgramSpec{
Type: bpf.SchedCLS,
License: "Apache-2.0",
Instructions: asm.Instructions{
asm.LoadAbsolute{Off: 0, Size: 4},
asm.JumpIf{Op: asm.JNE, Val: 0x0800, Skip: 2},
asm.LoadMemShift{Off: 12}, // 提取以太网协议类型
asm.Exit{},
},
})该方案使网络策略编译耗时从秒级降至毫秒级，且避免了C语言交叉编译依赖。
Go模块代理生态的可靠性演进
2024年Q1，国内三大公有云厂商联合推出Go Proxy联邦网络：
- 阿里云
proxy.aliyun.com提供goproxy.io镜像+私有模块缓存 - 腾讯云
goproxy.tencent.com集成SCM权限校验，支持.gitignore规则同步 - 华为云
goproxy.huawei.com实现模块签名验证（RFC 9117），拦截篡改包127次/日
WASM运行时在Go生态的突破性实践
TinyGo 0.30正式支持WebAssembly System Interface（WASI）标准，某IoT边缘计算平台基于此构建设备固件OTA验证器：
- 将Go写的SHA-256校验逻辑编译为WASM模块（仅12KB）
- 在Rust编写的核心调度器中通过
wasi_snapshot_preview1调用 - 实现固件签名验证延迟
生产环境Go内存逃逸分析实战
某电商订单服务在压测中发现goroutine堆积，通过go tool compile -gcflags="-m -l"定位到以下逃逸点：
func buildOrder(ctx context.Context, items []Item) *Order {
return &Order{ // 此处逃逸至堆：items被闭包捕获
CreatedAt: time.Now(),
Items: items, // slice底层数组未逃逸，但指针引用导致整体逃逸
}
}解决方案：改用unsafe.Slice预分配固定长度数组，并通过runtime.KeepAlive(items)阻止过早回收。
Go泛型在微服务治理框架中的规模化应用
Kratos v2.7重构服务注册模块，利用constraints.Ordered约束实现多维度健康检查排序：
type HealthChecker[T constraints.Ordered] struct {
threshold T
metrics map[string]T
}
func (h *HealthChecker[int]) SortByScore() []string { /* ... */ }该设计使CPU、内存、磁盘三类指标可复用同一排序逻辑，代码行数减少38%，且编译期保证类型安全。
持续交付流水线中的Go构建优化矩阵
| 优化项 | 传统方式耗时 | 优化后耗时 | 技术要点 |
|---|---|---|---|
| vendor依赖拉取 | 42s | 9s | GOSUMDB=off + 私有module proxy |
| 单元测试执行 | 186s | 47s | GOTESTFLAGS="-p=8" + test cache |
| Docker镜像构建 | 310s | 124s | 多阶段构建 + CGO_ENABLED=0静态链接 |
Go错误处理模式的工程化演进
Docker Engine 24.0采用errors.Join重构守护进程启动流程，将17个独立组件的启动错误聚合为结构化错误树：
graph TD
A[daemon.Start] --> B[containerd.Connect]
A --> C[libnetwork.Init]
A --> D[plugin.Manager.Load]
B -->|error| E["rpc error: code = Unavailable"]
C -->|error| F["failed to initialize bridge network"]
D -->|error| G["plugin 'volume' load timeout"]
A --> H[errors.Join(E,F,G)]