function f(x,y)
  print(x,y)
end

--> f1和f2完全等价，在引用同一个函数
f1 = function(x,y) print(x,y) end
f2 = f1

f "hello"     --> f("hello")
f {a=3,b=4}   --> f({a=3,b=4})

--> 查找序列中最大的值，同时返回该值的索引
function find_max(a)
  local max = a[1]
  local max_val_idx = 1
  for i,v in ipairs(a) do
    if v > max then
      max = v
      max_val_idx = i
    end
  end
  return max, max_val_idx
end

a = {3,10,1,12,5,6}
print(find_max(a))  --> 12    4

function f() return "a", "b", "c" end

-->   变量多重赋值   <--
f()                --> 三个返回值被丢弃
a = f()            --> 后两个返回值被丢弃
a,b = f()          --> 最后一个返回值被丢弃
a,b,c = f()        --> 三个返回值都对应赋值
a,b,c,d = f(),10   --> a="b",b=10,c=nil,d=nil，只获取了f()第一个返回值

-->   作为函数参数   <--
print(f())          --> a b c
print(1,f())        --> 1 a b c
print(f(),1)        --> a 1
print(f().."x")     --> ax

-->   在table构造式中   <--
t = { f() }      --> t = {"a","b","c"}
t = { f(),"d" }  --> t = {"a","d"}

-->   在return中   <--
function ff() return f() end      --> return "a","b","c"
function ff() return 1,f() end    --> return  1, "a","b","c"
function ff() return f(),1 end    --> return "a", 1

-->   在小括号中   <--
print( ( f() ) )    --> a
function




    
 fff() return(f()) end   --> return中的函数调用不要加括号

function f(x,y,z) print(x,y,z) end

f()           --> x = nil, y = nil, z = nil
f(1)          --> x = 1, y = nil, z = nil
f(1,2)        --> x = 1, y = 2, z = nil
f(1,2,3)      --> x = 1, y = 2, z = 3
f(1,2,3,4)    --> x = 1, y = 2, z = 3, 4被丢弃

function f(x) 
  x = x or 0       --> 检查x参数，并设置默认值
  ...
end

function f(x,y,z) return x, y, z end

f(1,2,3)

a = {1,2,3}
f(table.unpack(a))

function f(x,y,z,...)
  print(x,y,z)
  print(string.rep('-',20))
  for k,v in ipairs({...}) do
    print(k,v)
  end
end

f(1,2,3,4,5,6,7,8)    --> ... 接收了4,5,6,7,8

function x(...) print(...) end
x(1,2,3)       --> 1 2 3

--> 接收变长参数，并直接返回参数
function x(...) return ... end

--> 类似Perl的参数处理机制
function f(...)
  local a,b,c = ...
  <code......code>
end

function f(...) return select("#",...) end
f(1,2,3,4)    --> 4， 返回接收到的总参数数量

function f(...) return select("2",...) end
f(1,2,3,4)    --> 2  3  4， 返回从index=2开始剩下的所有参数

function f(...) return select("-3",...) end
f(1,2,3,4)    --> 2  3  4， 返回从倒数第三个开始剩下的所有参数
f(1,nil,nil,4)     --> nil  nil  4， 可以处理nil参数

function f(...)
  for i = 1,select("#", ...) do 
    local arg = select(i, ...)
  end
end

function f(...)
  local args = table.pack(...)
  print(args[1])
  print(args.n)
end

function add(...)
  local sum = 0
  local v = 0
  for i = 1, select("#",...) do
    v = select(i, ...)
    if type(v) ~= "number" then goto continue end
      sum = sum + v
    ::continue::
  end
  return sum
end

function




    
 f(name="long",age=23)
  ...
end

function f(arg)
  return arg.name,arg.age
end

f{name="junmajinlong",age=23}

function f(x) 
  x = x + 1
  return g(x)
end

function f(x) 
  x = x + 1
  return g(x)+1
end

function fact(n)
  if n == 1 then return 1 end
  return n * fact(n-1)
end

function fact(n,m)
  m = m or 1      --> 用户调用时不会传递m参数，所以设置其为1
  if n == 1 then return m end
  m = m * n
  return fact(n-1,m)
end

-->  不使用尾调用   <--
function sum1(n)
  if n == 1 then return 1 end
  return n + sum1(n-1)
end

-->  使用尾调用消除   <--
function sum2(n,m)
  m = m or 1
  if n == 1 then return m end
  m = m + n 
  return sum2(n-1,m)
end

sum2(1000000)      --> 500000500000
sum1(1000000)      --> 栈溢出
--[[
stdin:3: stack overflow
stack traceback:
        stdin:3: in function 'sum1'
        ...
        stdin:3: in function 'sum1'
        stdin:3: in function 'sum1'
        (...tail calls...)
        [C]: in ?
]]

List = {}
List.push = function (l,v) table.insert(l,v) end
List.pop = function (l) return table.remove(l) end

-->  等价定义形式  <--
List = {
  push = function (l,v) table.insert(l,v) end,
  pop = function (l) return table.remove(l) end
}

-->  Lua特意提供的更有意义的等价定义形式  <--
List = {}
function List.push(l,v) table.insert(l,v) end
function List.pop (l) return table.remove(l) end

List.push(List,"a")
List.push(List,"b")
List.push(List,"c")
List.pop(List)     --> c
List.pop(List)     --> b
List.pop(List)     --> a

local f = function(x,y) return x+y end     --> (1)
local function f(x,y) return x + y end     --> (2)

local f
f = function (x,y) return x + y end