代码即数据

几个小伙伴在考虑下面这个各个语言都会遇到的问题：

问题：设计一个命令行参数解析API

一个好的命令行参数解析库一般涉及到这几个常见的方面：

1) 支持方便地生成帮助信息

2) 支持子命令，比如：git包含了push, pull, commit等多种子命令

3) 支持单字符选项、多字符选项、标志选项、参数选项等多种选项和位置参数

4) 支持选项默认值，比如：—port选项若未指定认为5037

5) 支持使用模式，比如：tar命令的-c和-x是互斥选项，属于不同的使用模式

经过一番考察，小伙伴们发现了这个几个有代表性的API设计：

1. getopt()：

getopt()是libc的标准函数，很多语言中都能找到它的移植版本。

1. //C
2. while ((c = getopt(argc, argv, "ac:d:")) != -1) {
3. int this_option_optind = optind ? optind : 1;
4. switch (c) {
5. case 'a':
6. printf ("option a");
7. aopt = 1;
8. break;
9. case 'c':
10. printf ("option c with value '%s'", optarg);
11. copt = optarg;
12. break;
13. case 'd':
14. printf ("option d with value '%s'", optarg);
15. dopt = optarg;
16. break;
17. case '?':
18. break;
19. default:
20. printf ("?? getopt returned character code 0%o ??", c);
21. }
22. }

getopt()的核心是一个类似printf的格式字符串的命令行参数描述串，如上面的”ac”定义了”a”, “c”，”d”3个命令行参数，其中，a是一个标志符不需要参数，”c”和”d”需要跟参数。getopt()功能非常弱，只支持单个字符的标志选项和参数选项。如果按上面的5点来比对，基本上只能说是勉强支持第3点，其他几项只能靠程序自己来实现了，所以，想直接基于getopt()实现一个像git这样复杂的命令行参数是不可能的，只有自己来做很多的解析工作。小伙伴们看过getopt()之后一致的评价是:图样图森破。

2. Google gflags

接着，小伙伴们又发现了gflags这个Google出品C++命令行参数解析库。

1. //C++
2. DEFINE_bool(memory_pool, false, "If use memory pool");
3. DEFINE_bool(daemon, true, "If started as daemon");
4. DEFINE_string(module_id, "", "Server module id");
5. DEFINE_int32(http_port, 80, "HTTP listen port");
6. DEFINE_int32(https_port, 443, "HTTPS listen port");
8. int main(int argc, char** argv) {
9. ::google::ParseCommandLineFlags(&argc, &argv, true);
11. printf("Server module id: %s", FLAGS_module_id.c_str());
13. if (FLAGS_daemon) {
14. printf("Run as daemon: %d", FLAGS_daemon);
15. }
16. if (FLAGS_memory_pool) {
17. printf("Use memory pool: %d", FLAGS_daemon);
18. }
20. Server server;
22. return 0;
23. }

小伙伴们看了后不由得感叹“真心好用啊”！的确，gflags简单地通过几个宏就定义了命令行选项，基本上很好的支持了上面提到的1，3，4这几项，比起getopt()来强多了。对于类似cp这样的小命令，gflags应该是够用了，但要达到git这种级别就显得有些单薄了。

3. Ruby Commander

接下来小伙伴们又发现了Ruby Commander库：

1. //Ruby
2. # :name is optional, otherwise uses the basename of this executable
3. program :name, 'Foo Bar'
4. program :version, '1.0.0'
5. program :description, 'Stupid command that prints foo or bar.'
6. command :bar do |c|
7. c.syntax = 'foobar bar [options]'
8. c.description = 'Display bar with optional prefix and suffix'
9. c.option '--prefix STRING', String, 'Adds a prefix to bar'
10. c.option '--suffix STRING', String, 'Adds a suffix to bar'
11. c.action do |args, options|
12. options.default :prefix => '(', :suffix => ')'
13. say "#{options.prefix}bar#{options.suffix}"
14. end
15. end
16. $ foobar bar
17. # => (bar)
18. $ foobar bar --suffix '}' --prefix '{'
19. # => {bar}

Commander库利用Ruby酷炫的语法定义了一种描述命令行参数的内部DSL，看起来相当高端大气上档次。除了上面的第5项之外，其他几项都有很好的支持，可以说Commander库的设计基本达到了git这种级别命令行参数解析的要求。只是，要搞懂Ruby这么炫的语法和这个库的使用方法恐怕就不如getopt()和gflags容易了。有小伙伴当场表示想要学习Ruby，但是也有小伙伴表示再看看其他库再说。

4. Lisp cmdline库

接下来，小伙伴们发现了Lisp方言Racket的cmdline库。

1. //Lisp
2. (parse-command-line "compile" (current-command-line-arguments)
3. `((once-each
4. [("-v" "--verbose")
5. ,(lambda (flag) (verbose-mode #t))
6. ("Compile with verbose messages")]
7. [("-p" "--profile")
8. ,(lambda (flag) (profiling-on #t))
9. ("Compile with profiling")])
10. (once-any
11. [("-o" "--optimize-1")
12. ,(lambda (flag) (optimize-level 1))
13. ("Compile with optimization level 1")]
14. [("--optimize-2")
15. ,(lambda (flag) (optimize-level 2))
16. (("Compile with optimization level 2,"
17. "which implies all optimizations of level 1"))])
18. (multi
19. [("-l" "--link-flags")
20. ,(lambda (flag lf) (link-flags (cons lf (link-flags))))
21. ("Add a flag <lf> for the linker" "lf")]))
22. (lambda (flag-accum file) file)
23. '("filename"))

这是神马浮云啊?括号套括号，看起来很厉害的样子，但又不是很明白。看到这样的设计，有的小伙伴连评价都懒得评价了，但也有的小伙伴对Lisp越发崇拜，表示Lisp就是所谓的终极语言了，没有哪门语言能写出这么不明觉历的代码来！小伙伴们正准备打完收工，突然…

5. Node.js的LineParser库

发现了Node.js的LineParser库:

1. var meta = {
2. program : 'adb',
3. name : 'Android Debug Bridge',
4. version : '1.0.3',
5. subcommands : [ 'connect', 'disconnect', 'install' ],
6. options : {
7. flags : [
8. [ 'h', 'help', 'print program usage' ],
9. [ 'r', 'reinstall', 'reinstall package' ],
10. [ 'l', 'localhost', 'localhost' ]
11. ],
12. parameters : [
13. [ null, 'host', 'adb server hostname or IP address', null ],
14. [ 'p', 'port', 'adb server port', 5037 ]
15. ]
16. },
17. usages : [
18. [ 'connect', ['host', '[port]'], null, 'connect to adb server', adb_connect ],
19. [ 'connect', [ 'l' ], null, 'connect to the local adb server', adb_connect ],
20. [ 'disconnect', null, null, 'disconnect from adb server', adb_disconnect ],
21. [ 'install', ['r'], ['package'], 'install package', adb_install ],
22. [ null, ['h'], null, 'help', adb_help ],
23. ]
24. };
26. try {
27. var lineparser = require('lineparser');
28. var parser = lineparser.init(meta);
29. parser.parse(['install', '-r', '/pkgs/bird.apk']); // adb_install will be invoked
30. }
31. catch (e) {
32. console.error(e);
33. }

天啊！？这是什么？我和小伙伴们彻底惊呆了！短短十几行代码就获得了上面5点的全面支持，重要的是小伙伴们居然一下子就看懂了，没有任何的遮遮掩掩和故弄玄虚。本来以为Ruby和Lisp很酷，小伙伴们都想马上去学Ruby和Lisp了，看到这个代码之后怎么感觉前面全是在装呢？有个小伙伴居然激动得哭着表示：我写代码多年，以为再也没有什么代码可以让我感动，没想到这段代码如此精妙，我不由得要赞叹了，实在是太漂亮了！

小伙伴们的故事讲完了，您看懂了吗？如果没有就看看下面的分析吧。

在绝大多数语言中数据和代码可以说是泾渭分明，习惯C++、Java等主流语言的程序员很少去思考数据和代码之间的关系。与多数语言不同的是Lisp以“数据即代码，代码即数据”著称，Lisp用S表达式统一了数据和代码的形式而独树一帜。Lisp奇怪的S表达式和复杂的宏系统让许多人都感到Lisp很神秘，而多数Lisp教程要么强调函数式编程，要么鼓吹宏如何强大，反而掩盖了Lisp真正本质的东西，为此我曾写过一篇《Lisp的永恒之道》介绍Lisp思想。

设计思想和具体技术的区别在于前者往往可以在不同的环境中以不同的形式展现出来。比如，熟悉函数式编程的程序员在理解了纯函数的优点后即使是用C语言也会更倾向于写出无副作用的函数来，这就是函数式思想在命令式环境的应用。所以，理解Lisp思想一定要能在非Lisp环境应用，才算是融汇贯通。

如果真正理解了Lisp的本质，那所谓的“数据即代码，代码即数据”一点儿也不神秘，这不就是我们每天打交道的配置文件吗！？如果你还不是很理解的话，我们通过下面几个问题慢慢分析：

1) 配置的本质是什么？为什么要在程序中使用配置文件？

不知道你是否意识到了，我们每天都在使用的各种各样的配置本质上是一种元数据也是一种DSL，这和Lisp基于S表达式的“数据即代码，代码即数据”没有本质区别。在C++、Java等程序中引入配置文件的目的正是用DSL弥补通用语言表达能力和灵活性的不足。我知道不少人喜欢从计算的角度来看到程序和语言，似乎只有图灵完备的语言如C++、Java、Python等才叫程序设计语言，而类似CSS和HTML这样的东西根本不能叫做程序设计语言。其实，在我看来这种观点过于狭隘，程序的本质是语义的表达，而语义表达不一定要是计算。

2) 配置是数据还是代码？

很明显，Both!说配置是数据，因为它是声明式的描述，能方便地修改和传输；说配置是代码，因为它在表达逻辑，你的程序实际上就是配置的解释器。

3) 配置的格式是什么？

配置的格式是任意的，可以自己定义语法，只要配以相应的解释器就行。不过更简单通用的做法是基于XML、JSON、或S表达式等标准结构，在此之上进一步定义schema。甚至完全不必是文件，在我们的项目中配置经常是放到用关系数据库中的。

4) 业务逻辑都可以放到配置中吗？

这个问题的答案显然是：Yes！我没有遇到过不可以放入配置的逻辑，只是问题在于这样做是否值得，能达到什么效果。对于需要灵活变化，重复出现，有复用价值的东西放入作为配置是明智的选择。这篇文章的主要目的就在于介绍把主要业务逻辑都放到配置中，再通过程序解释执行配置的设计方法，我称之为元驱动编程(Meta Driven Programming)。