Code is data

Several friends are considering the following problems that each language will encounter ：

problem ： Design a command line parameter parsing API

A good command line parameter parsing library generally involves these common aspects ：

1) Support easy generation of help information

2) Support subcommands , such as ：git Contains push, pull, commit And so on

3) Single character option is supported 、 Multi character options 、 Flag options 、 Parameter options and other options and position parameters

4) The default values of options are supported , such as ：—port If the option is not specified, it will be considered as 5037

5) Support usage mode , such as ：tar Ordered -c and -x Is a mutually exclusive option , Belong to different usage modes

After some investigation , The partners found several representative API Design ：

1. getopt()：

getopt() yes libc The standard function of , You can find a ported version of it in many languages .

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() The core of is a similar printf The command line parameter description string of the format string , As above ”ac” Defined ”a”, “c”,”d”3 Two command line arguments , among ,a Is an identifier without parameters ,”c” and ”d” Need to follow the parameters .getopt() Very weak , Only single character flag options and parameter options are supported . If you press the above 5 Click to compare , Basically, I can only say that I reluctantly support the 3 spot , Other items can only be realized by the program itself , therefore , Want to base directly on getopt() Implement a program like git Such complex command-line arguments are impossible , I have to do a lot of parsing work myself . My friends have seen getopt() After that, the unanimous evaluation was : too young too simple .

2. Google gflags

next , My friends found out again gflags This Google Produce C++ Parsing command line parameters .

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. }

After watching it, my friends could not help sighing “ It's really easy to use ”！ You bet ,gflags Command line options are defined simply through a few macros , Basically, it supports the above mentioned 1,3,4 These items , Compared with getopt() It's much better . For similar cp Such a small order ,gflags It should be enough , But to achieve git This level seems a little thin .

3. Ruby Commander

Then the little friends found out Ruby Commander library ：

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 Library utilization Ruby Cool syntax defines an internal... That describes command line parameters DSL, It looks quite high-end and elegant . Except for the first 5 Beyond item , Several other items are well supported , so to speak Commander The design of the library basically achieves git Requirements for command line parameter resolution at this level . It's just , To understand Ruby I'm afraid that such a dazzling syntax and the use of this library are not as good as getopt() and gflags It's easy . A little friend said on the spot that he wanted to learn Ruby, But there are also small partners who say that they should look at other libraries .

4. Lisp cmdline library

Next , My friends found out Lisp dialect Racket Of cmdline library .

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"))

This is the god horse floating cloud ? Parentheses cover parentheses , It looks very powerful , But I don't quite understand . See this design , Some of my friends are too lazy to comment , But some friends are right Lisp More worship , Express Lisp Is the so-called ultimate language , No other language can write such code without awareness ！ My friends are preparing to finish the work , All of a sudden …

5. Node.js Of LineParser library

Found out Node.js Of LineParser library :

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. }

Oh my god ！？ What is it? ？ My friends and I were completely shocked ！ Just a dozen lines of code 5 Full support for point , The important thing is that the little friends can understand it at once , There is no concealment or deception . Originally thought Ruby and Lisp cool , All my friends want to learn at once Ruby and Lisp 了 , After seeing this code, how do you feel that the front is all installed ？ A little friend was so excited that he cried and said ： I've been writing code for years , I thought there was no more code that could move me , I didn't expect this code to be so exquisite , I can't help admiring , It's so beautiful ！

The story of my friends is over , Do you understand ？ If not, take a look at the following analysis .

In most languages, data and code are very distinct , habit C++、Java And other mainstream language programmers rarely think about the relationship between data and code . Unlike most languages Lisp With “ Data is code , Code is data ” Is famous for its ,Lisp use S Expressions are unique because they unify the form of data and code .Lisp strange S Expressions and complex macro systems make many people feel Lisp It's mysterious , The majority Lisp Tutorials either emphasize functional programming , Or preach how powerful the macro is , Instead, it covers up Lisp What is really essential , For this reason, I once wrote an article 《Lisp The eternal way of 》 Introduce Lisp thought .

The difference between design ideas and specific technologies is that the former can often be displayed in different forms in different environments . such as , Programmers who are familiar with functional programming understand the advantages of pure functions, even if they use C Languages also tend to write functions that have no side effects , This is the application of functional thinking in imperative environment . therefore , understand Lisp The thought must be able to be in the wrong Lisp Environmental applications , It can be regarded as integration .

If you really understand Lisp The essence of , So called “ Data is code , Code is data ” It's not mysterious at all , This is the configuration file we deal with everyday ！？ If you don't quite understand , We will analyze the following questions slowly ：

1) What is the nature of configuration ？ Why use configuration files in programs ？

I wonder if you realize , We use all kinds of... Every day Configuration is essentially a kind of metadata and a kind of DSL, This sum Lisp be based on S Of expression “ Data is code , Code is data ” There is no essential difference . stay C++、Java The purpose of introducing the configuration file into the program is to use DSL Make up for the lack of common language expression ability and flexibility . I know that many people like to see programs and languages from the perspective of computation , It seems that only Turing's complete language such as C++、Java、Python And so on is called programming language , But similar CSS and HTML Such a thing cannot be called a programming language at all . Actually , In my opinion, this view is too narrow , The essence of a program is the expression of semantics , Semantic expression does not have to be calculated .

2) Configuration is data or code ？

Obviously ,Both! Configuration is data , Because it is a declarative description , It can be easily modified and transmitted ; Say that configuration is code , Because it expresses logic , Your program is actually a configuration interpreter .

3) What is the configuration format ？

The configuration format is arbitrary , You can define your own grammar , As long as the corresponding interpreter is provided . But the simpler and more general approach is based on XML、JSON、 or S Expressions and other standard structures , Define further on this schema. It doesn't even have to be a file at all , In our projects, the configuration is often put into the relational database .

4) Can the business logic be put into the configuration ？

The answer to this question is obviously ：Yes！ I haven't encountered any logic that can't be put into the configuration , The question is whether it is worth it , What can be achieved . For the need to be flexible , Recurring , It is a wise choice to put something of reuse value into the configuration . The main purpose of this article is to introduce The main business logic is put into the configuration , Then the design method of execution configuration is explained through the program , I call it meta - driven programming (Meta Driven Programming).