费波拉且数的算法如图所示：

所以a和b分别保存了前两次的结果，每次for循环调用generator都从yield这一行代码恢复然后进行a, b = b, a+b操作。然后判断a是否小于等于n决定返回结果。

如果不用coroutine.wrap，我们可以这样写，效果是一样的，代码稍显啰嗦：

这里尝试着回答一下LuaFaq问题：

我可以使用Unicode字符串么？或者，Lua支持Unicode么？

简言之，可以，不支持。Lua只有极为精简的支持和足够的辅助功能，就没有其它的了。Unicode是一个庞大而复杂的标准，像是“Lua是否支持Unicode”是比较模糊地问题。

一些问题如下：

我可以存取Unicode字符串么？

我的Lua程序能用Unicode写么？

我可以比较Unicode字符串是否相同么？

字符串排序。

模式匹配。

我可以取得一个Unicode字符串的长度么？

支持括号型匹配，双向打印，随意的字符串组合以及各种高品质排版技术中产生的问题。

Lua字符串使用8-bit，所以简单的应用是支持的（比如存取操作）。但对于其他复杂操作没有内建支持。想知道更多故事，往下看。

Unicode字符串和Lua字符串

一个Lua字符串是一个至少8bit值的任意组合；可以直接映射到C编译器中的char类型（可能会比8bits更宽，但是一定会保证有8bits）。Lua没有保留任意字符，包括NUL。这意味着你可以成功地在Lua中存储UTF-8字符串。

注意UTF-8只是存储Unicode字符串的一种可能。还有其他编码模式，包括UTF-16和UTF-32以及它们的大端、小端变体。无论如何，所有这些都仅仅是8位字节的组合，可以毫无问题的存储到Lua字符串中。

在Lua中字符串的输入输出（使用IO库）使用C的stdio库，ANSI C不需要stdio库来处理任意8位字节顺序，除非是二进制模式。更进一步说，在非二进制模式，一些8位字节顺序可以转换到其他字符（为了处理不同平台上的换行符）。

这可能影响到处理非二进制的而且不是UTF-8格式的Unicode字符串文件输入输出。UTF-8字符串可能还是安全的，因为UTF-8不使用控制字符如\r \n作为多字节解析的一部分。而且这也不是一定的。如果你需要个确定答案，你应该使用二进制模式输入输出（binary-mode）。（如果你使用二进制模式，行结尾符将不会被转换）。

Unix文件输入输出很长时间里都是8字节整的。如果你不关心可移植性，仅仅在Unix或者类Unix系统上工作，可以完全不用担心前面提到的。

如果你使用Unicode是限制在传送字符串到外部支持Unicode的程序员，应该是不用担心的。例如，你应该可以从数据库取得一个Unicode字符串传递到一个识别Unicode的图形库中。但是也看看下面关于模式匹配和字符串等同比较的章节。

Unicode Lua 程序

字面型Unicode字符串可以出现在你的Lua程序组，UTF-8编码的字符串可以直接用8位字符形式或者使用\ddd语法（注意ddd是一个十进制数）。无论如何没有编码多字节顺序的功能（比如\U+20B4）；你可能不得不手动把它们编码成UTF-8格式或者以正确的大端或小端顺序塞进单独的8位字节数值中（针对UTF-16或者UTF-32）。

如果你不是使用某个char比8位更长字节的操作系统，就不能用任意的Unicode字符作为Lua标示符（变量名或者类似）。你可能使用ANSI以外的8位字符，Lua使用C函数isalpha和isalnum来辨别正确的可作为标示符的字符，所以这与当前locale配置有关。实话讲，使用ANSI以外的的字符做标示符不是一个好主意，因为你的程序可能没法在标准C locale下编译。

比较和排序

Lua字符串比较（使用==操作符）是通过逐个字节比较完成。这意味着==仅仅可以用来比较特殊的等同性，就是Unicode字符已经被正常化为正常可能之一（http://www.unicode.org/faq/normalization.html）。标准Lua库不提供任何正常化Unicode字符串的能力。相应的，非正常化的Unicode字符串也不能被可靠的用作table的key。

如果你想用Unicode类型的字符串等同比较，或者使用Unicode作为table的key，你不能保证你的字符串一定被正常化，然后你不得不自己写或者寻找一个正常化函数，这是一个很重要的练习！

Lua字符串比较操作符（<和<=）使用C语言函数strcoll，这个函数依赖于locale配置。这意味着两个字符串随着locale不同会得到不同的结果。例如，字符串使用西班牙语传统排序与威尔士语排序结果是不一样的。

也许你的操作系统实现了你想要的排序算法，这时候你可以使用它们，否则你可能要自己写函数来对Unicode字符串排序。这是一个更重要的练习。

UTF-8被设计成一个8位字节序的简单逐位比较可以得到同样的结果。UTF-32也是正确的，但是我不知道什么系统使用这个编码方式。不幸的是，简单的逐位比较没有被用作任何语言的排列顺序。

模式匹配

Lua的模式匹配的工作方式也是逐个字节的。通常情况下，这对于Unicode的模式匹配没有用处。即使有时候程序以你预想的方式工作了。例如，"%u"将不能匹配所有Unicode大写字符。你能匹配正常化后的Unicode字符串中的单个Unicode字符，但是你可能也担心字符串顺序。如果没有后续合并字符串，"a"将匹配一个UTF-8字符中的字符a。在UTF-16LE中你能匹配"a%z"。（记住你不能使用\0在Lua模式中）

长度和字符串索引

如果你想知道一个Unicode字符的长度，根据情况不同你会得到不同答案。

如果你想知道一个字符串占据多少个字节，比如你想拷贝到某个buffer中，现有的string.len函数可以工作。

你可能想知道Unicode字符串有多少字符。根据被使用的编码，一个单一的Unicode字符占用4个字节。只有UTF-32LE和UTF-32BE是常数长度编码（每个字符四字节）；UTF-32是一个常数长度编码但是第一个元素应该是”字节序标记”。这不应该被看做字符（UTF-32和变体是最新版本Unicode4.0的一部分）。

一些UTF-16的实现确保所有字符都是两字节长，但是从Unicode3.0版本以后就不是这样。

很高兴的是UTF-8被设计成很容易计算Unicode字符串中符号个数；仅仅计算0×00到0x7f或者0xC2到0xF4范围内的八位字节数字个数。这些是UTF-8字符码的开始。0xC0, 0xC1, 0xF5到0xFF不能用于构成UTF-8字节序；八位字节在0×80到0xBF可以仅仅出现在第二个或者多位编码后面部分。记住你不能使用\0在Lua模式中。

例如，你想使用接下来的代码计算UTF-8字符个数，（对于计算某些非法字符，这是不正确的）

local _, count = string.gsub(unicode_string, "[^\128-\193]", "")

如果你想知道一个Unicode字符串占据多少打印列（当你使用固定宽度字体），又有不同的回答了。这是因为某些Unicode字符没有一个打印宽度，而另外一些有两倍的打印宽度。合并字符被用于给其他字符加重音，通常打印时不占据额外空间。

所以不同情况下至少有三种不同的长度可能。Lua提供了一种string.len，而其它你需要自己写函数。

有一个类似的问题就是通过位置索引字符串某个字符。string.sub(s, -3)会返回最后三个字节，但未必会返回最后三个字符。

你可能使用接下来代码段枚举UTF-8字节序：

 for uchar in string.gfind(ustring, "([%z\1-\127\194-\244][\128-\191]*)") 

  do -- something 

end

More sophisticated issues

As you might have guessed by now, Lua provides no support for things like bidirectional printing or the proper formatting of Thai accents. Normally such things will be taken care of by a graphics or typography library. It would of course be possible to interface to such a library that did these things if you had access to one.

There is a little string-like package [slnunicode] with upper/lower, len/sub and pattern matching for UTF-8.

See ValidateUnicodeString for a smaller library.

[ICU4Lua] is a Lua binding to ICU (International Components for Unicode [1]), an open-source library originally developed by IBM.

See UnicodeIdentifers for platform independent Unicode Lua programs.

2, download luasocket latest code. Unzip it to the folder we create in step1.

3, open lua solution file with vc2010 (I think VC2008 should be OK too). try to build it. Should be successful.

4, add all *.h *.c file of luasocket into the project. Remove following from project: usocket.h usocket.c unix.h unix.c. They are used by unix OS.

5, Modify the project setting.

preprocessor definitions look like: WIN32;_WIN32LUASOCKET_EXPORTS;LUASOCKET_DEBUG;LUASOCKET_API=__declspec(dllexport);NDEBUG;_CONSOLE;%(PreprocessorDefinitions)

and add “Ws2_32.lib;”into library.

6, insert

  {"mime", luaopen_mime_core},  {"socket", luaopen_socket_core},

into luaL_Reg lualibs[] of linit.c file.

add two extern function declaration.

int luaopen_mime_core (lua_State *L);int luaopen_socket_core (lua_State *L);

7, build.

8, change socket.lua under luasocket from require("socket.core") to require("socket") , change mime.lua, from require("mime.core") to require("mime")

9, in your test script, for example the testclnt.lua in luasocket/example, add this line

loadfile("socket.lua")()

before socket = require("socket");

10, run the test. Everything should be OK now.

http://comments.gmane.org/gmane.comp.lang.lua.general/67646

http://lua-users.org/wiki/LuaCoroutinesVersusPythonGenerators

——————

Javascript1.7版有一个非常类似Python生成器(generator)的特性；而类似Lua协程风格的变体在经过长期讨论以后被拒绝（参考http://www.neilmix.com/2007/02/07/threading-in-javascript-17/ ）

Python生成器与Lua协程有什么不同之处？Lua最重要的特性，coroutine.yield()是个一般函数，可以在coroutine.resume()动态扩展的任意位置被调用，限制是你不能yield操作C回调函数（除非你使用了Coco库）。在Python中，yield是一个语法，只能在生成器（generator）的语句体里存在。

这意味着Python生成器必须写成生成器形式，不能分解成更小的函数，也不能递归调用自身。你可以通过一个链的形式实现，有封讨论组的邮件http://mail.python.org/pipermail/python-list/2005-August/335545.html 描述了这种机制：

在Lua中，我们可以写神秘的（agnostic）inorder函数作为高阶函数（higher-order）。

这个Lua函数可以用作for loop里面的枚举器：

或者是类似foreach函数排序：

inorder(print, t)

我试图尽量简化递归型生成器的比较，写了一些简单程序生成infinite ruler function（http://www.research.att.com/~njas/sequences/A001511 ）。关于这个函数的一个更有意思的网页是Michael Naylor的http://www.ac.wwu.edu/~mnaylor/abacaba/abacaba.html

Ruler function可以写成没有递归的形式。但是这个例子里它需要一些特性如深度优先搜索，所以我们还是看看递归实现方式。程序按顺序生成2 ^ K值，然后把它们加到一系列校验测试中。很容易知道ruler函数中前面2 ^ K个元素的和是2^(K+1) -1。Python内嵌函数及标准库可以很容易完成它；在Lua中，我不得不实现sum和islice函数，幸运的是这并不难。

所以Lua实现如下：

Python也非常类似：

这里面递归有些诡异，原因是我们手动改变尾调用为一个for loop，因为Python不支持尾调用，而且原始的尾调用实现使得Python数据更难看。

两个程序都可以通过检查，所以只粘贴一下比较结果。我不相信这仅仅是因为“Lua跑得比Python快”，真正原因应该是协程coroutine更快一些，主要不同的地方是不需要传递值到一系列yield中。

译者注：

关于Ruler function，可以参考wiki http://en.wikipedia.org/wiki/Thomae%27s_function

（后记，由于这方面知识的缺乏，翻译的非常蹩脚难懂，自己都感觉很难受，希望有达人能提出建议意见）

2010-6-14 Update：感谢云风的留言，修改了一些错误的地方。

最近浏览stackoverflow发现这几个不错的帖子，分享给大家：

http://stackoverflow.com/questions/2674462/lua-and-c-separation-of-duties

Lua与C的责任分配问题。

http://stackoverflow.com/questions/2685636/lua-game-state-and-game-loop

游戏大循环（game loop）该如何维护？

——————————————

另外国内网易云风的博客上也零零散散有些内容，可以参考。

我不是游戏开发业者，所以也不好发表什么建议。但是我想比较重要的一点，也是在程序设计理念上一直强调的一点是：你要知道你要做什么，你想完成什么功能需求。

有些人话都说不清楚，就想搞游戏设计开发。脑子里都是浆糊，怎么可能设计出清晰的程序逻辑。找一支笔一个本子，先把你的需求想法列出来，画个交互关系图，把时序逻辑理清了，该如何设计如何开发也就容易多了。其实这也就是常识性的东西，只是现在不少人浮躁的连常识都没有了。

1，对学习这门语言或者技术的必要性进行评估。比如你是工作需要，或者兴趣所至，甚至是为了把妹。这个必要性关系到你要学多深入，需要学习多长时间。

比如我想学Lua，是想学它如何在万把行代码里面实现了一个如此精巧的编程语言，想学习它的GC机制，学习它如何设计VM，如何用纯C语言设计项目等等。

2，寻找相关资源。比较好的起始点是这门技术的官方网站以及维基百科。

比如Lua语言的官方网站是http://www.lua.org，维基百科地址为http://en.wikipedia.org/wiki/Lua_%28programming_language%29

一般在google.com里面敲入"lua wiki"之类就能直接搜索到相关维基条目。使用维基百科的好处是能够对编程语言有个概括了解，基本上看了以后，你都可以跟别人扯上几句一点问题也没有。另外维基百科在编程语言相关条目中有一个很有意思的特色就是：influenced by以及influenced列表。比如Lua条目中注明被Scheme、SNOBOL、Modula、CLU、C++所影响，影响了IO、GameMonkey、Squirrel、Falcon、Dao、MiniD这些语言，通过它可以了解到这门语言的祖先以及后代，相当的有意思。

而在官方网站，会有最新鲜的新闻、下载、文档帮助、论坛等相关内容。

3 找到官网以后，就要花上一段时间在官方网站好好浏览探寻一番。比如Lua官方网站的about栏目介绍了Lua是什么，为什么选择Lua，谁编写了Lua代码等等。在News栏目有关于Lua的最新新闻。Download栏目中有软件下载，学习一门语言，重要的是在练习中学习，大多数人都用Windows，就可以遵照下载栏目的推荐下载Lua for windows。

4 下载了软件（Lua for windows），安装成功以后，就可以看看文档document了。在Lua的文档网页中有在线参考手册（reference manual），大多数编程语言也都会在下载安装包中自带一份手册文档（就我所知Ruby Python都是如此）。

如何系统的学习一门语言？通过手册不是什么好办法，手册内容相对教条枯燥，读起来不容易。而且在线学习注意力不容易集中，很容易点着点着就跑偏了。最好的办法还是要买一本实体的参考书。

买实体书就要用到amazon或者douban了，你可以根据amazon以及douban上的打分来确定这本书的好坏，另外在Lua的document页面也有几本书推荐，像是Lua这种略微偏门的语言，其实选书很简单，因为就那么两三本，我个人推荐Programming in lua，国内有翻译版本，另外也可以下载到5.0的中文版。

那么对于java、dotnet这类参考书乌央乌央的技术来说，该如何选书？这时候我会参考以下几个因素：一个是语言创始人写的可选择，一个是奥莱里oreilly出版的可以买，另外可以参考豆瓣或者amazon的书单功能，看看其他人都推荐什么。最不济的办法可以看销量，销量高的书未必就好，但是选了也不至于错的离谱。

买到书以后，最好花上几天时间通读一下，对于不理解的部分先标记略过，力争先对语言技术的整体有个了解，对于一些基本操作、命令有一些印象。

5 通读以后就要细读了，一般来讲，每个编程语言都力争相对完整，所以必然有一些你未必感兴趣的内容或者用不到的内容，这些都可以放在一边需要时候再捡起来。细读的过程最好准备个小本子，另外建议在github上注册一个账号，github有个gist.github.com页面可以保存代码片段，在做代码练习的时候很有用。

细读的过程力争完全理解，书上的示例代码也都尽量自己敲进去运行一次，另外可以对示例代码做一定的扩展，比如在第五章的代码中加入第四章的代码，让它们组合起来看看如何。

6 用一两个月时间细读以后就是熟练提高阶段。当你细读了感兴趣的章节，最好在一段时间内尽量用新语言完成自己的编程需求，比如写个网络爬虫，或者删除某个目录下的特定文件，或者做做文本处理，一定要经常用才不会忘记。这段使用过程可能需要两三个月的时间，力争达到常见的代码函数不怎么查手册就可以熟练写下来。另外可以有意的对自己已经完成的算法或者应用进行语言上的翻译，用新语言实现一下快速排序，实现一下正则表达式。编程其实就是个熟练过程，越练越顺手。

这个时候可以试着购买一些advanced级别的书籍，了解一些更深入的内容，书籍的好坏依然是到amazon或者douban上搜索。

提高的过程中可以订阅一些相关的博客内容，可以到blogsearch.google.com查找博客文章，或者到csdn、javaeye、cnblogs这样的技术相关博客站点搜索。看到好的文章，可以使用delicious.com这个书签网站保存起来以后慢慢阅读。

7 在这段期间包括以后的使用过程，如果出现问题怎么办？可以遵照以下顺序查找帮助：

    a）书籍或者手册，在线文档，在线帮助等等

    b）在官网的wiki或者stackoverflow.com上搜索相关的关键字。

    c）使用google搜索相关关键字。

    d）到stackoverflow或者官方邮件列表、官方论坛中提问。

一般来说最好订阅这门语言的邮件列表，比如Lua的邮件列表就是http://www.lua.org/lua-l.html 即使不提问，看看别人的问题也是很有意思的。

我不建议大家加入什么QQ群学习，QQ或者msn的即时通讯特性决定了它不是一个很好的学习方式，基本上只适合打屁聊天。

8 到了四五个月以后，按照前面步骤学下来的朋友应该已经算是中级水平了，不太可能问出什么“跪求、裸求”之类的弱智问题。这时候就可以往更深入的层次发展，比如试着读读源代码，试着写写相关编程库编程插件，在官方论坛、maillist、stackoverflow里面多帮人解答解答问题，试着多写写自己对于这门语言的使用经验，分享一些相关问题等等，就此走向“破碎虚空”的高手之路。

好了，就这样吧！

我刚买了Seven languages in seven weeks这本书的Beta版，真是一本好书。

这本书每章介绍一门编程语言，总共是七门语言。每章你都能找到语言的介绍，还有一些练习和自学题目。实际上每章也分成三天，我将用“第一天”“第二天”“第三天”来写它们。

这本书里介绍了下面这些编程语言：

Ruby

IOLanguage

Prolog

Scala

Erlang

Clujure

Haskell

因为我（原作者）知道ruby了，就很快翻到第二章IOLanguage。IO是一门原型编程语言，某种程度上类似javascript（译者注：类似语言还有Lua）。我喜欢这门语言的语法和简洁性。

在Mac os X上安装IO

如果你想编译所有依赖库，从源代码开始安装需要一些时间。这里我们使用macports来获取所有依赖库，你可以在这里http://www.iolanguage.com/scm/io/docs/IoGuide.html#Introduction-Installing找到详细的安装文档。

 1: cd ~/

 2: git clone git://github.com/stevedekorte/io.git

 3: cd io

 4: make vm; sudo make install; sudo make port; sudo make install

你可能不得不加入一些辅助库，可以参考前面关于安装的在线文档知道详细步骤。

如果你想安装textmate的绑定，可以运行以下命令：

 1: cd "/Library/Application Support/TextMate/Bundles"

 2: svn co http://svn.textmate.org/trunk/Bundles/Io.tmbundle/

就是这些，现在可以运行Terminal程序了。

IO语言基础

IO编程语言的完整介绍可以参考这里http://www.iolanguage.com/scm/io/docs/IoGuide.html

下面是一个简单的预览：

 1: Io 20090105

 2:  

 3: Io> 3 * 4

 4: ==> 12

 5:  

 6: Io> Animal := Object clone

 7: ==> Animal_0x10034c170:

 8: type = "Animal"

 9:  

 10:  

 11: Io> Animal description := "All animals in the world"

 12: ==> All animals in the world

 13:  

 14: Io> dog := Animal clone

 15: ==> Animal_0x10033f5f0:

 16:  

 17: Io> dog description

 18: ==> All animals in the world

 19:  

 20: Io> dog description := "A generic dog"

 21: ==> A generic dog

 22:  

 23: Io> dog description

 24: ==> A generic dog

 25:  

 26: Io> dog talk := method("Baw" print)

 27: ==> method(

 28: "Baw" print

 29: )

 30:  

 31: Io> dog talk()

 32: Baw==> Baw

 33:  

 34: Io> list(1, 2, 3) sum

 35: ==> 6

 36:  

 37: Io> list(1, 2, 3) average

 38: ==> 2

 39:  

 40: Io> list(1, 2, 3) map(x, x * x)

 41: ==> list(1, 4, 9)

 42:  

 43: Io> fibonacci := method(n, if(n < 2, n, (fibonacci(n -1) + fibonacci(n - 2))))

 44: ==> method(n,

 45: if(n < 2, n, (fibonacci(n - 1) + fibonacci(n - 2)))

 46: )

 47: Io> fibonacci(34)

 48: ==> 5702887

先别担心这语言看上去有些怪异，实际上你会发现它的语法非常简单。

通过IO建立一个在线新闻程序

这是我做的一个小练习，刚刚学过语言以后，用IO语言在20分钟内创建一个简单版本的新闻平台。代码不是很出彩，但是它证明了使用IO多轻松简单。

 1: # INSTANTIATE DB

 2:  

 3: db := SQLite clone

 4: db setPath("news.sqlite")

 5:  

 6: # HTML HELPERS

 7:  

 8: ul := method(content, "<ul>" .. content .. "</ul>")

 9:  

 10: li := method(content, "<li>".. content .. "</li>")

 11:  

 12: a := method(text, url, "<a href=\"#{url}\">#{text}</a>" interpolate)

 13:  

 14: form := method(action, content, "<form action=\"#{action}\" method=\"get\">" interpolate .. content .. "</form>")

 15:  

 16: field := method(name, "<label>#{name}</label>: <input type=\"text\" name=\"#{name}\" \>" interpolate)

 17:  

 18: submit := method("<input type=\"submit\" />")

 19:  

 20: with_template := method(title, body,

 21: "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"

 22: \"http://www.w3.org/TR/html4/loose.dtd\">

 23: <html>

 24: <head>

 25: <meta http-equiv=\"Content-type\" content=\"text/html; charset=utf-8\">

 26: <title>" .. title .. "</title>

 27: <style type=\"text/css\" media=\"screen\">

 28: body {

 29: background:#ffffcc;

 30: margin:20px;

 31: padding:0;

 32: font-family:Calibri;

 33: font-size:18px;

 34: }

 35:  

 36: h1 {

 37: color:#006363;

 38: margin:1em;

 39: }

 40:  

 41: a {

 42: color:#ff7373;

 43: font-size:20px;

 44: }

 45:  

 46: li {

 47: line-height:1.5em;

 48: }

 49: </style>

 50: </head>

 51: <body>" .. a("Home", "/") .. " - " .. a("New", "/new") .. "<h1>" .. title .. "</h1>" .. body .. "</body></html>"

 52: )

 53:  

 54: # Actions

 55:  

 56: render_index := method(params,

 57: db open

 58: posts := db exec("SELECT * from posts")

 59: db close

 60:  

 61: posts_html := posts map(post, li( a( post at("title"), post at("url") ) ) ) join

 62:  

 63: with_template("Io News", ul(posts_html))

 64: )

 65:  

 66: render_new := method(params,

 67: with_template("New", form("/create", field("title") .. field("url") .. submit() ))

 68: )

 69:  

 70: render_create := method(params,

 71: db open

 72: db exec("INSERT into posts (title, url)

 73: values ('#{params at(\"title\")}', '#{params at(\"url\")}')" interpolate)

 74: db close

 75: with_template("Hurray!", "Io rocks!")

 76: )

 77:  

 78: not_found := method(

 79: with_template("Not found")

 80: )

 81:  

 82: # Unfortunately I had to manually extract the parameters

 83:  

 84: extract_parameters := method(string,

 85: # foo=bar&x=y => list(list("foo", "bar"), list("x", "y"))

 86: l := string split("&") map(param, param split("="))

 87:  

 88: params := Map clone

 89: l foreach(param, params atPut(param at(0), param at(1)))

 90: params

 91: )

 92:  

 93: handle_request := method(request,

 94: path_and_parameters := request split("?")

 95: path := path_and_parameters at(0)

 96:  

 97: if(path_and_parameters size > 1,

 98: parameters := extract_parameters(path_and_parameters at(1)),

 99: parameters := nil

 100: )

 101:  

 102: # Does anyone know how to implement cond()?

 103: if(path == "/",

 104: render_index(parameters),

 105: if(path == "/new",

 106: render_new(parameters),

 107: if(path == "/create",

 108: render_create(parameters),

 109: not_found

 110: )

 111: )

 112: )

 113: )

 114:  

 115: WebRequest := Object clone do(

 116: handleSocket := method(aSocket,

 117: aSocket streamReadNextChunk

 118: request := aSocket readBuffer betweenSeq("GET ", " HTTP")

 119: aSocket streamWrite(handle_request(request))

 120: aSocket close

 121: )

 122: )

 123:  

 124: WebServer := Server clone do(

 125: setPort(8000)

 126: handleSocket := method(aSocket,

 127: WebRequest clone @handleSocket(aSocket)

 128: )

 129: )

 130:  

 131: WebServer start

如果你想运行代码，你可能需要先建立一个数据库结构，下面是我的步骤：

 1: db := SQLite clone

 2: db setPath("news.sqlite")

 3: db open

 4: db exec("CREATE TABLE posts(id INTEGER PRIMARY KEY ASC,

 5: title VARCHAR(255),

 6: url VARCHAR(255),

 7: published_at DATE)")

 8:  

 9: db exec("INSERT INTO posts (title, url, published_at)

 10: values

 11: ('Welcome aboard', 'http://example.com', DATETIME('NOW'))")

 12:  

 13: db exec("INSERT INTO posts (title, url, published_at)

 14: values

 15: ('Io documentation', 'http://www.iolanguage.com/scm/io/docs/IoGuide.html', DATETIME('NOW'))")

 16:  

 17: db close

结果如下：

个人而言，我非常喜欢IO语言，我可能会多学习它几天时间。

string trim功能

 1: function string_trim(s)

 2: if s == nil then

 3: return

 4: end

 5:  

 6: return (string.gsub(s, "^%s*(.-)%s*$", "%1"))

 7: end

检查某个字符串是不是指向合法目录。

 1: function check_directory(s)

 2: s = string_trim(s)

 3: if not s or s == "" then

 4: return false

 5: end

 6:  

 7: if string.sub(s, -1, -1) == [[\]]then

 8: s = string.sub(s, 1, -2)

 9: end

 10:  

 11: local attr = lfs.attributes (s)

 12: if (attr and attr.mode == "directory") then

 13: return true

 14: end

 15:  

 16: return false

 17: end

对于文件操作，最好先备份一下原来文件：

 1: local str = "copy \"" .. Folder .. '\\log.db' .. "\" \"" .. Folder .. '\\log.db' .. "." .. os.time() .. "\" /v /y"

 2:  

 3: os.execute(str)

对于sqlite的操作，注意使用了一个自增myid作为key。

 1: Db1 = sqlitelua.open(upFolder .. '\\mainlog.db')

 2:  

 3: Db1:exec('CREATE TABLE newfiles(myid INTEGER PRIMARY KEY AUTOINCREMENT, myname, myfolder)')

 4:  

 5: local stmt1 = Db1:prepare[[ INSERT INTO newfiles VALUES (:myid, :myname, :myfolded) ]]

 6:  

 7: stmt1:bind_names{myname = new_name, myfolder = currentFolder}

 8:  

 9: stmt1:step()

 10: stmt1:reset()

 11: stmt1:finalize()

很有意思的是，下面的代码是有效地，我也是看了书才知道。代码后面可以跟着，也可以不跟分号。

 1: a = 5 b = 6

 2: c = 7; d = 8;

 3: print(a, b, c, d)

Lua中，什么是字母依赖于locale的设置，也就是中文环境下，中文可以用作变量名（？这个需验证）

Lua有大小写之分。

常用的块注释方式是–[[然后以--]]结尾，这样如果想取消块注释，就把开头多加个-就行了。

LUA_INIT内容为@文件名，解释器会先执行这个文件（？需验证）。

Lua中的（以后省略）函数为第一类值，比如print = type; print(a); 这个是合法合理的，但是print就没有了，一般用于沙箱sandbox操作。

条件判断只有两种情况为假，false以及nil。其余都为真。

number是实数（通常下）。用双精度代表整数，只要这个数字不大于10的14次方就没问题（本书这里笔误为1014，shit，我对照了PIL第一版确认的）。重新编译数字类型可以方便用于其它平台luaconf.h。数字可以写作4.57e-3 0.3e12 5e+20这种科学计数法。

Lua可以存储任意二进制字符到字符串类型中。5.1支持的长括号写法[===[匹配]===]，只要等号数量移植。字符串与数字运算，数字会转成字符串，可以用tonumber把字符变成数字。

 1: local str = "5e+20"

 2: local num = tonumber(str)

 3: print(num)

数字转成字符，可以用tostring或者让数字与空字符串连接。

5.1的字符串支持#。

local a = {}创建了一个table，并且让a引用这个table，通过a这个变量我们可以操作这个table，如果没有变量继续引用这个table（a = nil），Lua会负责回收内存销毁它。

a["nameX“] = 5 等价于 a.nameX = 5，注意key里面的引号。local a = {}; a[x] = 5这个代码是不合法的。local a = {}; a["x"] = 5; print(a.x);这个会打印出5。

长度操作#的常用做法，print(a[#a])打印最后一个（因为Lua的table索引从1开始），a[#a +1] = n常用与自增，a[#a] = nil删除最后一个。

注意当table中有空洞（数字索引不连续，或者某个值为nil）的时候，#操作未必得到正确值。

5.1新增%取模操作。a % b == a – floor(a / b) * b，结果符号永远与第二个参数相同。print(5 % -2)得到-1，print(-5 % 2)得到1。另外取模操作可以用于对实数取整数部分或者小数部分。x = math.pi; x – x % 0.01 是让x精确到小数点后2位。x % 1 取小数部分，x – x % 1 取到整数部分。

table，userdata以及function，比较引用。

and与or都是用短路求值。 x = x or v常用于默认值设置。

Lua中的字符串是不可变值immutable value，两个字符串链接，会返会一个新的字符串。

链表写法：

 1: list = nil

 2: for line in io.lines() do

 3: list = {next = list, value = line}

 4: end

local a = { [-1] = 3, ["3"] = 5, ["n"] = "bbb"};

print(a[-1]); print(a["3"]); print(a.n);比较有意思的是a["3"]没法写成a.3。

a = {x = 0, y = 0} 相当于a = {["x"] = 0, ["y"] = 0}的语法特例。

local a = { [-1] = 3; ["3"] = 5; ["n"] = "bbb"};这样写也是合法的，构造式可以用分号代替逗号。

第四章

x, y = y, x交互x与y的值。

可以用do-end控制局部变量的范围。

local print = print，相当于定义了一个局部变量print（函数），后面如果使用print，就是访问了这个局部变量。访问局部变量要比访问全局变量快。

while x do .. end，当x为真值时进入while；repeat .. until x，当x为真值的时候结束循环。这点我弄混过。

 1: print( 5 % 3)

 2: print( -5 % 3)

 3: print( 5 % -3)

 4: print(-5 % -3)

The result will be 2, 1, -1, -2.

 1: if not nil then

 2: print("not nil")

 3: end

 4:  

 5: if not false then

 6: print("not false")

 7: end

 8:  

 9: if 0 then

 10: print("0")

 11: end

 12:  

 13: if "" then

 14: print("empty string")

 15: end

The result will be "not nil", "not false", "0", "empty string", in Lua, only nil and false will be FALSE in condition checking.

 1: for i = 1, 5 do

 2: print(i)

 3: i = i + 5

 4: print(i)

 5: print("")

 6: end

OK, the result will be 1  6, 2  7, 3  8, 4  9, 5  10, you could see the index variable "i" is not changed for the for-loop, and you could assign new value (i=i+5) to it in the for range, but it will restore back to the loop index value again.

 1: local x, y = {}

 2: print(x)

 3: print(y)

 4:  

 5: y = x

 6: print(y)

 7: table.insert(y, "aa")

 8: print(x[1])

It will print like "table: 003CACB0" "nil" "table: 003CACB0" "aa".

Two thing need to note, local x, y = {} will only initialize the "x". Another is the y will have same address with x if x is a table, and insert to table y will cause x changes too. It seems like in c or c++ only copy the pointer address, not copy the value with the pointer.