Programming in Lua Functions and Expressions

I The Language
1 Getting Started
1.1 Chunks
1.2 Some Lexical Conventions
1.3 Global Variables
1.4 The Stand-Alone Interpreter
2 Types and Values
2.1 Nil
2.2 Booleans
2.3 Numbers
2.4 Strings
2.5 Tables
2.6 Functions
2.7 Userdata and Threads
3 Expressions
3.1 Arithmetic Operators
3.2 Relational Operators
3.3 Logical Operators
3.4 Concatenation
3.5 Precedence
3.6 Table Constructors
4 Statements
4.1 Assignment
4.2 Local Variables and Blocks
4.3 Control Structures
4.4 break and return
5 Functions
5.1 Multiple Results
5.2 Variable Number of Arguments
5.3 Named Arguments
6 More About Functions
6.1 Closures
6.2 Non-Global Functions
6.3 Proper Tail Calls
7 Iterators and the Generic for
7.1 Iterators and Closures
7.2 The Semantics of the Generic for
7.3 Stateless Iterators
7.4 Iterators with Complex State
7.5 True Iterators
8 Compilation, Execution, and Errors
8.1 Compilation
8.2 C Code
8.3 Errors
8.4 Error Handling and Exceptions
8.5 Error Messages and Tracebacks
9 Coroutines
9.1 Coroutine Basics
9.2 Pipes and Filters
9.3 Coroutines as Iterators
9.4 Non-Preemptive Multithreading
10 Complete Examples
10.1 Data Description
10.2 Markov Chain Algorithm
II Tables and Objects
11 Data Structures
11.1 Arrays
11.2 Matrices and Multi-Dimensional Arrays
11.3 Linked Lists
11.4 Queues and Double Queues
11.5 Sets and Bags
11.6 String Buffers
11.7 Graphs
12 Data Files and Persistence
12.1 Data Files
12.2 Serialization
13 Metatables and Metamethods
13.1 Arithmetic Metamethods
13.2 Relational Metamethods
13.3 Library-De[1]ned Metamethods
13.4 Table-Access Metamethods
14 The Environment
14.1 Global Variables with Dynamic Names
14.2 Global-Variable Declarations
14.3 Non-Global Environments
15 Modules and Packages
15.1 The require Function
15.2 The Basic Approach for Writing Modules
15.3 Using Environments
15.4 The module Function
15.5 Submodules and Packages
16 Object-Oriented Programming
16.1 Classes
16.2 Inheritance
16.3 Multiple Inheritance
16.4 Privacy 156
16.5 The Single-Method Approach
17 Weak Tables
17.1 Memoize Functions
17.2 Object Attributes
17.3 Revisiting Tables with Default Values
III The Standard Libraries
18 The Mathematical Library
19 The Table Library
19.1 Insert and Remove
19.2 Sort
19.3 Concatenation
20 The String Library
20.1 Basic String Functions
20.2 Pattern-Matching Functions
20.3 Patterns
20.4 Captures
20.5 Replacements
20.6 Tricks of the Trade
21 The I/O Library
21.1 The Simple I/O Model
21.2 The Complete I/O Model
21.3 Other Operations on Files
22 The Operating System Library
22.1 Date and Time
22.2 Other System Calls
23 The Debug Library
23.1 Introspective Facilities
23.2 Hooks
23.3 Pro[1]les
IV The C API
24 An Overview of the C API
24.1 A First Example
24.2 The Stack
24.3 Error Handling with the C API
25 Extending Your Application
25.1 The Basics
25.2 Table Manipulation
25.3 Calling Lua Functions
25.4 A Generic Call Function
26 Calling C from Lua
26.1 C Functions
26.2 C Modules
27 Techniques for Writing C Functions
27.1 Array Manipulation
27.2 String Manipulation
27.3 Storing State in C Functions
28 User-De[1]ned Types in C
28.1 Userdata
28.2 Metatables
28.3 Object-Oriented Access
28.4 Array Access
28.5 Light Userdata
29 Managing Resources
29.1 A Directory Iterator
29.2 An XML Parser
30 Threads and States
30.1 Multiple Threads
30.2 Lua States
31 Memory Management
31.1 The Allocation Function
31.2 The Garbage Collector
Index

Getting Started

To keep with the tradition, our rst program in Lua just prints “Hello World”: print(« Hello World »)
If you are using the stand-alone Lua interpreter, all you have to do to run your rst program is to call the interpreter —usually named lua —with the name of the text le that contains your program. If you write the above program in a le hello.lua, the following command should run it: % lua hello.lua As a more complex example, the next program denes a function to compute the factorial of a given number, then asks the user for a number and prints its factorial:

-- defines a factorial function
function fact (n)
if n == 0 then
return 1
else
return n * fact(n-1)
end
end
print("enter a number:")
a = io.read("*number") -- read a number
print(fact(a))

Chunks
Each piece of code that Lua executes, such as a le or a single line in interactive mode, is called a chunk. A chunk is simply a sequence of commands (or statements).
Lua needs no separator between consecutive statements, but you can use a semicolon if you wish. My personal convention is to use semicolons only to separate two or more statements written in the same line. Line breaks play no role in Lua’s syntax; for instance, the following four chunks are all valid and equivalent:
a = 1
b = a*2
a = 1;
b = a*2;
a = 1; b = a*2
a = 1 b = a*2 — ugly, but valid

Some Lexical Conventions
Identiers in Lua can be any string of letters, digits, and underscores, not beginning with a digit; for instance i j i10 _ij
aSomewhatLongName _INPUT
You should avoid identiers starting with an underscore followed by one or more upper-case letters (e.g., _VERSION); they are reserved for special uses in Lua.
Usually, I reserve the identier _ (a single underscore) for dummy variables.
In Lua, the concept of what a letter is dependents on the locale. With a proper locale, you can use variable names such as ndice or ac~ao. However, such names..

…

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Programming in Lua (1.66 MO) (Cours PDF)