zoukankan      html  css  js  c++  java
  • lua学习之函数篇

    函数

    1. 函数是对语句和表达式进行抽象的主要机制

    两种用法

    1. 一是可以完成特定的任务,一句函数调用被视为一条语句
    2. 二是以只用来计算并返回特定的结果,视为一句表达式
    print("Hello, World")
    a = math.sin(3) + math.cos(10)
    print(os.date())
    
    
    1. 无论哪种用法都需要将所有参数放到一对圆括号中
    2. 但如果参数是字面字符串或 table 构造式的话,可以放在括号中,也可以不放
    3. 即使在调用函数时没有参数,也必须有一个 () 空括号,如调用 os.date()
    print "Hello, World" -- 等价于 print("Hello, World")
    print {1, 2, 3} -- 等价于 print({1, 2, 3})
    
    function add(a)
        local sum = 0
        for i, v in ipairs(a) do
           sum = sum + v 
        end
        return sum
    end
    b = {1, 2, 3}
    add(b)
    
    1. function 是定义函数的关键字
    2. add 是函数名
    3. a 是函数的形式参数,是函数定义式参数列表中的参数
    4. add(b) 调用这个函数所传入的参数称为实际参数
    5. 调用函数的实际参数的个数可以与函数定义时的形式参数个数不同
    6. lua 会自动调整实参的数量,以匹配参数表的要求,这和多s重赋值类似
    7. 若实参少于形参,多余的形参被初始化为 nil
    8. 若实参多余形参,多余的实参被抛弃
    9. lua 程序既可以使用 以 lua 编写的函数,也可使用 C 语言编写的函数
    function f(a, b)
        return a or b
    end
    f(3) -- a = 3, b = nil
    f(3, 4) -- a = 3, b = 4
    f(3, 4, 5)  -- a = 3, b = 4 ,5 被丢弃了
    

    定义一个全局的计数器

    function intCount(n)
        n = n or 1  -- 赋值一个默认值
        count = count + 1
    end
    

    面向对象式调用函数

    1. o.foo(o, x)
    2. o:foo(x) 等价于 o.foo(o, x)
    3. 冒号操作符使得我们在调用 o.foo 时隐含地将 o 作为函数的第一个参数

    多重返回值

    1. lua 允许函数返回多个结果
    2. 如标准库中的一些预定义函数
    -- 用于在字符串中定位一个模式的函数 string.find
    print(string.find("Hello Lua users", "Lua")) -- 开始的位置 7, 结束的位置 9
    
    1. 在 return 后列出需要返回的所有值即可,用 , 逗号分隔
    -- 查找数组中的最大元素,并返回这个元素的所在位置
    function maximum(a)
        local mi = 1 -- 最大值的索引
        local max = a[mi] -- 最大值
        for i,v  in ipairs(a) do
       		if v > max then
                mi = i
                max = v
            end
        end
        return max, mi
    end
    maximum(a) -- 没有任何反应
    print(maximum({3, 4, 23, 5, 7})  -- 23 3
    print(maximum({3, 4, 23, 5, 7} .. "a") -- 23a
    
    1. 如果将函数调用作为单独的语句执行,lua 会丢弃所有的返回值
    2. 如果将将函数作为表达式的一部分调用,只保留函数的第一个返回值
    3. 只有当函数是一系列表达式中的最后一个元素(或只有一个元素的时候),才会获取所有的返回值

    一系列表达式在 Lua 中的 4 中情况

    1. 多重赋值
    2. 函数调用时传入的实参列表
    3. table 构造式
    4. return 语句

    多重赋值

    1. 在多重赋值中,如果一个函数调用是最后(或仅有)的一个表达式,lua 会保留尽可能多的返回值,用来匹配赋值的变量
    2. 如果一个函数没有返回值或没有返回足够多的返回值,那么 lua 会用 nil 来补充缺失的值
    3. 如果一个函数调用不是一系列表达式中的最后一个元素,就只能返回一个值
    4. 如果一个函数调用作为另一个函数调用的最后一个(或仅有的)实参的时候,第一个函数的所有返回值都会作为实参传递给另一个函数
    function foo0() end
    function foo1() return "a" end
    function foo2() return "a", "b" end
    -- 多重赋值的4种情况
    -- 第一种情况
    x, y = foo2() -- x = "a" , y = "b"
    x = foo2() -- x = "a"
    x, y, z = 10, foo2() -- x = 10, y = "a", z = "b"
    -- 第二种情况
    x, y = foo0() -- x = nil, y = nil
    x, y = foo1() -- x = "a", y = nil
    x, y, z = foo2() -- x = "a", y = "b", z = nil
    -- 第三种情况
    x, y = foo2(), 20 -- x = "a", y = 20
    x, y = foo0(), 20, 30 -- x = nil, y = 20
    -- 第四种情况
    print(foo0()) -- 不会打印任何值
    print(foo1()) -- a
    print(foo2()) -- a, b
    print(foo2(), 20) -- a, 1
    print(foo2() .. "x") -- ax
    

    table 构造式

    1. table 构造式可以完整地接收一个函数调用的所有结果,即不会有任何数量方面的调整
    2. 但这种行为,只有当一个函数调用作为最后一个元素时才会发生
    3. 其他位置上的函数调用总是只产生一个结果值
    function foo0() end
    function foo1() return "a" end
    function foo2() return "a", "b" end
    t = {foo2()} -- t = {"a", "b"}
    t = {foo2(), "x"} -- t = {"a", "x"}
    
    

    return

    1. 将函数调用放入一对圆括号 () 中,使其只返回一个结果
    2. return 语句后面的内容不需要 () 圆括号
    3. 如果强行加上则会使一个多返回值的函数,强制其只返回一个 return(f())
    function foo0() end
    function foo1() return "a" end
    function foo2() return "a", "b" end
    function foo(i)
        if i == 0 then return foo0() 
            elseif i == 1 then return foo1() 
            elseif i == 2 then return foo2() 
    	end
    end
    print(foo(1)) -- a
    print(foo(2)) -- a, b
    print(foo(0)) -- 无返回值
    
    -- () 包裹
    print((foo(1)) -- a
    print((foo(2)) -- a
    print((foo(0)) -- nil 不太懂为什么
    

    unpack 函数

    1. 接收一个数组作为参数
    2. 并从下标 1 开始返回该数组的所有元素
    3. 这个预定义函数由 C 语言编写
    print(unpack{10, 20, 30}) -- 10 20 30
    a, b = unpack{10, 20, 30}  -- a = 10, b = 20
    
    1. 用于泛型调用
    2. 泛型调用就是可以以任何实参来调用任何函数
    -- 调用任意函数 f, 而所有的参数都在数组 a 中
    -- unpack 将返回 a 中的所有值,这些值作为 f 的实参
    f(unpack(a)) 
    f = string.find
    a = {"hello", "ll"}
    f(unpack(a)) -- 3 4 等效于 string.find("hello", "ll")
    

    用 lua 递归实现 unpack

    function unpack(t, i)
        i = i or 1
        if t[i] then
            return t[i], unpack(t, i + 1)
        end
    end
    

    变长参数

    1. lua 中的函数可以接收不同数量的实参
    2. 当这个函数被调用时,它的所有参数都会被收集到一起
    3. 这部分收集起来的实参称为这个函数的「变长参数」
    4. ... 3个点表示该函数接收不同数量的实参
    5. 一个函数要访问它的变长参数时,需要用 ... 三个点,此时 ... 三个点是作为一个表达式使用的
    6. 表达式 ... 三个点的行为类似一个具有多重返回值的函数,它返回的是当前函数的所有变长参数
    7. 具有变长参数的函数也可以拥有任意数量的固定参数
    8. 但固定参数一定要在变长参数之前
    9. 当变长参数中包含 nil ,则需要用 select 访问变长参数
    10. 调用 select 时,必须传入一个固定参数 selector(选择开关) 和一系列变长参数
    11. 如果 selector 为数字 n ,那么 select 返回它的第 n 个可变实参
    12. 否则,select 只能为字符串 "#" ,这样 select 会返回变长参数的总数,包括 nil
    -- 返回所有参数的和
    function add(...)
    	local s = 0
        for i, v in ipairs{...} do -- 表达式{...}表示一个由变长参数构成的数组
           	s = s + v
        end
        return s
    end
    print(add(3, 4, 5, 100)) -- 115
    
    -- 调试技巧 ,类似与直接调用函数 foo ,但在调用 foo 前先调用 print 打印其所有的实参
    function foo1(...)
        print("calling foo:", ...)
        return foo(...)
    end
    
    
    -- 获取函数的实参列表
    function foo(a, b, c) end
    function foo(...)
            local a, b, c = ...
    end
    -- 格式化文本 string.format ,输出文本 io.write
    -- 固定参数一定要在变长参数之前
    function fwrite(fmt, ...)
        return io.write(string.format(fmt, ...))
    end
    fwrite() -- fmt = nil
    fwrite("a") -- fmt = a 
    fwrite("%d%d", 4, 5) -- fmt = "%d%d" , 变长参数  = 4, 5
    
    for i = 1, select('#', ...) do
        local arg = select('#', ...)
        <循环体>
    end
    

    具名参数

    1. lua 中的参数传递机制是具有 「位置性」的
    2. 就是说在调用一个函数时,实参是通过它在参数表中的位置与形参匹配起来的
    3. 第一个实参的值与第一个形参相匹配,依此类推
    4. 定义:通过名称来指定实参
    5. 可将所有的实参组织到一个 table 中,并将这个 table 作为唯一的实参传给函数
    6. lua 中特殊的函数调用语法,当实参只有一个 table 构造式时,函数调用中的圆括号是可有可无的
    os.rename  -- 文件改名,希望达到的效果 os.rename(old = "temp.lua", new = "temp1.lua")
    -- lua 不支持注释的写法
    rename = {old = "temp.lua", new = "temp1.lua"}
    function rename (arg)
        return os.rename(arg.old, arg.new)
    end
    
    x = Window{x = 0, y = 0, width = 300, height = 200, title = "Lua", background = "blue", border = "true"}
    
    -- Window 函数根据要求检查必填参数,或为某些函数添加默认值
    -- 假设 _Window 是真正用于创建新窗口的函数,要求所有参数以正确次序传入
    function Window(options)
    	if type(options.title) ~= "string" then
            error("no title")
        elseif type(options.width) ~= "number" then
            error("no width")
        elseif type(options.height) ~= "height" then
            error("no height")
    	end
        _Window(options.title,
        	options.x or 0 -- 默认值
            options.y or 0 -- 默认值
            options.width, options.height,
            options.background or "white" -- 默认值
            options.border -- 默认值为 false(nil)
        )
        
    
  • 相关阅读:
    关于 iOS 证书,你必须了解的知识
    Spark踩坑记:共享变量
    Python 操作 MySQL 的正确姿势
    【黑客浅析】像黑客一样思考
    利用 Flask+Redis 维护 IP 代理池
    程序员的江湖:从黑木崖到回龙观
    [NM 状态机1] Application状态机详解
    Hadoop 2.0 编译问题小结
    Yarn上的几个问题整理
    Yarn中如何生成状态机图
  • 原文地址:https://www.cnblogs.com/door-leaf/p/12323793.html
Copyright © 2011-2022 走看看