文档章节

Lua_手册_代码版

吃一堑消化不良
 吃一堑消化不良
发布于 2016/04/05 19:48
字数 1460
阅读 91
收藏 11
Lua
-- 单行注释
--[[
    [多行注释]
--]]
 
----------
- 1. 变量 & 控制流
----------
num = 23 -- 数字都是双精度
str = 'aspythonstring' -- 像 Python 一样不可变
str = "aspythonuse" -- 可以双引号
str = [[
        像 Python 的多行注释可用于
        表示多行字符串一样
        方便
    ]]
 
bol = nil -- 未定义;支持垃圾回收
 
-- 缩进只为易读性,像 Matlab 一样以 end 结尾
while num < 50 do
    num = num + 1 -- 没有 ++ 或 += 自增操作符号
end
 
-- IF 条件开关
if num > 40 then
    print('> 40')
elseif s ~= 'aspython' then -- ~= 表示 !=
    io.write('s is not aspython') -- 风骚的标准输出
else
    thisIsGlobal = 5 -- 驼峰式命名
    -- 显示声明局部变量(像 Javascript 一样)
    local line = io.read()
 
    -- .. 作为字符串连接符
    print('凛冬将至' .. line)
end
 
-- 引用未定义变量将返回 nil ,这不是错误
foo = anUnknownVariable  -- 等价于 foo = nil
 
aBoolValue = false
-- 只有 nil 与 false 为逻辑假; 数字 0 与空字串 '' 为真!
if not aBoolValue then print('false') end
 
-- 像 Python 一样运用 'or' 和 'and'
-- 得到 C 语言中 a ? b : c 的效果;需注意 b = false 或 nil 的情况
ans = aBoolValue and 'yes' or 'no'
 
karlSum = 0
for i = 1, 100 do -- 像 Matlab 一样的递增语法,包括两端,如同数学中[1, 100]
    karlSum = karlSum + i
end
 
-- Step 为 2 递减的方式 '100, 1, -2'
for j = 100, 1, -2 then print(j) end
 
-- 综上,范围可表示为 "begin, end [, step]"
 
-- 另一个循环控制
num = 23
repeat
    print('凡人必有一死')
    num = num - 1
until num == 0
 
 
----------
- 2. 函数
----------
function fib(n)
    if n < 2 then return 1 end
    return fib(n - 2) + fib(n - 1)
end
 
-- Javascript 一样的匿名函数与闭包
function adder(x)
    -- 返回一个函数
    -- 闭包内封存 x 值
    return function (y) return x + y end
end
a1 = adder(9)
a2 = adder(36)
print(a1(16))  --> 25
print(a2(64))  --> 100
 
-- 遇到不匹配的列表长度时
-- 过长的变量将被赋予 nil
-- 过长的值将被忽略
 
x, y, z = 1, 2, 3, 4 -- 4 将被忽略
function bar(a, b, c)
    print(a, b, c)
    return 4, 8, 15, 16, 23, 42
end
x, y = bar('zaphod')  --> "zaphod  nil nil"
-- x = 4, y = 8, 其余值被忽略
 
-- 函数与其他类型一样为一等公民
-- 同样有 local/global 之分
-- 像 Javascript 一样定义
function f(x) return x * x end
f = function (x) return x * x end
 
print 'Hello World!' -- 只有一个`字符串`参数时可省略括号
 
----------
- 3. 表(Table) 
----------
-- 表是 Lua 中唯一的复合类型
-- 像 PHP 中的数组或 Javascript 中的 Object 一样
-- 可用作 list/dict/map
 
-- 默认以字符串作为 key
t = {key1 = 'value1', key2 = false}
-- 像 Javascript 一样以 . 取值
print(t.key1) --> "value1"
t.key3 = {} -- 加入新的键值对
t.key2 = nil -- 销毁一组键值对
 
-- 理论上任何非 nil 的变量都可以作为 key
u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
print(u[6.28])  --> "tau"
a = u['@!#'] -- a = 'qbert'
b = u[{}] -- b = nil;像 Javascript 一样 {} 会创建新的对象
          -- 因此不要用蛋疼的 key 值,老老实实用字串或数字
 
-- 同字符串一样,只有一个表作为函数的参数时可以省略括号
-- 为了一个括号增加阅读难度,得不偿失
function h(x) print(x.key1) end
h{key1 = 'Sonmi~451'}  --> "Sonmi~451"
 
for key, val in pairs(u) do  -- 像 Python  一样的键值迭代
    print(key, val)
end
 
-- 像 Javascript 一样的全局作用域 _G
print(_G['_G'] == _G) --> true
 
-- 省略 key 之后即可变身为 list
-- 实际上是以递增自然数为 key
v = {'value1', 'value2', 1.21, 'gigawatts'}
for i = 1, 
#v do  -- 像 Bash 一样,#v 表示列表长度
    print(v[i])  -- 像 Matlab 一样,列表索引从 1 开始
end
 
----------
- 3.1 Metatables & metamethods
----------
-- 元表(metatable)就是表的表,像 Javascript 的原型(prototype)一样
-- 为表重载一些元方法(metamethods)
 
f1 = {a = 1, b = 2}
f2 = {a = 2, b = 3}
-- s = f1 + f2 为错
 
mm = {}
function mm.__add(x, y)
  sum = {}
  sum.a = x.a + y.a
  sum.b = x.b + y.b
  return sum
end
 
setmetatable(f1, mm)
setmetatable(f2, mm)
 
-- 实际调用 f1 的 metatable 中的 __add(f1, f2)
-- 只为 f1 设置元表也可以
s = f1 + f2 -- s = {a = 3, b = 5}
 
-- s2 = s + s 为错,s 未定义元表
 
-- __index 元方法重载表中 key 的提取符号 `.`
defaultFavs = {animal = 'gru', food = 'donuts'}
myFavs = {food = 'pizza'}
setmetatable(myFavs, {__index = defaultFavs})
food = myFavs.food
 
-- Lua 中的值都具有元方法,只有 Table 可以重载
-- 所有元方法如下
 
-- __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)  <fn or a table>  for a.b
-- __newindex(a, b, c)             for a.b = c
-- __call(a, ...)                  for a(...)
 
----------
- 3.2 类风格的 Table 与继承
----------
 
-- 像 Javascript 一样并没有内置 Class
-- 但可以通过 Table `{}` 实现
 
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"
 
-- 1. Dog 像类但实际是 Table
-- 2. Dog:new(...) := Dog.new(self, ...)
-- 3. newObj 作 Dog 的实例
-- 4. self 是 Lua 中默认的参数,在这里 self = Dog
--    继承的时候可以改变
--    self.__index 与 self 的元方法 __index 不是一回事
--    self = {__index = self, metatable = {__index = ...}}
-- 5. setmetatable(newObj, self) 相当于 setmetatable(newObj, {__index = self})
--    赋予实例所有类方法
-- 6. 同 2.
-- 7. mrDog = Dog.new(Dog)
 
-- 继承
LoudDog = Dog:new()
function LoudDog:makeSound()
    s = self.sound .. ' '
    print(s .. s .. s)
end
seymour = LoudDog:new()
seymour:makeSound() --> "woof woof woof"
 
----------
- 4. 模块
----------
 
-- 以下来自文件 mod.lua
local M = {}
 
local function sayMyName()
    print('Hrunkner')
end
 
function M.sayHello()
    print('Why hello there')
    sayMyName()
end
return M
-- 以上
-- 回到主文件
local mod = require('mod') -- 运行 mod.lua 中的代码
-- 操作同下
local mod = (function()
    -- 像 Javascript 一样
    --[[
        mod.lua 中的代码
    ]]--
end)()
 
mod.sayHello() --> "Why hello there"
mod.sayMyName() --> 错!sayMyName() 是 mod.lua 中的局部变量
 
-- require 返回的值将被缓存
-- 即使多次调用 require 被调用文件也只运行一次
 
-- mod2.lua 包含 print("mod2")
local a = require("mod2") --> "mod2"
local b = require("mod2") -- 不输出, 实际为 b = a
 
-- dofile 是不缓存的版本的 require
dofile("mod2") --> "mod2"
dofile("mod2") --> "mod2"
 
-- loadfile 读取文件但不执行
-- 勘误:f = loadfile('mod2'),需加后缀名,否则找不到文件
f = loadfile('mod2.lua')
f() --> "mod2"
 
-- loadstring 读取代码字符串
f = loadstring("print('Lua is cool!')")
f() --> "Lua is cool!"

本文转载自:http://blog.jobbole.com/70480/

共有 人打赏支持
吃一堑消化不良
粉丝 28
博文 188
码字总数 112947
作品 0
浦东
程序员
私信 提问
Fanta/free-programming-books-zh_CN

免费的编程中文书籍索引 免费的编程中文书籍索引,欢迎投稿。 国外程序员在 stackoverflow 推荐的程序员必读书籍,中文版。 stackoverflow 上的程序员应该阅读的非编程类书籍有哪些? 中文版...

Fanta
2016/11/14
0
0
开源电子书

目录 语言无关类 操作系统 智能系统 分布式系统 编译原理 函数式概念 计算机图形学 WEB服务器 版本控制 编辑器 NoSQL PostgreSQL MySQL 管理和监控 项目相关 设计模式 Web 大数据 编程艺术 ...

zting科技
2017/12/11
0
0
免费的编程中文书籍索引【收藏速度】

语言无关类 优质博客 PyTab在线手册中心 ImportNew 廖雪峰的官方网站 程序员博客墙 操作系统 开源世界旅行手册 鸟哥的Linux私房菜 Linux 系统高级编程 The Linux Command Line (中英文版) L...

yonghu86
2015/04/15
0
0
LuaJIT-2.1.0

参照 LuaJIT 官网上文档后,在Windows 10 enterprise 下采用Mingw 成功编译。 特此将2.1.0 beta版与2.0.4稳定版打包成安装版,以备日后使用。 在此免费提供下载连接:LuaJIT解释器 ,并在下载...

水果糖
2016/09/09
109
0
脚本编程语言--Lua

Lua 是一个小巧的脚本语言。作者是巴西人。该语言的设计目的是为了嵌入应用程序中,从而为应用程序提供灵活的扩展和定制功能。 Lua脚本可以很容易的被C/C++代码调用,也可以反过来调用C/C++...

匿名
2008/11/09
120.3K
7

没有更多内容

加载失败,请刷新页面

加载更多

Java单例模式学习记录

在项目开发中经常能遇见的设计模式就是单例模式了,而实现的方式最常见的有两种:饿汉和饱汉(懒汉)。由于日常接触较多而研究的不够深入,导致面试的时候被询问到后有点没底,这里记录一下学习...

JerryLin123
昨天
1
0
VSCODE 无法调试

VSCODE 无法调试 可以运行 可能的原因: GCC 的参数忘了加 -g

shzwork
昨天
3
0
理解去中心化 稳定币 DAI

随着摩根大通推出JPM Coin 稳定币,可以预见稳定币将成为区块链落地的一大助推器。 坦白来讲,对于一个程序员的我来讲(不懂一点专业经济和金融),理解DAI的机制,真的有一点复杂。耐心看完...

Tiny熊
昨天
4
0
5.线程实现

用于线程实现的Python模块 Python线程有时称为轻量级进程,因为线程比进程占用的内存少得多。 线程允许一次执行多个任务。 在Python中,以下两个模块在一个程序中实现线程 - _thread 模块 th...

Eappo_Geng
昨天
3
0
ServiceLoader

创建一个接口文件在resources资源目录下创建META-INF/services文件夹在services文件夹中创建文件,以接口全名命名创建接口实现类 内容me.zzp.ar.d.PostgreSQLDialectme.zzp.ar.d.Hype...

Cobbage
昨天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部