刚学 go 的同学一定思考过 go 程序的启动过程，关于这个问题可以看饶大的文章 go 程序是怎样跑起来的。今天我们将问题缩小，来学习 go 程序是怎么加载启动参数，以及如何进行参数解析。
c 参数解析学习过 c 语言的童鞋，一定对 argc 和 argv 不会陌生。
c 程序总是从主函数 main 开始执行的，而在带参数的主函数中，依照惯例，会使用 argc 和 argv 的命名作为主函数参数。
其中，argc （argument count）代表的是命令行参数个数，argv（argument value） 是用来存放指向参数的指针数组。
#include <stdio.h>int main(int argc, char *argv[]){ printf("argc = %d\n",argc); printf("argv[0] = %s, argv[1] = %s, argv[2] = %s \n", argv[0], argv[1], argv[2]); return 0;}
编译执行以上 c 代码，得到输出如下
$ gcc c_main.c -o main$ ./main foo bar sss dddargc = 5argv[0] = ./main, argv[1] = foo, argv[2] = bar
那在 go 语言中，又该如何获取命令行参数呢？
os.args 加载同 c 一样，go 程序也是从 main 主函数开始（用户层）执行，但主函数中并没有定义 argc 和 argv。
我们可以通过 os.args 函数，获取命令行参数。
package mainimport ( "fmt" "os")func main() { for i, v := range os.args { fmt.printf("arg[%d]: %v\n", i, v) }}
编译执行 go 函数
$ go build main.go $ ./main foo bar sss dddarg[0]: ./mainarg[1]: fooarg[2]: bararg[3]: sssarg[4]: ddd
同 c 一样，第一个参数也是代表可执行文件。
加载实现下文我们需要展示一些 go 汇编代码，为了方便读者理解，先通过两图了解 go 汇编语言对 cpu 的重新抽象。
x86/amd64 架构
go 伪寄存器
go汇编为了简化汇编代码的编写，引入了 pc、fp、sp、sb 四个伪寄存器。
四个伪寄存器加上其它的通用寄存器就是 go 汇编语言对 cpu 的重新抽象。当然，该抽象的结构也适用于其它非 x86 类型的体系结构。
回到正题，命令行参数的解析过程是程序启动中的一部分内容。
以 linux amd64 系统为例，go 程序的执行入口位于runtime/rt0_linux_amd64.s。
text _rt0_amd64_linux(sb),nosplit,$-8 jmp _rt0_amd64(sb)
_rt0_amd64函数实现于 runtime/asm_amd64.s
text _rt0_amd64(sb),nosplit,$-8 movq 0(sp), di // argc leaq 8(sp), si // argv jmp runtime·rt0_go(sb)
看到 argc 和 argv 的身影了吗？在这里，它们从栈内存分别被加载到了 di、si 寄存器。
rt0_go函数完成了 runtime 的所有初始化工作，但我们这里仅关注 argc 和 argv 的处理过程。
text runtime·rt0_go(sb),nosplit|topframe,$0 // copy arguments forward on an even stack movq di, ax // argc movq si, bx // argv subq $(4*8+7), sp // 2args 2auto andq $~15, sp movq ax, 16(sp) movq bx, 24(sp) ... movl 16(sp), ax // copy argc movl ax, 0(sp) movq 24(sp), ax // copy argv movq ax, 8(sp) call runtime·args(sb) call runtime·osinit(sb) call runtime·schedinit(sb) ...
经过一系列操作之后，argc 和 argv 又被折腾回了栈内存 0(sp)和 8(sp) 中。
args 函数位于runtime/runtime1.go中
var ( argc int32 argv **byte)func args(c int32, v **byte) { argc = c argv = v sysargs(c, v)}
在这里，argc 和 argv 分别被保存至变量runtime.argc和runtime.argv。
在rt0_go函数中调用执行完args函数后，还会执行schedinit。
func schedinit() { ... goargs() ...
goargs实现于runtime/runtime1.go
var argslice []stringfunc goargs() { if goos == "windows" { return } argslice = make([]string, argc) for i := int32(0); i < argc; i++ { argslice[i] = gostringnocopy(argv_index(argv, i)) }}
该函数的目的是，将指向栈内存的命令行参数字符串指针，封装成 go 的 string类型，最终保存于runtime.argslice。
这里有个知识点，go 是如何将 c 字符串封装成 go string 类型的呢？答案就在以下代码。
func gostringnocopy(str *byte) string { ss := stringstruct{str: unsafe.pointer(str), len: findnull(str)} s := *(*string)(unsafe.pointer(&ss)) return s}func argv_index(argv **byte, i int32) *byte { return *(**byte)(add(unsafe.pointer(argv), uintptr(i)*sys.ptrsize))}func add(p unsafe.pointer, x uintptr) unsafe.pointer { return unsafe.pointer(uintptr(p) + x)}
此时，go 已经将 argc 和 argv 的信息保存至runtime.argslice中，那聪明的你一定能猜到os.args方法就是读取的该slice。
在os/proc.go中，是它的实现
var args []stringfunc init() { if runtime.goos == "windows" { // initialized in exec_windows.go. return } args = runtime_args()}func runtime_args() []string // in package runtime
而runtime_args方法的实现是位于 runtime/runtime.go中的os_runtime_args函数
//go:linkname os_runtime_args os.runtime_argsfunc os_runtime_args() []string { return append([]string{}, argslice...) }
在这里实现了runtime.argslice的拷贝。至此，os.args方法最终成功加载了命令行参数 argv 信息。
总结本文我们介绍了 go 可以利用os.args解析程序启动时的命令行参数，并学习了它的实现过程。
在加载实现的源码学习中，我们发现如果从一个点出发，去追溯它的实现原理，这个过程并不复杂，希望童鞋们不要惧怕研究源码。
os.args方法将命令行参数存储在字符串切片中，通过遍历即可提取它们。但在实际开发中我们一般不会直接使用os.args方法，因为 go 为我们提供了一个更好用的 flag 包。但鉴于篇幅原因，该部分的内容以后再写了。
以上就是go 如何实现启动参数的加载的详细内容。