Programming in Lua 4th Edition by Roberto Ierusalimschy 8590379868 9788590379867

Programming in Lua 4th Edition by Roberto Ierusalimschy – Ebook PDF Instant Download/Delivery: 8590379868, 9788590379867

Full download Programming in Lua 4th Edition after payment

Product details:

ISBN 10: 8590379868

ISBN 13: 9788590379867

Author: Roberto Ierusalimschy

Lua is spreading more and more throughout different areas of software, from embedded systems and mobile devices to the Web and the Internet of Things. Besides, it has a major role in the game industry, where knowledge of Lua has become an indisputable asset. Lua is the language of choice for anyone who needs a scripting language that is simple, efficient, extensible, portable, and free. Programming in Lua is the official book about the language, providing a solid base to any programmer who wants to use Lua. Authored by Roberto Ierusalimschy, the chief architect of the language, it covers all aspects of Lua 5—from the basics to its API with C. The book is the main source of programming patterns for Lua, with numerous code examples that help the reader to make the most of Lua’s flexibility and powerful mechanisms. Programming in Lua is targeted at people with some programming background, but does not assume any prior knowledge about Lua or other scripting languages. This Fourth Edition updates the book to Lua 5.3 and marks a complete reorganization of the text. Building on his many years of experience teaching Lua, Roberto has restructured the book to present the material in a growing order of complexity, allowing the reader to better absorb the character of the language.

Programming in Lua 4th Table of contents:

I. The Basics

1. Getting Started
   1.1 Chunks
   1.2 Some Lexical Conventions
   1.3 Global Variables
   1.4 Types and Values
   1.5 The Stand-Alone Interpreter
   1.6 Exercises

2. Interlude: The Eight-Queen Puzzle
   2.1 Exercises

3. Numbers
   3.1 Numerals
   3.2 Arithmetic Operators
   3.3 Relational Operators
   3.4 The Mathematical Library
   3.5 Representation Limits
   3.6 Conversions
   3.7 Precedence
   3.8 Lua Before Integers
   3.9 Exercises

4. Strings
   4.1 Literal Strings
   4.2 Long Strings
   4.3 Coercions
   4.4 The String Library
   4.5 Unicode
   4.6 Exercises

5. Tables
   5.1 Table Indices
   5.2 Table Constructors
   5.3 Arrays, Lists, and Sequences
   5.4 Table Traversal
   5.5 Safe Navigation
   5.6 The Table Library
   5.7 Exercises

6. Functions
   6.1 Multiple Results
   6.2 Variadic Functions
   6.3 The Function Table Unpack
   6.4 Proper Tail Calls
   6.5 Exercises

7. The External World
   7.1 The Simple I/O Model
   7.2 The Complete I/O Model
   7.3 Other Operations on Files
   7.4 Other System Calls
   7.5 Exercises

8. Local Variables and Blocks
   8.1 Control Structures
   8.2 Exercises

---

II. Real Programming
9. Closures
9.1 Functions as First-Class Values
9.2 Non-Global Functions
9.3 Lexical Scoping
9.4 A Taste of Functional Programming
9.5 Exercises

10. Pattern Matching
    10.1 The Pattern-Matching Functions
    10.2 Patterns
    10.3 Captures
    10.4 Replacements
    10.5 Tricks of the Trade
    10.6 Exercises

11. Interlude: Most Frequent Words
    11.1 Exercises

12. Date and Time
    12.1 The Function os.time
    12.2 The Function os.date
    12.3 Date-Time Manipulation
    12.4 Exercises

13. Bits and Bytes
    13.1 Bitwise Operators
    13.2 Unsigned Integers
    13.3 Packing and Unpacking Binary Data
    13.4 Binary Files
    13.5 Exercises

14. Data Structures
    14.1 Arrays
    14.2 Matrices and Multi-Dimensional Arrays
    14.3 Linked Lists
    14.4 Queues and Double-Ended Queues
    14.5 Reverse Tables
    14.6 Sets and Bags
    14.7 String Buffers
    14.8 Graphs
    14.9 Exercises

15. Data Files and Serialization
    15.1 Data Files
    15.2 Serialization
    15.3 Exercises

16. Compilation, Execution, and Errors
    16.1 Compilation
    16.2 Precompiled Code
    16.3 Errors
    16.4 Error Handling and Exceptions
    16.5 Error Messages and Tracebacks
    16.6 Exercises

17. Modules and Packages
    17.1 The Function require
    17.2 The Basic Approach for Writing Modules in Lua
    17.3 Submodules and Packages
    17.4 Exercises

III. Lua-isms
18. Iterators and the Generic for
18.1 Iterators and Closures
18.2 The Semantics of the Generic for
18.3 Stateless Iterators
18.4 Traversing Tables in Order
18.5 True Iterators
18.6 Exercises

19. Interlude: Markov Chain Algorithm
    19.1 Exercises

20. Metatables and Metamethods
    20.1 Arithmetic Metamethods
    20.2 Relational Metamethods
    20.3 Library-Defined Metamethods
    20.4 Table-Access Metamethods
    20.5 Exercises

21. Object-Oriented Programming
    21.1 Classes
    21.2 Inheritance
    21.3 Multiple Inheritance
    21.4 Privacy
    21.5 The Single-Method Approach
    21.6 Dual Representation
    21.7 Exercises

22. The Environment
    22.1 Global Variables with Dynamic Names
    22.2 Global-Variable Declarations
    22.3 Non-Global Environments
    22.4 Using_ENV
    22.5 Environments and Modules
    22.6 _ENV and Load
    22.7 Exercises

23. Garbage
    23.1 Weak Tables
    23.2 Memorize Functions
    23.3 Object Attributes
    23.4 Revisiting Tables with Default Values
    23.5 Ephemeron Tables
    23.6 Finalizers
    23.7 The Garbage Collector
    23.8 Controlling the Pace of Collection
    23.9 Exercises

24. Coroutines
    24.1 Coroutine Basics
    24.2 Who Is the Boss?
    24.3 Coroutines as Iterators
    24.4 Event-Driven Programming
    24.5 Exercises

25. Reflection
    25.1 Introspective Facilities
    25.2 Hooks
    25.3 Profiles
    25.4 Sandboxing
    25.5 Exercises

26. Interlude: Multithreading with Coroutines
    26.1 Exercises

IV. The C API
27. An Overview of the C API
27.1 A First Example
27.2 The Stack
27.3 Error Handling with the C API
27.4 Memory Allocation
27.5 Exercises

28. Extending Your Application
    28.1 The Basics
    28.2 Table Manipulation
    28.3 Calling Lua Functions
    28.4 A Generic Call Function
    28.5 Exercises

29. Calling C from Lua
    29.1 C Functions
    29.2 Continuations
    29.3 C Modules
    29.4 Exercises

30. Techniques for Writing C Functions
    30.1 Array Manipulation
    30.2 String Manipulation
    30.3 Storing State in G Functions
    30.4 Exercises

31. User-Defined Types in C
    31.1 Userdata
    31.2 Metatables
    31.3 Object-Oriented Access
    31.4 Array Access
    31.5 Light Userdata
    31.6 Exercises

32. Managing Resources
    32.1 A Directory Iterator
    32.2 An XML Parser
    32.3 Exercises

33. Threads and States
    33.1 Multiple Threads
    33.2 Lua States
    33.3 Exercises
    

People also search for Programming in Lua 4th: 

programming in lua fourth edition online

programming in lua third edition

lua programming for beginners

lua programming youtube

Tags:

Roberto Ierusalimschy,Programming,Lua