Lua学习笔记

 1.  Lua -i main.lua     

     -i 进入交互模式

     -l 加载一个库

     -e  “lua code” 直接在命令行执行lua code

2. 注释

--  This is a line comment
--[[  This block show 
  how to block commenting some lines
]]--

3. 数据数型

8种基本数据类型：nil, boolean, number, string, function, userdata, thread, and table.

 

4. String.

    1）字符串值不能修改，只能生成另一个字符串。

    2）可用#来获取一个字符串的length。

    3）[[  双括号可以

             扩起多行

             长字符串]]。

    4）..  是字符串连接符，不要用+ 

       a =  " one string "
       b =  string.gsub(a,  " one ",  " another ")
        print(#a) 【 10】 
        print b    【another string】

    5)  I/O

          io.read(), we read a line from the standard input.

As write is simpler than read, we will look at it first. The  io.write  function simply gets an arbitrary number of string arguments  and writes them to the current output file. Numbers are converted to strings following the usual conversion rules;  for full control over this conversion, you should use the format  function, from the string library:

    >  io.write( " sin (3) =  ",  math.sin( 3),  " \n ")
       -- > sin (3) = 0.1411200080598672
    >  io.write( string.format( " sin (3) = %.4f\n ",  math.sin( 3)))
       -- > sin (3) = 0.1411

As a rule, you should use  print  for quick- and-dirty programs,  or  for debugging,  and write when you need full control over your output:

    >  print( " hello ",  " Lua ");  print( " Hi ")
       -- > hello   Lua
       -- > Hi
    
    >  io.write( " hello ",  " Lua ");  io.write( " Hi ",  " \n ")
       -- > helloLuaHi

 

5. Table 

a = {}
a[ " x "] =  10 相当于 a.x =  10  注意： a.x   表示 a[ " x "] ，此时x是一个字符串，做索引。
 
a = { x= 10, y = 20} 相当于 a = {};  a.x = 10;  a.y = 20
i =  0; a = {[i+ 0] =  " a ", [i+ 1] =  " b ", [i+ 3] =  " c "}
 
表示数组只需要用数字做为索引即可， a = { " 10 ",  " 20 ",  " 30 "} 相当于 a[ 1] =  " 10; a[2] =  " 20 " ; a[3] =  " 30 " ,
Lua数组下标默认是1开始，要用0的话，可以显示的写成 a= {[ 0] =  " 10 ",  " 20 ",  " 30 "}

 

6. if语句，for循环

  
  
  
  

   
   
   
   
 
    if a< 
    0  
    then  
    
    a =  
    0  
    
 
    end 
   
  
  
  
  

    
    
    
    

     
     
     
     

            
      if a<b  
      then  
      
         
      return a  
      
     
      else  
      
         
      return b  
      
     
      end 
      
     
      
     
      if op ==  
      " 
      + 
      "  
      then 
      
        r = a + b 
      
     
      elseif op ==  
      " 
      - 
      "  
      then 
      
        r = a - b 
      
     
      else 
      
         
      error( 
      " 
      invalid operation 
      ") 
      
     
      end 
     
    
    
    
    

   
   
   
   

    
    
    
    
     
     
     
     

      
      
      
      

        a = {}   
       
 
       for i= 
       1, 
       100[,k]  
       do   
       -- 
        k为步长，可省略不写，默认值为1，若想递减可改为-1 
       
    a[i] = i;  
       
 
       end 
         
      
     
     
     
     
    
    
    
    
     
     
     
     

      
      
      
      
 
       while 条件  
       do 
       
 
       end 
      
     
     
     
     
    
    
    
    
      
      
      
      

       
       
       
       
 
        repeat 
        
 
        until 条件 
       
      
      
      
      
    
    
    
    
7. 操作符
    
    
    
    
    and, or 是短路求值，即当第一个参数能决定表达式的值时，就不再去判断第二个参数。
    
    
    
    
    x = x and v， 意思是如果x非空，那么x = v，x 若为nil/fasle，x = nil/false
    
    
    
    
    x = x or v ，意思是如果x为空，那么x=v，否则 x = x
    
    
    
    
    优先级，from the higher to the lower priority:
    
    
    
    
      
      
      
      

       
       
       
       

                      ^ 
        
              
        not  - (unary) 
        
             *   / 
        
             +   - 
        
             .. 
        
             <   >   <=  >=  ~=  == 
        
              
        and 
        
              
        or 
       
      
      
      
      
    
    
    
    
8. 变量赋值 
    
    
    
    
     
     
     
     

      
      
      
      

        a, b, c =  
       1,  
       2,  
       3        
       -- 
          一次赋值多个变量 
       
a, b, c =  
       0                
       -- 
          b,c会被赋值为nil 
       
a, b, c =  
       0,  
       1,  
       2,  
       3    
       -- 
          3会被丢掉 
       
x, y = y, x                
       -- 
          交换x与y的值 
       
 
       local a =  
       1        
       -- 
         
       local 关键字用来定义局部变量，尽量多的使用局部变量是一种美德 
      
     
     
     
     
    
    
    
    
9. 变长参数 & 泛型for
    
    
    
    
     
     
     
     

      
      
      
      
 
       function add(...) 
       
 
       local s =  
       0 
       
 
       for i, v  
       in  
       ipairs{...}  
       do    
       -- 
        i为index, v 为value 
       
 s = s +v 
       
 
       end  
       
 
       return s 
       
 
       end 
      
     
     
     
     
    
    
    
    
      
      
      
      

       
       
       
       t = {
       
       
       
       10, 
       
       
       
       20, 
       
       
       
       30}
       
       
       
       

       
       
       
       for element 
       
       
       
       in values(t) 
       
       
       
       do
       
       
       
       
    
       
       
       
       print (element)
       
       
       
       

       
       
       
       end
      
      
      
      
    
    
    
    
10. Function.

    
    
    
    
     
     
     
     

      
      
      
      
 
       function new_counter() 
       
     
       local i= 
       0 
       
     
       return  
       function() 
       
            i = i + 
       1 
       
                
       return i 
       
            
       end 
       
 
       end 
      
      
      
      
      
 
      
      
      
      
c1 = new_counter()
      
      
      
      
print(c1()) --> 1
      
      
      
      
print(c1()) --> 2 
     
     
     
     
    
    
    
    
11. 协程(coroutine)
    
    
    
    
1) 协程的四种状态: 挂起(suspended), 运行(running)，死亡（dead)，正常(normal)
    
    
    
    
2) 协程创建后处于挂起状态，需要coroutine.resume(协程名）才能执行。
    
    
    
    
     
     
     
     

      
      
      
      

        co =  
       coroutine.create( 
       function()  
       print( 
       " 
       hi 
       ")  
       end) 
       
 
       print(co)   
       -- 
       >thread:0x8071d98 
       
 
       print( 
       coroutine.status(co))   
       -- 
       >suspended 
       
 
       coroutine.resume(co)    
       -- 
       > hi 
      
     
     
     
     
    
    
    
    
3) 调用coroutine.yield，可让协程挂起。
      
      
      
      

       
       
       
       

         co =  
        coroutine.create(  
        function() 
        
     
        for i =  
        1,  
        10  
        do  
        
         
        print( 
        " 
        co 
        ", i) 
        
         
        coroutine.yield() 
        
     
        end 
        
 
        end 
        
 
        
 
        coroutine.resume(co)   
        -- 
        >co 1 
        
 
        print( 
        coroutine.status(co))   
        -- 
        > suspended 
        
 
        coroutine.resume(co)   
        -- 
        >co 2 
        
 
        coroutine.resume(co)   
        -- 
        >co 3 
        
... 
        
 
        coroutine.resume(co)   
        -- 
        >co 10 
        
 
        coroutine.resume(co)   
        -- 
        > 什么都不打印，返回false 
       
      
      
      
      
    
    
    
    
4)当协程A唤醒协程B时，协程A就处于normal状态。
    
    
    
    
5)coroutine.resume-yield传参
    
    
    
    
     
     
     
     

      
      
      
      
 
       function run_coroutine(thread) 
       
     
       local status, value =  
       coroutine.resume(thread) 
       
     
       return value 
       
 
       end 
       
 
       
 
       function stop_coroutine(x) 
       
     
       coroutine.yield(x) 
       
 
       end 
       
 
       
 
       function inputer() 
       
     
       return  
       coroutine.create( 
       function() 
       
         
       while  
       true  
       do 
       
             
       local line =  
       io.read() 
       
            stop_coroutine(line) 
       
         
       end 
       
     
       end) 
       
 
       end 
       
 
       
 
       function outputer(thread) 
       
     
       return  
       coroutine.create( 
       function() 
       
         
       for line =  
       1,  
       5  
       do 
       
             
       local x = run_coroutine(thread) 
       
            x =  
       string.format( 
       " 
       %5d Enter is %s 
       ", line, x) 
       
            stop_coroutine(x) 
       
         
       end 
       
     
       end) 
       
 
       end 
       
 
       
 
       function main(thread) 
       
     
       while  
       true  
       do 
       
         
       local obtain = run_coroutine(thread) 
       
         
       if obtain  
       then 
       
             
       io.write(obtain,  
       " 
       \n\n 
       ") 
       
         
       else 
       
             
       break 
       
         
       end 
       
     
       end 
       
 
       end 
       
 
       
p = inputer() 
       
f = outputer(p) 
       
main(f) 
      
     
     
     
     
    
    
    
    
. Userdata
    
    
    
    
. Thread