Vizualizare sursă pentru „Lua (limbaj de programare)”

{{Infocaseta Limbaj de programare
| name                   = Lua
| logo                   = [[Fișier:Lua-Logo.svg|150px]]
| designer               = [[Roberto Ierusalimschy]]<br /> Waldemar Celes<br /> Luiz Henrique de Figueiredo
| turing-complete        = Da
| influențat_de          =  [[C++]], [[CLU (limbaj de programare)|CLU]], [[Modula-2|Modula]], [[Scheme (limbaj de programare)|Scheme]], [[SNOBOL]]
|influență               =[[Io (limbaj de programare)|Io]]<!--2002-->, [[GameMonkey Script|GameMonkey]]<!--2003-->, [[Squirrel (limbaj de programare)|Squirrel]]<!--2003-->, [[Falcon (limbaj de programare)|Falcon]]<!--2003-->, [[MiniD]]<!--2006-->
| latest_release_version = 5.3.2
| latest_release_date    = {{Start date|df=yes|2015|11|30}}
| latest_preview_version = 5.3.2 RC2
| latest preview date    = {{Start date|df=yes|2015|11|25}}
| licență                = [[Licență MIT]] 
| sistem_de_operare      = [[multiplatformă]]
| paradigmă              = [[programare imperativă|imperativ]], [[limbaj de scripting|scripting]], ([[Programare procedurală|procedural]], [[prototype-based programming|prototype-based]] [[POO|programare orientată pe obiecte]]), [[Programare funcțională|funcțională]]
| tipare                 = dinamică, ''[[Type system#Strong and weak typing|strong]], [[Duck typing|duck]]''
| programming_language = [[ANSI C]]
| dialecte               = [http://metalua.luaforge.net/ Metalua], [http://idle.thomaslauer.com/ Idle], [http://www.nongnu.org/gsl-shell/ GSL Shell]
| implementări           = [http://www.lua.org/download.html Lua], [http://luajit.org/ LuaJIT], [https://code.google.com/p/llvm-lua/ LLVM-Lua], [https://code.google.com/p/lua-alchemy/ Lua Alchemy]
| anul                   = 1993
| file_ext               = .lua
| website                = {{URL|http://www.lua.org/}}
}}

'''Lua''' ({{IPA-en|luːə}}, din {{lang-pt|[[wikt:lua#portugheză|lua]]}} {{IPA-pt|ˈlu.(w)ɐ|}} înseamnă ''[[lună]]''<ref name=luaabout>{{cite web| url = http://www.lua.org/about.html#name| title = About Lua| publisher = Lua.org| accessdate = 2013-06-19}}</ref>) este un [[limbaj de programare]] [[Limbaj de programare multiparadigmă|multiparadigmă]] creat ca limbaj de scripting cu semantică extensibilă. Întrucât e scris în [[ANSI C]], Lua este un limbaj [[multiplatformă]].<ref name=autogenerat1>{{cite web| url = http://www.lua.org/about.html#why| title = About Lua| publisher = Lua.org| accessdate = 2011-08-11}}</ref> Lua are un [[Application programming interface|API]] [[C (limbaj de programare)|C]] relativ simplu.<ref>{{cite web |url=http://www.foreignaffairs.com/articles/139332/yuri-takhteyev/from-brazil-to-wikipedia?page=2 |title=From Brazil to Wikipedia |work=[[Foreign Affairs]] |author=Yuri Takhteyev |date=21 aprilie 2013 |accessdate=25 aprilie 2013}}</ref>

== Exemple de cod ==
Clasicul program „hello world” poate fi scris în modul următor:
<syntaxhighlight lang="lua">
print('Hello World!')
</syntaxhighlight>
El mai poate fi scris astfel:
<syntaxhighlight lang="lua">
io.write('Hello World!\n')
</syntaxhighlight>
sau, după exemplul oferit pe [http://www.lua.org/cgi-bin/demo?hello site-ul web Lua] {{Webarchive|url=https://web.archive.org/web/20160304095806/http://www.lua.org/cgi-bin/demo?hello |date=2016-03-04 }}
<syntaxhighlight lang="lua">
io.write("Hello world, from ", _VERSION, "!\n")
</syntaxhighlight>

[[Comentariu (programare)|Comentarea]] utilizează următoarea sintaxă, similară cu cea a limbajelor [[Ada (limbaj de programare)|Ada]], [[Eiffel (limbaj de programare)|Eiffel]], [[Haskell (limbaj de programare)|Haskell]], [[SQL]] și [[VHDL]]:
<syntaxhighlight lang="lua">
-- Un comentariu în Lua începe cu două cratime și ține până la sfârșitul rândului.

--[[ Comentariile sau șirurile de caractere întinse pe mai multe rânduri
     sunt încadrate de paranteze pătrate duble. ]]

--[=[ Comentarii ca acesta pot avea alte --[[comentarii]] încorporate. ]=]
</syntaxhighlight>

[[Factorial]]ul este implementat ca funcție în exemplul de mai jos:
<syntaxhighlight lang="lua">
function factorial(n)
  local x = 1
  for i = 2,n do
    x = x * i
  end
  return x
end
</syntaxhighlight>

=== Bucle ===
Lua are patru tipuri de [[loop|bucle]]: [[while|<code>while</code>]], <code>repeat</code> (similară cu [[do while|<code>do while</code>]]), [[bucla for|<code>for</code>]] numeric și <code>for</code> generic.

<syntaxhighlight lang="lua">
--condiție = true

while condiție do
  --enunțuri
end

repeat
  --enunțuri
until condiție

for i = first,last,delta do --delta poate fi negativ, permițând buclei să numere crescător sau descrescător
  print(i)
end
</syntaxhighlight>

Bucla <code>for</code> generic:
<syntaxhighlight lang="lua">
for key, value in pairs(_G) do
  print(key, value)
end
</syntaxhighlight>
va itera prin tabelul <code>_G</code> utilizând funcția iterator standard <code>pairs</code>, până va returna <code>nil</code>.
<!-- 
=== Funcții ===
Abordarea funcțiilor de către Lua ca valori de [[first-class function|primă clasă]] este ilustrată în exemplul următor, unde comportamentul funcției ''print'' este modificat:
<syntaxhighlight lang="lua">
do
  local oldprint = print   -- Reține funcția ''print'' curentă ca „oldprint”
  function print(s)        -- Redefinește funcția ''print'', funcția ''print'' obișnuită poate fi încă folosită
    if s == "foo" then
      oldprint("bar")
    else
      oldprint(s)
    end
  end
end
</syntaxhighlight>
Any future calls to <code>print</code> will now be routed through the new function, and because of Lua's [[Scope (programming)#Lexical scoping|lexical scoping]], the old print function will only be accessible by the new, modified print.

Lua also supports [[Closure (computer science)|closures]], as demonstrated below:
<syntaxhighlight lang="lua">
function addto(x)
  -- Return a new function that adds x to the argument
  return function(y)
    --[[ When we refer to the variable x, which is outside of the current
         scope and whose lifetime would be shorter than that of this anonymous
         function, Lua creates a closure.]]
           return x + y
         end
end
fourplus = addto(4)
print(fourplus(3))  -- Prints 7
</syntaxhighlight>
A new closure for the variable <code>x</code> is created every time <code>addto</code> is called, so that each new anonymous function returned will always access its own <code>x</code> parameter. The closure is managed by Lua's garbage collector, just like any other object.

=== Tabele ===
Tables are the most important data structure (and, by design, the only built-in [[composite data type]]) in Lua, and are the foundation of all user-created types. They are conceptually similar to [[associative array|associative arrays in PHP and dictionaries in Python]].

A table is a collection of key and data pairs, where the data is referenced by key; in other words, it's a [[hash table|hashed]] [[Heterogeneity|heterogeneous]] [[associative array]]. A key (index) can be of any data type except nil.  A numeric key of <code>1</code> is considered distinct from a string key of <code>"1"</code>.

Tables are created using the <code>{}</code> constructor syntax:
<syntaxhighlight lang="lua">
a_table = {} -- Creates a new, empty table
</syntaxhighlight>
Tables are always passed by reference:
<syntaxhighlight lang="lua">
a_table = {x = 10}  -- Creates a new table, with one entry mapping "x" to the number 10.
print(a_table["x"]) -- Prints the value associated with the string key, in this case 10.
b_table = a_table
b_table["x"] = 20   -- The value in the table has been changed to 20.
print(b_table["x"]) -- Prints 20.
print(a_table["x"]) -- Also prints 20, because a_table and b_table both refer to the same table.
</syntaxhighlight>

==== As record ====
A table is often used as [[object composition|structure]] (or [[Record (computer science)|record]]) by using [[string (computer science)|strings]] as keys. Because such use is very common, Lua features a special syntax for accessing such fields.
Example:
<syntaxhighlight lang="lua">
point = { x = 10, y = 20 }   -- Create new table
print(point["x"])            -- Prints 10
print(point.x)               -- Has exactly the same meaning as line above
</syntaxhighlight>

==== As namespace ====
By using a table to store related functions, it can act as a namespace.
<syntaxhighlight lang="lua">
Point = {}

Point.new = function(x, y)
  return {x = x, y = y}
end

Point.set_x = function(point, x)
  point.x = x
end
</syntaxhighlight>

==== As array ====
By using a numerical key, the table resembles an [[array data type]]. Lua arrays are 1-based: the first index is 1 rather than 0 as it is for many other programming languages (though an explicit index of 0 is allowed).

A simple array of strings:
<syntaxhighlight lang="lua">
array = { "a", "b", "c", "d" }   -- Indices are assigned automatically.
print(array[2])                  -- Prints "b". Automatic indexing in Lua starts at 1.
print(#array)                    -- Prints 4.  # is the length operator for tables and strings.
array[0] = "z"                   -- Zero is a legal index.
print(#array)                    -- Still prints 4, as Lua arrays are 1-based.
</syntaxhighlight>
The length of a table <math>t</math> is defined to be any integer index <math>n</math> such that <math>t[n]</math> is not <code>nil</code> and <math>t[n+1]</math> is <code>nil</code>; moreover, if <math>t[1]</math> is <code>nil</code>, <math>n</math> can be zero. For a regular array, with non-nil values from 1 to a given <math>n</math>, its length is exactly that <math>n</math>, the index of its last value. If the array has "holes" (that is, nil values between other non-nil values), then <code>#t</code> can be any of the indices that directly precedes a <code>nil</code> value (that is, it may consider any such nil value as the end of the array).<ref>{{cite web|url=http://www.lua.org/manual/5.1/manual.html#2.5.5|title=Lua 5.1 Reference Manual|accessdate=2012-10-16|year=2012}}</ref>

An array of objects:
<syntaxhighlight lang="lua">
function Point(x, y)        -- "Point" object constructor
  return { x = x, y = y }   -- Creates and returns a new object (table)
end
array = { Point(10, 20), Point(30, 40), Point(50, 60) }   -- Creates array of points
print(array[2].y)                                         -- Prints 40
</syntaxhighlight>
Using a hash map to emulate an array normally is slower than using an actual array; however, Lua tables are optimized for use as arrays<ref name=lobject_h_array>{{cite web|url=http://www.lua.org/source/5.1/lobject.h.html#array|title=Lua 5.1 Source Code|accessdate=2011-03-24|year=2006}}</ref> to help avoid this issue.

=== Metatabele ===
Extensible semantics is a key feature of Lua, and the [[metatable]] concept allows Lua's tables to be customized in powerful ways.  The following example demonstrates an "infinite" table.  For any <math>n</math>, <code>fibs[n]</code> will give the <math>n</math><sup>th</sup> [[Fibonacci number]] using [[dynamic programming]] and [[memoization]].
<syntaxhighlight lang="lua">
fibs = { 1, 1 }                                -- Initial values for fibs[1] and fibs[2].
setmetatable(fibs, {
  __index = function(values, n)                --[[ __index is a function predefined by Lua, 
                                                    it is called if key "n" does not exist. ]]
    values[n] = values[n - 1] + values[n - 2]  -- Calculate and memoize fibs[n].
    return values[n]
  end
})
</syntaxhighlight>

=== Object-oriented programming ===
Although Lua does not have a built-in concept of [[class (computer science)|classes]], they can be implemented using two language features: [[first-class function]]s and tables. By placing functions and related data into a table, an object is formed. [[Inheritance (object-oriented programming)|Inheritance]] (both single and multiple) can be implemented via the [[metatable]] mechanism, telling the object to look up nonexistent methods and fields in parent object(s).

There is no such concept as "class" with these techniques; rather, [[prototype-based programming|prototypes]] are used, as in the programming languages [[Self (programming language)|Self]] or [[JavaScript]]. New objects are created either with a [[factory method pattern|factory method]] (that constructs new objects from scratch), or by cloning an existing object.

Lua provides some [[syntactic sugar]] to facilitate object orientation. To declare [[Method (computer science)|member functions]] inside a prototype table, one can use <code>function table:func(args)</code>, which is equivalent to <code>function table.func(self, args)</code>. Calling class methods also makes use of the colon: <code>object:func(args)</code> is equivalent to <code>object.func(object, args)</code>.

Creating a basic [[Vector (geometry)|vector]] object:
<syntaxhighlight lang="lua">
Vector = {}                   -- Create a table to hold the class methods
function Vector:new(x, y, z)  -- The constructor
  local object = { x = x, y = y, z = z }
  setmetatable(object, { __index = Vector })  -- Inheritance
  return object
end
function Vector:magnitude()   -- Another member function
  -- Reference the implicit object using self
  return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end

vec = Vector:new(0, 1, 0)     -- Create a vector
print(vec:magnitude())        -- Call a member function using ":" (output: 1)
print(vec.x)                  -- Access a member variable using "." (output: 0)
</syntaxhighlight>

== Internals ==
Lua programs are not [[interpreted language|interpreted]] directly from the textual Lua file, but are [[compiler|compiled]] into [[bytecode]] which is then run on the Lua [[virtual machine]]. The compilation process is typically transparent to the user and is performed during [[Run time (program lifecycle phase)|run-time]], but it can be done offline in order to increase loading performance or reduce the memory footprint of the host environment by leaving out the compiler.

Like most CPUs, and unlike most virtual machines (which are [[stack machine|stack-based]]), the Lua VM is [[register machine|register-based]], and therefore more closely resembles an actual hardware design. The register architecture both avoids excessive copying of values and reduces the total number of instructions per function. The virtual machine of Lua 5 is one of the first register-based pure VMs to have a wide use.<ref name=lua5impl>{{Cite journal| last1 = Ierusalimschy | first1 = R. | last2 = Figueiredo | first2 = L. H. | last3 = Celes | first3 = W. | title = The implementation of Lua 5.0| journal = J. Of Universal Comp. Sci.| volume = 11| issue = 7| pages = 1159–1176| year = 2005| url = http://www.jucs.org/jucs_11_7/the_implementation_of_lua/jucs_11_7_1159_1176_defigueiredo.html}}</ref> [[Perl 6|Perl]]'s
[[Parrot virtual machine|Parrot]] and [[Android (operating system)|Android]]'s [[Dalvik virtual machine|Dalvik]] are two other well-known register-based VMs.

This example is the bytecode listing of the factorial function defined above (as shown by the <code>luac</code> 5.1 compiler):<ref name=luavm51instr>{{cite web| author = Kein-Hong Man| title = A No-Frills Introduction to Lua 5.1 VM Instructions| year = 2006| url = http://luaforge.net/docman/view.php/83/98/ANoFrillsIntroToLua51VMInstructions.pdf}}</ref>

 function <factorial.lua:1,6> (10 instructions, 40 bytes at 003D5818)
 1 param, 3 slots, 0 upvalues, 1 local, 3 constants, 0 functions
         1       [2]     EQ              0 0 -1  ; - 0
         2       [2]     JMP             2       ; to 5
         3       [3]     LOADK           1 -2    ; 1
         4       [3]     RETURN          1 2
         5       [5]     GETGLOBAL       1 -3    ; factorial
         6       [5]     SUB             2 0 -2  ; - 1
         7       [5]     CALL            1 2 2
         8       [5]     MUL             1 0 1
         9       [5]     RETURN          1 2
         10      [6]     RETURN          0 1

== C API ==
Lua is intended to be embedded into other applications, and accordingly it provides a robust, easy-to-use [[C (programming language)|C]] [[Application Programming Interface|API]]. The API is divided into two parts: the Lua core and the Lua auxiliary library.<ref name="luarefman">{{cite web| url = http://www.lua.org/manual/5.2/| title = Lua 5.2 Reference Manual| publisher = Lua.org| accessdate = 2012-10-23}}</ref>

The Lua API is fairly straightforward because its design eliminates the need for manual [[Reference counting|reference management]] in C code, unlike [[Python (programming language)|Python]]'s API. The API, like the language, is minimalistic. Advanced functionality is provided by the auxiliary library, which consists largely of [[preprocessor]] [[Macro (computer science)|macros]] which make complex table operations more palatable.

=== Stack ===
The Lua C API is [[Stack (data structure)|stack]] based. Lua provides functions to push and pop most simple C data types (integers, floats, etc.) to and from the stack, as well as functions for manipulating tables through the stack. The Lua stack is somewhat different from a traditional stack; the stack can be indexed directly, for example. Negative indices indicate offsets from the top of the stack (for example, &minus;1 is the last element), while positive indices indicate offsets from the bottom.

Marshalling data between C and Lua functions is also done using the stack. To call a Lua function, arguments are pushed onto the stack, and then the <code>lua_call</code> is used to call the actual function. When writing a C function to be directly called from Lua, the arguments are popped from the stack.

=== Example ===
Here is an example of calling a Lua function from C:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <lua.h>
#include <lauxlib.h>

int main(void)
{
    lua_State *L = luaL_newstate();
    if (luaL_dostring(L, "function foo (x,y) return x+y end")) {
        lua_close(L);
        exit(EXIT_FAILURE);
    }

    lua_getglobal(L, "foo");
    lua_pushinteger(L, 5);
    lua_pushinteger(L, 3);
    lua_call(L, 2, 1);
    printf("Result: %d\n", lua_tointeger(L, -1));
    lua_close(L);
    return 0;
}
</syntaxhighlight>

Running this example gives:
<pre>$ gcc -o example example.c -llua
$ ./example
Result: 8
</pre> -->

== Referințe ==
<references />

== Bibliografie ==
;În engleză
* {{cite web | url=http://www.gamedev.net/page/resources/_/technical/game-programming/an-introduction-to-lua-r1932 | title=An Introduction to Lua | publisher=[[GameDev.net]] | date=29 April 2003 | accessdate=3 ianuarie 2013 | author=Matheson, Ash | archive-date=2012-12-18 | archive-url=https://web.archive.org/web/20121218104442/http://www.gamedev.net/page/resources/_/technical/game-programming/an-introduction-to-lua-r1932 | dead-url=yes }}
* {{cite web|url=http://www.onlamp.com/pub/a/onlamp/2006/02/16/introducing-lua.html|title=Introducing Lua|last=Fieldhouse|first=Keith|date=16 February 2006|work=ONLamp.com|publisher=[[O'Reilly Media]]|accessdate=2013-12-29|archive-date=2006-03-12|archive-url=https://web.archive.org/web/20060312124121/http://www.onlamp.com/pub/a/onlamp/2006/02/16/introducing-lua.html|dead-url=yes}}
* {{cite web|url=http://www.ibm.com/developerworks/linux/library/l-lua.html|title=Embeddable scripting with Lua|last=Streicher|first=Martin|date=28 April 2006|work=developerWorks|publisher=[[IBM]]}}
* {{cite journal |last=Quigley|first=Joseph|date=1 June 2007|title=A Look at Lua|journal=[[Linux Journal]]|url=http://www.linuxjournal.com/article/9605}}
* {{cite news|url=http://www.computerworld.com.au/article/260022/a-z_programming_languages_lua/|title=The A-Z of Programming Languages: Lua|last=Hamilton|first=Naomi|date=11 September 2008|work=[[Computerworld]]|publisher=[[IDG]]|access-date=2013-12-29|archive-date=2012-06-12|archive-url=https://web.archive.org/web/20120612025517/http://www.computerworld.com.au/article/260022/a-z_programming_languages_lua/|dead-url=yes}} Interview with Roberto Ierusalimschy.
* {{cite journal |url=http://queue.acm.org/detail.cfm?id=1983083|title=Passing a Language through the Eye of a Needle|last1=Ierusalimschy|first1=Roberto|last2=de Figueiredo|first2=Luiz Henrique |last3=Celes|first3=Waldemar|date=12 May 2011|journal=[[ACM Queue]]|publisher=[[Association for Computing Machinery|ACM]]}} How the embeddability of Lua impacted its design.
* [http://www.lua.org/papers.html Lua papers and theses]

== Legături externe ==
{{wikibooks|Lua Functional Programming}}
{{MediaWiki|Lua}}
* {{Commons category-inline|Lua (programming language)}}
* {{official website|http://www.lua.org/}}
* [http://lua-users.org lua-users.org] {{Webarchive|url=https://web.archive.org/web/20101216084624/http://lua-users.org/ |date=2010-12-16 }} – Community website for and by users (and authors) of Lua
* [http://www.eluaproject.net/en_overview.html eLua – Embedded Lua]
* [http://luaforge.net Projecte în Lua]
* [http://code.google.com/p/squilu/ SquiLu Squirrel modified with Lua libraries]

{{Control de autoritate}}

[[Categorie:Fondări în 1993]]
[[Categorie:Limbaje de programare]]
[[Categorie:Limbaje de scripting]]
[[Categorie:Software liber]]
[[Categorie:Software multiplatformă]]