Learn Lua in 15 Minutes 整理

Learn Lua in 15 Minutes more or less -- Two dashes start a one-line comment. --[[      Adding two ['s and ]'s makes it a      multi-line comment. --]] ---------------------------------------------------- -- 1. Variables and flow control. ---------------------------------------------------- num = 42  -- All numbers are doubles. -- Don't freak out, 64-bit doubles have 52 bits for -- storing exact int values; machine precision is -- not a problem for ints that need < 52 bits. s = 'walternate'  -- Immutable strings like Python. t = "double-quotes are also fine" u = [[ Double brackets        start and end        multi-line strings.]] t = nil  -- Undefines t; Lua has garbage collection. -- Blocks are denoted with keywords like do/end: while num < 50 do   num = num + 1  -- No ++ or += type operators. end -- If clauses: if num > 40 then   print('over 40') elseif s ~= 'walternate' then  -- ~= is not equals.   -- Equality check is == like Python; ok for strs.   io.write('not over 40\n')  -- Defaults to stdout. else   -- Variables are global by default.   thisIsGlobal = 5  -- Camel case is common.   -- How to make a variable local:   local line = io.read()  -- Reads next stdin line.   -- String concatenation uses the .. operator:   print('Winter is coming, ' .. line) end -- Undefined variables return nil. -- This is not an error: foo = anUnknownVariable  -- Now foo = nil. aBoolValue = false -- Only nil and false are falsy; 0 and '' are true! if not aBoolValue then print('twas false') end -- 'or' and 'and' are short-circuited. -- This is similar to the a?b:c operator in C/js: ans = aBoolValue and 'yes' or 'no'  --> 'no' karlSum = 0 for i = 1, 100 do  -- The range includes both ends.   karlSum = karlSum + i end -- Use "100, 1, -1" as the range to count down: fredSum = 0 for j = 100, 1, -1 do fredSum = fredSum + j end -- In general, the range is begin, end[, step]. -- Another loop construct: repeat   print('the way of the future')   num = num - 1 until num == 0 ---------------------------------------------------- -- 2. Functions. ---------------------------------------------------- function fib(n)   if n < 2 then return 1 end   return fib(n - 2) + fib(n - 1) end -- Closures and anonymous functions are ok: function adder(x)   -- The returned function is created when adder is   -- called, and remembers the value of x:   return function (y) return x + y end end a1 = adder(9) a2 = adder(36) print(a1(16))  --> 25 print(a2(64))  --> 100 -- Returns, func calls, and assignments all work -- with lists that may be mismatched in length. -- Unmatched receivers are nil; -- unmatched senders are discarded. x, y, z = 1, 2, 3, 4 -- Now x = 1, y = 2, z = 3, and 4 is thrown away. function bar(a, b, c)   print(a, b, c)   return 4, 8, 15, 16, 23, 42 end x, y = bar('zaphod')  --> prints "zaphod  nil nil" -- Now x = 4, y = 8, values 15..42 are discarded. -- Functions are first-class, may be local/global. -- These are the same: function f(x) return x * x end f = function (x) return x * x end -- And so are these: local function g(x) return math.sin(x) end local g; g  = function (x) return math.sin(x) end -- the 'local g' decl makes g-self-references ok. -- Trig funcs work in radians, by the way. -- Calls with one string param don't need parens: print 'hello'  -- Works fine. ---------------------------------------------------- -- 3. Tables. ---------------------------------------------------- -- Tables = Lua's only compound data structure; --          they are associative arrays. -- Similar to php arrays or js objects, they are -- hash-lookup dicts that can also be used as lists. -- Using tables as dictionaries / maps: -- Dict literals have string keys by default: t = {key1 = 'value1', key2 = false} -- String keys can use js-like dot notation: print(t.key1)  -- Prints 'value1'. t.newKey = {}  -- Adds a new key/value pair. t.key2 = nil   -- Removes key2 from the table. -- Literal notation for any (non-nil) value as key: u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} print(u[6.28])  -- prints "tau" -- Key matching is basically by value for numbers -- and strings, but by identity for tables. a = u['@!#']  -- Now a = 'qbert'. b = u[{}]     -- We might expect 1729, but it's nil: -- b = nil since the lookup fails. It fails -- because the key we used is not the same object -- as the one used to store the original value. So -- strings & numbers are more portable keys. -- A one-table-param function call needs no parens: function h(x) print(x.key1) end h{key1 = 'Sonmi~451'}  -- Prints 'Sonmi~451'. for key, val in pairs(u) do  -- Table iteration.   print(key, val) end -- _G is a special table of all globals. print(_G['_G'] == _G)  -- Prints 'true'. -- Using tables as lists / arrays: -- List literals implicitly set up int keys: v = {'value1', 'value2', 1.21, 'gigawatts'} for i = 1, #v do  -- #v is the size of v for lists.   print(v[i])  -- Indices start at 1 !! SO CRAZY! end -- A 'list' is not a real type. v is just a table -- with consecutive integer keys, treated as a list. ---------------------------------------------------- -- 3.1 Metatables and metamethods. ---------------------------------------------------- -- A table can have a metatable that gives the table -- operator-overloadish behavior. Later we'll see -- how metatables support js-prototypey behavior. f1 = {a = 1, b = 2}  -- Represents the fraction a/b. f2 = {a = 2, b = 3} -- This would fail: -- s = f1 + f2 metafraction = {} function metafraction.__add(f1, f2)   sum = {}   sum.b = f1.b * f2.b   sum.a = f1.a * f2.b + f2.a * f1.b   return sum end setmetatable(f1, metafraction) setmetatable(f2, metafraction) s = f1 + f2  -- call __add(f1, f2) on f1's metatable -- f1, f2 have no key for their metatable, unlike -- prototypes in js, so you must retrieve it as in -- getmetatable(f1). The metatable is a normal table -- with keys that Lua knows about, like __add. -- But the next line fails since s has no metatable: -- t = s + s -- Class-like patterns given below would fix this. -- An __index on a metatable overloads dot lookups: defaultFavs = {animal = 'gru', food = 'donuts'} myFavs = {food = 'pizza'} setmetatable(myFavs, {__index = defaultFavs}) eatenBy = myFavs.animal  -- works! thanks, metatable -- Direct table lookups that fail will retry using -- the metatable's __index value, and this recurses. -- An __index value can also be a function(tbl, key) -- for more customized lookups. -- Values of __index,add, .. are called metamethods. -- Full list. Here a is a table with the metamethod. -- __add(a, b)                     for a + b -- __sub(a, b)                     for a - b -- __mul(a, b)                     for a * b -- __div(a, b)                     for a / b -- __mod(a, b)                     for a % b -- __pow(a, b)                     for a ^ b -- __unm(a)                        for -a -- __concat(a, b)                  for a .. b -- __len(a)                        for #a -- __eq(a, b)                      for a == b -- __lt(a, b)                      for a < b -- __le(a, b)                      for a <= b -- __index(a, b)    for a.b -- __newindex(a, b, c)             for a.b = c -- __call(a, ...)                  for a(...) ---------------------------------------------------- -- 3.2 Class-like tables and inheritance. ---------------------------------------------------- -- Classes aren't built in; there are different ways -- to make them using tables and metatables. -- Explanation for this example is below it. Dog = {}                                   -- 1. function Dog:new()                         -- 2.   newObj = {sound = 'woof'}                -- 3.   self.__index = self                      -- 4.   return setmetatable(newObj, self)        -- 5. end function Dog:makeSound()                   -- 6.   print('I say ' .. self.sound) end mrDog = Dog:new()                          -- 7. mrDog:makeSound()  -- 'I say woof'         -- 8. -- 1. Dog acts like a class; it's really a table. -- 2. function tablename:fn(...) is the same as --    function tablename.fn(self, ...) --    The : just adds a first arg called self. --    Read 7 & 8 below for how self gets its value. -- 3. newObj will be an instance of class Dog. -- 4. self = the class being instantiated. Often --    self = Dog, but inheritance can change it. --    newObj gets self's functions when we set both --    newObj's metatable and self's __index to self. -- 5. Reminder: setmetatable returns its first arg. -- 6. The : works as in 2, but this time we expect --    self to be an instance instead of a class. -- 7. Same as Dog.new(Dog), so self = Dog in new(). -- 8. Same as mrDog.makeSound(mrDog); self = mrDog. ---------------------------------------------------- -- Inheritance example: LoudDog = Dog:new()                           -- 1. function LoudDog:makeSound()   s = self.sound .. ' '                       -- 2.   print(s .. s .. s) end seymour = LoudDog:new()                       -- 3. seymour:makeSound()  -- 'woof woof woof'      -- 4. -- 1. LoudDog gets Dog's methods and variables. -- 2. self has a 'sound' key from new(), see 3. -- 3. Same as LoudDog.new(LoudDog), and converted to --    Dog.new(LoudDog) as LoudDog has no 'new' key, --    but does have __index = Dog on its metatable. --    Result: seymour's metatable is LoudDog, and --    LoudDog.__index = LoudDog. So seymour.key will --    = seymour.key, LoudDog.key, Dog.key, whichever --    table is the first with the given key. -- 4. The 'makeSound' key is found in LoudDog; this --    is the same as LoudDog.makeSound(seymour). -- If needed, a subclass's new() is like the base's: function LoudDog:new()   newObj = {}   -- set up newObj   self.__index = self   return setmetatable(newObj, self) end ---------------------------------------------------- -- 4. Modules. ---------------------------------------------------- --[[ I'm commenting out this section so the rest of --   this script remains runnable. -- Suppose the file mod.lua looks like this: local M = {} local function sayMyName()   print('Hrunkner') end function M.sayHello()   print('Why hello there')   sayMyName() end return M -- Another file can use mod.lua's functionality: local mod = require('mod')  -- Run the file mod.lua. -- require is the standard way to include modules. -- require acts like:     (if not cached; see below) local mod = (function ()   end)() -- It's like mod.lua is a function body, so that -- locals inside mod.lua are invisible outside it. -- This works because mod here = M in mod.lua: mod.sayHello()  -- Says hello to Hrunkner. -- This is wrong; sayMyName only exists in mod.lua: mod.sayMyName()  -- error -- require's return values are cached so a file is -- run at most once, even when require'd many times. -- Suppose mod2.lua contains "print('Hi!')". local a = require('mod2')  -- Prints Hi! local b = require('mod2')  -- Doesn't print; a=b. -- dofile is like require without caching: dofile('mod2')  --> Hi! dofile('mod2')  --> Hi! (runs again, unlike require) -- loadfile loads a lua file but doesn't run it yet. f = loadfile('mod2')  -- Calling f() runs mod2.lua. -- loadstring is loadfile for strings. g = loadstring('print(343)')  -- Returns a function. g()  -- Prints out 343; nothing printed before now. --]] ---------------------------------------------------- -- 5. References. ---------------------------------------------------- --[[ I was excited to learn Lua so I could make games with the Löve 2D game engine. That's the why. I started with BlackBulletIV's Lua for programmers. Next I read the official Programming in Lua book. That's the how. It might be helpful to check out the Lua short reference on lua-users.org. The main topics not covered are standard libraries:  * string library  * table library  * math library  * io library  * os library By the way, this entire file is valid Lua; save it as learn.lua and run it with "lua learn.lua" ! This was first written for tylerneylon.com. It's also available as a github gist. Tutorials for other languages, in the same style as this one, are here: http://learnxinyminutes.com/ Have fun with Lua! --]]


-- 注释语句

--[[
注释段落语句
  ]] --

--引用其他lua文件,不需要加上（.lua）后缀
--require "xx"

--变量不需要定义，可以直接赋值
count = 100  --成员变量
local count = 100  --局部变量

--方法定义
function hello ( ... )
    --打印
    print ( "Hello Lua!" ) ;
    print ( string .format ( ... ) )
end

-- 每一行代码不需要使用分隔符，当然也可以加上
-- 访问没有初始化的变量，lua默认返回nil

-- 调用函数形式
hello ( "你懂的" )

--打印变量的类型
isOK = false
print ( type ( isOK ) )

-- 基本变量类型
a = nil --Lua 中值为nil 相当于删除
b = 10
c = 10.4
d = false
--定义字符串，单引号，双引号都可以的
e = "i am"
d = 'himi'

--两个字符串的连接可以如下形式
stringA = "Hi"
stringB = "mi"
print ( stringA..stringB )

--另外Lua也支持转移字符，如下
print ( stringA.. "\n" ..stringB ) ;

--修改字符串的部分gsub，可以如下形式:(将stringA字符串中的Hi修改为WT)
stringA = string .gsub ( stringA , "Hi" , "WT" )
print ( stringA ) ;

--将字符换成数字tonumber(不转也会自动转)
--将数字换成字符tostring(不转也会自动转)
stringC = "100"
stringC = tonumber ( stringC )
stringC = stringC + 20
stringC = tostring ( stringC )
print ( stringC )

--取一个字符串的长度使用 #
print ( #stringC)

--创建 表
tableA = { }
m = "x"
tableA[m] = 100
m 2 = 'y'
tableA[m 2 ] = 200
print ( tableA[ "x" ].. "\n" ..tableA.y )
--另外表还可以如下形式（从1开始）
tableB = { "4" , "5" , "6" , "7" , "8" }
print ( tableB[ 1 ] )

--算术操作符
c 1 = 10 + 2
c 2 = 10 -2
c 3 = 10 * 2
c 4 = 10 / 2
c 5 = 10 ^ 2
c 6 = 10 % 2
c 7 = -10 + 2
print ( c 1. . "_" ..c 2. . "_" ..c 3. . "_" ..c 4. . "_" ..c 5. . "_" ..c 6. . "_" ..c 7 )

--控制操作
--if then elseif then else end
abc = 10
if  abc = = 10 then
    print ( "v1" )
elseif abc = = 9 then
    print ( "v2" )
else
    print ( "v3" )
end

--for
--从4（第一个参数）涨到10（第二个参数），每次增长以2（第三个参数）为单位
for i = 4 , 10 , 2 do
    print ( "for1:" ..i + 1 )
end
--也可以不制定最后一个参数，默认1的增长速度
for i = 4 , 10 do
    print ( "for2:" ..i + 1 )
end

tableFor = { "himi1" , "himi2" , "himi3" , "himi4" , "himi5" }
for k , v in pairs ( tableFor ) do
    print ( "for3:key:" ..k.. "value:" ..v )
end

--while
w 1 = 20
while true do
    w 1 = w 1 + 1
    if w 1 = = 25 then
        break
    end
end
print ( "whlile:" ..w 1 )

--repeat
    aa = 20
    repeat aa = aa + 2
        print ( "repeat:" ..aa )
    until aa > 28

--关系操作符
--需要注意的是不等于符号 ~=  而不是!=
ax = 10
bx = 20

if ax > bx then
    print ( "GX1" )
elseif ax < bx then
    print ( "GX2" )
elseif ax > = bx then
    print ( "GX3" )
elseif ax < = bx then
    print ( "GX4" )
elseif ax = = bx then
    print ( "GX5" )
elseif ax~ = bx then
    print ( "GX6" )
else
    print ( "GX7" )
end

 

其中主要需要注意的是，判断语句不等于，不再是!= ，在Lua中是~= ，这个要注意。

源码下载地址： http://vdisk.weibo.com/s/wwgnO

 

另外关于一些常见的函数如下详解：

 

--函数详解

--有一个返回值的函数
function funTestBackOne ( aCount )
    local aCount = aCount + 1
    return aCount
end

a = 20
print ( funTestBackOne ( a ) )

--有多个返回值的函数
function funTestBackMore ( )
    return 2 , 3
end

a , b = funTestBackMore ( )
print ( a.. " and " ..b )

--有变长参数的函数
function funTestUnKnow ( ... )
    print ( ... )
end
funTestUnKnow ( a , b , "Himi" )

--闭合函数(一个函数写在另外一个函数内)
function funTest 1 ( ... )
    local d = 12 ;
    d = d + ...
    function funTest 2 ( ... )
        print ( d )
    end
    funTest 2 ( )
end

funTest 1 ( 100 )

 

掌握这些Lua语言基础，基本足够你使用了。

转自：http://blog.csdn.net/xiaominghimi/article/details/8770395