Lua crash course

Following crash course is an extremely condensed extract from the official Lua reference manual. For more details refer to the free Lua Quick Reference e-book, to the Lua website and to the numerous examples contained in the demo scenes.

Lexical conventions

  • Lua is a case sensitive language. "and", "And" or "AND" are not the same.
  • Following are Lua keywords: and break do else elseif end false for function if in local nil not or repeat return then true until while
  • Following strings denote other tokens: + - * / % ^ # == ~= <= >= < > = ( ) { } [ ] ; : , . .. ...
  • Literal strings can be delimited by matching single or double quotes (e.g. 'hello' or "hello")
  • A comment starts with a double hyphen (--) anywhere outside of a string. e.g.:
  • a=4 -- variable a is now 4!

    Types and values

  • Lua is a dynamically typed language which means that variables do not have types; only values do.
  • There are 8 basic types in Lua:
    • nil type of the value nil whose main property is to be different from any other value. It usually represents the absence of a useful value
    • bool values false and true (both nil and false make a condition false; any other value makes it true)
    • number both integer and floating-point numbers (has internally two distinct representations: long integer and double)
    • string arrays of characters (strings may contain any 8-bit character, including embedded zeros)
    • function Lua functions
    • userdata can hold arbitrary C data (corresponds to a block of raw memory)
    • thread independent threads of execution used to implement coroutines
    • table arrays that can hold values of any type except nil

  • Variables

  • There are 3 kinds of variables: global variables, local variables and table fields. Any variable is assumed to be global unless explicitly declared as local
  • Before the first assignment to a variable, its value is nil
  • Square brackets are used to index a table (e.g. value=table[x]). The first value in a table is at position 1 (and not 0 as for C arrays)

  • Statements

  • Relational operators (always result in false or true)
    • == equality
    • ~= negation of equality
    • < smaller than
    • > bigger than
    • <= smaller or equal than
    • >= bigger or equal than
  • Lua allows multiple assignments. The syntax for assignments defines a list of variables on the left side and a list of expressions on the right side. The elements in both lists are separated by commas:
  • x,y,z = myTable[1],myTable[2],myTable[3]
  • If control structure (by example):
  • if value1==value2 then print('value1 and value2 are same!') end
  • For control structure (by example):
  • for i=1,4,1 do -- count from 1 to 4 with increments of 1 print(i) end
  • While control structure (by example):
  • i=0 while i~=4 do i=i+1 end
  • Repeat control structure (by example):
  • i=0 repeat i=i+1 until i==4
  • Table operations (by example):
  • myTable={'firstValue',2,3} -- builds a table with 3 values print(myTable[1]) -- prints the first element in the table table.insert(myTable,4) -- appends the number 4 to the table
  • Concatenation (by example):
  • a='hello' b=' world' c=a..b -- c contains 'hello world'
  • Length operator #:
  • stringLength=#'hello world' tableSize=#{1,2,3,4,5}

    Bitwise operators

  • Lua supports the following bitwise operators:
    • & bitwise AND
    • | bitwise OR
    • ~ bitwise exclusive OR
    • >> right shift
    • << unary bitwise NOT
    • ~ unary bitwise NOT

    Coroutines or threads

  • Coroutines are easily created and resumed with:
  • -- Create a coroutine: corout=coroutine.create(coroutineMain) -- Start/resume a coroutine: if coroutine.status(corout)~='dead' then local ok,errorMsg=coroutine.resume(corout) if errorMsg then error(debug.traceback(corout,errorMsg),2) end end -- The coroutine itself: function coroutineMain() while not sim.getSimulationStopping() do -- some code end end