Lua

Lua
Sprog klasse funktionelt programmeringssprog , objektorienteret programmeringssprog , scriptsprog , multiparadigme programmeringssprog , imperativt programmeringssprog , proceduremæssigt programmeringssprog , prototypeorienteret programmeringssprog [d] , fortolket programmeringssprog , kompileret programmeringssprog , fri software og filformat
Dukkede op i 1993 [2]
Forfatter Roberto Jeruzalimski ,
Valdemar Selish,
Luis Enrique de Figueiredo
Udvikler Robert Jeruzalimsky [1]
Filtypenavn _ .lua[3] [4] ,.luna,.lunaireeller.anair
Frigøre 5.4.4 (26. januar 2022)
Type system dynamisk , stærk , and
Blev påvirket C++ , Clu , Simple Object Language [d] , DEL , Snobol , Modula , Modula-2 og Scheme
påvirket JavaScript
Licens MIT-licens [5] [6]
Internet side lua.org (  engelsk) (  havn)
OS tværplatform [7]
 Mediefiler på Wikimedia Commons

Lua ( lua ,  port.  -  "måne" [8] ) er et scripting programmeringssprog udviklet i Tecgraf ( Computer Graphics Technology Group ) division af det katolske universitet i Rio de Janeiro ( Brasilien ). Sprogtolken er en gratis , open source C -sprogstolk .

Med hensyn til ideologi og implementering er Lua-sproget tættest på JavaScript , især implementerer det også OOP - prototypemodellen , men adskiller sig i Pascal-lignende syntaks og mere kraftfulde og fleksible konstruktioner. Et karakteristisk træk ved Lua er implementeringen af ​​et stort antal softwareenheder med et minimum af syntaktiske midler. Så alle sammensatte brugerdefinerede datatyper ( arrays , strukturer , sæt , køer , lister ) implementeres gennem tabelmekanismen og objektorienterede programmeringsmekanismer , inklusive multipel nedarvning  , ved hjælp af metatables , som også er ansvarlige for overbelastningsoperationer og en række andre funktioner.

Lua er beregnet til brugere, der ikke er professionelle programmører, hvilket resulterer i, at der lægges stor vægt på enkelhed i design og nem læring. Sproget er meget brugt til at skabe replikerbar software (for eksempel er den grafiske grænseflade i Adobe Lightroom -pakken skrevet i den ). Vandt også frem som et programmeringssprog for niveauer og udvidelser i mange spil (inklusive Garry's Mod ) [9] .

Historie

Sproget blev udviklet af Tecgraf-afdelingen (computergrafikteknologigruppe) ved det katolske universitet i Rio de Janeiro i Brasilien, sprogets historie går tilbage til 1993. Sprogets forfattere er Roberto Jeruzalimski , Luiz Henrique de Figueiredo og Waldemar Celes . Lua er frit distribueret, open source i C-sprog .

Som Luis Enrique de Figueiredo bemærkede, er Lua det eneste programmeringssprog udviklet i et udviklingsland, der har modtaget verdensomspændende anerkendelse, hvilket især kom til udtryk i en invitation til HOPL- konferencen [10] .

De historiske forældre til sproget var konfigurations- og databeskrivelsessprogene SOL (Simple Object Language) og DEL (Data-Entry Language) [11] , de blev uafhængigt udviklet hos Tecgraf i 1992-1993 for at tilføje en vis fleksibilitet til to separate projekter (begge var interaktive grafikapplikationer til designbehov hos Petrobras ). SOL og DEL manglede nogen kontrolkonstruktioner, og Petrobras følte et voksende behov for at tilføje fuld programmering til dem.

Som forfatteren af ​​sproget skriver i The Evolution of Lua : [12]

I 1993 var den eneste rigtige konkurrent Tcl , som var specielt designet til at blive indlejret i applikationer. Tcl havde dog en ukendt syntaks, manglede god databeskrivelsesunderstøttelse og kørte kun på Unix -platforme . Vi har ikke overvejet Lisp eller Scheme på grund af deres uvenlige syntaks. Python var stadig i sin vorden. I den gør-det-selv-atmosfære, der dengang herskede hos Tecgraf, var det helt naturligt, at vi besluttede at udvikle vores eget scriptsprog. På grund af det faktum, at de fleste af brugerne ikke var professionelle programmører, måtte sproget undgå indviklet syntaks og semantik. Implementeringen af ​​det nye sprog skulle være let at transportere , da Tecgrafs kunder havde meget forskellige platforme. Endelig, da vi forventede, at andre Tecgraf-produkter også havde brug for et indlejret scriptsprog, skulle det nye sprog følge eksemplet med SOL og leveres som et bibliotek med en C API .

Lua 1.0 blev designet på en sådan måde, at objektkonstruktører, der dengang var lidt anderledes end den nuværende lette og fleksible stil, inkluderede syntaksen for SOL-sproget (deraf navnet Lua: på portugisisk sol  - "sol", lua  - "måne") . Lua-kontrolkonstruktioner er for det meste lånt fra Modula-2 (hvis, mens, gentag/indtil), selvom de også er påvirket af Clu ( parallel tildeling , returværdi med flere funktioner som et enklere alternativ til at sende parametre ved reference eller eksplicitte pointere ), C++ ("Det er en god idé kun at erklære lokale variabler , når du har brug for dem"), Snobol og awk ( associative arrays ). Skaberne af Lua anerkender også, at den enkelte allestedsnærværende datastruktureringsmekanisme i Lisp and Scheme ( sammenkædet liste ) var en stor indflydelse på deres beslutning om at vælge tabeller som den primære datastruktur for Lua [13] .

Versioner af Lua op til 5.0 blev udgivet under en licens svarende til BSD-licensen . Fra version 5.0 og fremefter distribueres Lua under MIT-licensen . Begge licenser er tilladelige og stort set identiske.

Generelle karakteristika

Lua er beregnet til at blive brugt som et selvstændigt scriptsprog eller indbygget i en applikation. Den blev oprindeligt designet til at være enkel og kompakt nok til at passe på en række forskellige platforme og give acceptabel ydeevne. Designet tog også hensyn til kravene om nem læring og muligheden for brug af ikke-professionelle programmører.

Lua er et proceduremæssigt dynamisk skrevet modulsprog med automatisk hukommelsesstyring . Indeholder grundlæggende elementer til at understøtte funktionelle og objektprogrammeringsstile . Lua kan således kaldes et multi-paradigme sprog . De indbyggede parallelle programmeringsværktøjer giver dig mulighed for at skrive flertrådede programmer ved hjælp af kun sprogværktøjer uden at referere til operativsystemets API eller eksterne biblioteker. Da Luas hovedformål er inlining, har den effektiv interoperabilitet på tværs af sprog, primært fokuseret på at kalde C -biblioteker og arbejde i et C-miljø.

Sproget understøtter et lille antal indbyggede datatyper: booleans, tal, strenge, funktioner, streams. Der er ingen typiske kombinerede datastrukturer såsom arrays , sets , lists og records , i stedet for dem alle bruges én grundlæggende Lua-struktur, tabellen (se nedenfor). En separat type userdataer designet specifikt til lav-niveau programmering og dataudveksling med ekstern kode på andre sprog. Funktioner i Lua er førsteklasses objekter og kan tildeles og videregives som parametre. Lukninger er understøttet, det er muligt at oprette funktioner af højere ordrer. Objektsystemet er prototypisk, der er ingen eksplicit understøttelse af arv , men det implementeres let ved hjælp af metatables .

Generelt sigter Lua mod at levere fleksible metafunktioner, der kan udvides efter behov, snarere end at levere et sæt funktioner, der er specifikke for et bestemt programmeringsparadigme. Som et resultat er det underliggende sprog enkelt og nemt at tilpasse til de fleste applikationer. Ved at tilbyde et minimalt sæt grundlæggende faciliteter, forsøger Lua at finde en balance mellem magt og størrelse.

Syntaks

Luas syntaks er for det meste bygget på sent Pascal-lignende sprog som Modula-2 eller Oberon . Tekstindtastningsformatet er gratis, kommandoer i programteksten er adskilt af eventuelle mellemrumstegn. Det er tilladt, men ikke påkrævet, at bruge semikolon til at adskille operationer.

I et interview med Robert Jeruzalimski bemærkede han, at Lua-syntaksen var et kompromis, han måtte indgå for at gøre det lettere for ikke-professionelle programmører at lære sproget. Han beskrev syntaksen som "temmelig ordrig", og bemærkede, at han personligt ville have foretrukket en mere kortfattet notation [10] .

Ordforråd

Sprogets hovedalfabet er engelsk, tegn på andre sprog kan bruges i strenge bogstaver. Identifikatorer kan bestå af bogstaver, tal og understregninger, men kan ikke starte med et tal eller matche et af søgeordene. Sprogguiden anbefaler ikke at bruge identifikatorer, der begynder med en understregning, da sådanne identifikatorer bruges til systemformål.

Sproget skelner mellem store og små bogstaver, alle søgeord er skrevet med små bogstaver, identifikatorer, der kun adskiller sig i tilfælde af bogstaver, betragtes som forskellige. Følgende 22 nøgleord kan ikke bruges til navne [14] :

og bryde gør andet elseif end false goto for function if in local nil not eller gentag returner derefter sand indtil mens

Kommentarer

Kommentarer bruger følgende syntaks, der ligner Ada , SQL og VHDL :

-- En simpel enkeltlinjekommentar i Lua starter med et dobbelt minus og fortsætter til slutningen af ​​linjen. dim = { "en" , "to" , "tre" } -- En linjekommentar behøver ikke at starte i begyndelsen af ​​en linje -- den kan følge andre sprogkonstruktioner -- for at forklare dem. --[[En kommentar med flere linjer begynder med to på hinanden følgende åbne firkantede parenteser efterfulgt af to minusser og fortsætter gennem to på hinanden følgende afsluttende firkantede parenteser. Ligesom her: ]] -- En interessant effekt kan opnås ved at kombinere inline og multi-line kommentarer: --[[ For at fjerne kommentarer til koden nedenfor er det nok at tilføje et mellemrum i denne linje mellem minusser og parenteser. for i=1,#dim do print(dim[i]) end -- Hvis der tilføjes et mellemrum mellem minustegn og parentes ovenfor, så --]] -- her bliver slutningen af ​​flerlinjekommentaren til en normal linje

Datatyper

Lua er et sprog med implicit dynamisk datatypedefinition . En sprogvariabel kan indeholde værdier af enhver type. Alle værdier i Lua kan gemmes i variabler, bruges som argumenter til funktionskald og returneres som et resultat af deres udførelse.

Der er otte hovedtyper i Lua:

  • nul (udefineret)
  • boolsk (boolsk)
  • nummer (numerisk)
  • streng _
  • funktion (funktion)
  • brugerdata (brugerdata)
  • tråd (tråd)
  • bord (bord)

nil  er værditypen nil [tom værdi], hvis hovedegenskab er at være forskellig fra alle andre værdier og angive fraværet af en brugbar værdi.

Den boolske type inkluderer værdierne falsk (falsk) og sand (sand).

Taltypen omfatter normalt reelle tal (dobbelt). I de første versioner af Lua blev heltal ikke adskilt i en separat type; denne beslutning er motiveret af det faktum, at den reelle repræsentation giver dig mulighed for nøjagtigt at repræsentere en ret bred vifte af heltal. Fra version 5.3 er muligheden for eksplicit at definere et heltals- eller reelt talsformat blevet tilføjet. Den interne repræsentation af tal kan ændres, når tolken bygges.

Strengtypen angiver tegnarrays . Lua-strenge kan indeholde et hvilket som helst 8-bit tegn, inklusive nul ('\0'). Strenge er uforanderlige. Streng bogstaver kan skrives i enkelte eller dobbelte anførselstegn, servicetegn er placeret i dem i standard C-notation med en førende omvendt skråstreg. Multiline literaler er afgrænset af to på hinanden følgende åbnings- og to på hinanden følgende afsluttende firkantede parenteser.

Der er ingen Unicode-understøttelse indbygget i sproget, selvom brugen af ​​UTF-8-tegn i strengliteraler er tilladt, og selve UTF-8-repræsentationssystemet giver dig mulighed for at indtaste, udskrive og delvist behandle strenge i denne kodning ved hjælp af standard systemværktøjer . Nylige versioner af Lua inkluderer utf8-biblioteket, som giver mere avanceret understøttelse af UTF-8, og der er tredjepartsbiblioteker, der giver værktøjer til at arbejde med Unicode-strenge i forskellige kodninger.

Funktioner i Lua er fuldgyldige objekter, der kan tildeles, overføres som en parameter til en funktion og returneres som en af ​​værdierne. Trådtypen har koroutiner, brugerdatatypen er designet til at repræsentere eksterne data modtaget eller leveret fra/til kode på et andet sprog (hovedsageligt C/C++).

Operationer

Opgave Tildelingsoperatoren er symbolet =. Ligesom scriptsprog som Perl , Python , Ruby og Icon , tillader samtidig tildeling . I det enkleste tilfælde giver dette dig mulighed for at skrive udtryk som: x , y = y , x I modsætning til for eksempel Go er paralleltildeling i Lua meget liberal, den kræver ikke, at antallet af variabler nøjagtigt matcher antallet af værdier. Hvis der er flere værdier end variabler, så kasseres de sidste værdier; hvis der er færre værdier, får de sidste variable på listen værdien nul. Sammenligninger og logiske operatorer Sammenligningsoperatorer: <, >, <=, >=, ==, ~= (de sidste to betyder sammenligning for henholdsvis lighed og ulighed). Sammenligninger for lighed og ulighed gælder for enhver datatype, andre - kun for strenge og tal. Logiske operatorer: and, or, not - logiske henholdsvis "og", "eller" og "ikke" kan anvendes på værdier af enhver type og returnerer sand eller falsk. I parametrene for disse operationer betragtes værdierne nul og falsk som falske, alle andre værdier er sande. I modsætning til C og en række andre sprog repræsenterer selv et numerisk nul (0) eller en tom streng ("") en "sand" værdi i form af logiske operatorer. Evaluering af binære logiske operatorer udføres traditionelt indtil resultatet er bestemt, hvor det sidst evaluerede underudtryk returneres som resultatet. Derfor kan de bruges som en ternær operator ?:i C: -- ligner r = (a < b)? f(a): f(b); i C, r = ( a < b ) og f ( a ) eller f ( b ) -- vil r få værdien af ​​funktionen f() fra den mindste af de to værdier a og b, -- forudsat at f(a) er ikke er nul eller falsk. Aritmetiske operatorer + - tilføjelse; - - subtraktion; * - multiplikation; / - division; - - unær minus ; % - resten af ​​divisionen; ^ - eksponentiering.

Alle aritmetiske operatorer understøtter rigtige operander, hvilket giver forudsigelige resultater. Returnerer for eksempel x^0.5kvadratroden af x​​, x^(-1/3) den reciproke af terningroden af x​​. Operatoren %er defineret af: a % b = a - math.floor(a / b) * b, hvor funktionen math.floor()evalueres til den heltallige del af sit argument. For heltalsargumenter er resultatet ganske normalt. For et reelt udbytte skal du huske på, at operationen ikke udfører nogen yderligere afrunding eller kassering af brøkdelen, så resultatet beholder brøkdelen af ​​dividenden. For eksempel vil det math.pi % 2ikke returnere 1, men 1.1415926535898. Denne implementering giver nogle ekstra funktioner. For eksempel, for at afkorte xtil tre decimaler, er det nok at tage udtrykketx - x % 0.001

Tabeller

En tabel i Lua er en dynamisk heterogen associativ array , det vil sige et sæt par af " ключ-значение". Nøgler kan være værdier af enhver Lua-type undtagen nil. Nøgler kan også være Lua-literaler (identifikatorer). At skrive niltil et tabelelement svarer til at slette dette element.

Tabeller er den eneste sammensatte datatype i Lua. De er grundlaget for alle brugerdefinerede datatyper såsom strukturer , arrays , sæt og andre:

-- Generel tabel: tom = {} -- Tom tabel tom [ 1 ] = "første" -- Tilføjelse af element med heltalsindeks tomt [ 3 ] = "anden" -- Tilføjelse af element med heltalsindeks tomt [ "tredje" ] = "tredje" -- Tilføj element ved strengindeks tomt [ 1 ] = nul -- Fjern element fra tabel -- Klassiske array-strenge indekseres som standard med heltal startende fra 1 dage1 = { "mandag" , "tirsdag" , "onsdag" , "torsdag" , "fredag" , "lørdag" , "søndag" } -- Array med vilkårlige indekseringsdage2 = { [ 0 ] = "Søndag" , [ 1 ] = "Mandag" , [ 2 ] = "tirsdag" , [ 3 ] = "onsdag" , [ 4 ] = "torsdag" , [ 5 ] = "fredag" , [ 6 ] = "lørdag" } -- Optegnelse (struktur) - værdier af forskellige typer er indekseret efter bogstavelig person = { tabnum = 123342 , -- Personalenummer fio = "Ivanov Stepan Vasilyevich" , -- Fulde navn post = "værktøjsmager" , -- Stillingsløn = 25800,45 , -- Løn sdate = "10/23/2013" , -- Ansat dato bdate = " 08/08/1973" } -- Fødselsdato pfio = person . fio --Reference til strukturelement. -- Sæt-indekser bruges til at gemme værdier workDays = {[ "mandag" ] = sand , [ "tirsdag" ] = sand , [ "onsdag" ] = sand , [ "torsdag" ] = sand , [ "fredag" " ] = sand } arbejdsdage [ "lørdag" ] = sand -- Føj lørdag til antallet af arbejdsdage arbejdsdage [ " onsdag" ] = nul -- Vi arbejder ikke længere om onsdagen -- Tjek om d er en arbejdsdag hvis workDays [ d ] så udskriv ( d .. " - work day " ) else print ( d .. " - day off " ) end

Multisæt (sæt, der kan indeholde mere end én forekomst af det samme element) implementeres på samme måde som det sidste eksempel, kun værdierne er ikke logiske, men heltal - tællere for antallet af tilsvarende elementer i sættet. Sammenkædede lister kan repræsenteres som arrays af to-element arrays, der indeholder en værdi og en reference til det næste element. Multidimensionelle arrays kan implementeres som arrays af arrays. Mere komplekse strukturer såsom køer, grafer, netværk implementeres også på basis af tabeller, den specifikke implementeringsmetode bestemmes af opgaven.

Lukninger

Lua støtter konceptet med lukninger , for eksempel:

funktion makeaddfunc ( x ) - Returnerer en ny anonym funktion , der tilføjer x til sin argumentreturfunktion ( y ) - Når vi henviser til en variabel x, der er uden for det aktuelle omfang - og hvis levetid er mindre end denne anonyme funktion - - - Lua skaber en lukning. return x + y end end plustwo = makeaddfunc ( 2 ) -- dvs. plustwo = funktion(y) return 2 + y end print ( plustwo ( 5 )) -- Printer 7

Hver gang der kaldes makeaddfunc, oprettes en ny lukning for variablen x, så hver returneret anonym funktion vil referere til sin egen parameter x. Som ethvert andet Lua-objekt styres en luknings levetid af skraldeopsamleren.

Midler og metoder til programmering

Metatables

Den metatable mekanisme giver mange af de funktioner, som andre sprog giver ved at introducere separate syntaktiske mekanismer. Metatabeller er efter struktur almindelige Lua-tabeller, underlagt alle sprogets regler og begrænsninger. Deres ejendommelighed ligger i deres anvendelse. Metatabellen gemmer yderligere metadata for typer og objekter, det vil sige information om de parametre og funktioner, der er knyttet til dem. Oplysningerne gemt i metatables bruges af Lua-fortolkeren, deres brug giver dig mulighed for at ændre eller udvide funktionaliteten af ​​programobjekter.

En metatable i Lua kan associeres med en værdi af enhver type. Skalære datatyper (alle undtagen brugerdata og tabeller) har fælles metatabeller for hver type. Tabellerne og værdierne af en type userdatahar individuelle metatable referencer i hver instans. Ændring af metatables af alle typer undtagen tabeller kan kun ske gennem ekstern C-kode. Kun tabel metatables er tilgængelige direkte fra Lua.

En Lua-tabel, der er oprettet fra bunden, har ikke en metatable (dens metatable reference er nul). Men en metatable for det kan oprettes til enhver tid eller fås fra en anden tabel. Den indbyggede funktion getmetatable(t)returnerer metatablen af ​​tabel t, og funktionen setmetatable(t, m)indstiller tabel t til metatable m.

For metatables er der dokumenteret et sæt felter, som kan bruges af sprogtolken. For at angive disse felters særlige rolle er der vedtaget en særlig navngivningsregel for dem: deres identifikatorer begynder med to understregninger. Nogle af disse felter indeholder information om specifikke egenskaber for det objekt, som metatablen refererer til. For eksempel kan indstillingen __mode, når den er givet, gøre en tabel svag , det vil sige en tabel, hvis objektreferencer alle er svage referencer . Men værdierne af de fleste af de mulige metatable felter er de såkaldte metamethods , det vil sige referencer til funktioner, som tolken kalder under visse betingelser. Den generelle logik ved at bruge metametoder af fortolkeren er som følger: når fortolkeren støder på en operation i programmet, der ikke er defineret for operandobjektet, får den adgang til den metatable, der er knyttet til operanden, finder den tilsvarende metametode i den og kalder den.

--[[ Opret additionsoperation for tabeller ]] -- Operander t1 = { 1 , 2 , 3 } t2 = { 10 , 20 , 30 } -- Opret metatable mt = {} -- Skriv metametode "__add" mt til metatable . __add = funktion ( a , b ) lokal res = {} for k i par ( a ) do res [ k ] = a [ k ] + b [ k ] ende retur res end -- Bind metatable til tabel t1 setmetatable ( t1 , mt ) -- Tabeladdition er nu en gyldig operation t3 = t1 + t2 -- join metatable med t3 med metamethod __tostring setmetatable ( t3 , { __tostring = function ( t ) local res = " \n " for _ , v i par ( t ) do res = res .. tostring ( v ) .. "-" end return res .. " \n " end }) -- Dette vil udskrive: "11-22-33-" for _ , v i ipairs ( t3 ) do io.write ( v , "," ) end print ( tostring ( t3 )) -- udskriver "11,22,33,"

Lua understøtter metametoder til alle aritmetiske og sammenligningsoperationer, så de kan bruges til at implementere aritmetik for alle objekter, der er oprettet af programmøren. Ud over de standard, kan du bruge de såkaldte "bibliotek"-metametoder, som ikke understøttes af kernen af ​​sproget, men af ​​specifikke biblioteker. I eksemplet ovenfor er dette en metametode, der __tostringunderstøttes af strengbiblioteket; denne metode konverterer tabellen til en streng.

Feltet er af største interesse __index. Det kaldes, når tolken forsøger at læse et tabelelement, men ikke finder det. Et felt __indexkan referere til enten en tabel eller en metode. I det første tilfælde vil tolken, der ikke finder den ønskede værdi i hovedtabellen, lede efter den i tabellen __index. I den anden, i stedet for at få adgang til tabellen, vil denne metode blive kaldt. Ved at specificere tabeller eller metametoder for et givet felt kan Lua implementere nedarvning, skjule objektdata, spore operationer på tabeldata og meget mere.

Objektorienteret programmering

Grundlaget for OOP i Lua er tabeller. I princippet er en tabel et objekt i OOP-forstand, da den kan have felter navngivet med identifikatorer og lagre vilkårlige værdier (objektegenskaber) og funktioner til at implementere objektets adfærd (objektmetoder) i disse felter. Noget af det syntaktiske sukker leveret af Lua gør beskrivelse og håndtering af objekter mere velkendte for programmører, der har erfaring med traditionelle OOP-sprog. Der er intet begreb om " klasse " i Lua, derfor er et separat objekt beskrevet, og alle felter og metoder refererer specifikt til det. Egenskaber beskrives på samme måde som tabelelementer med identifikationsnøgler, metoder beskrives som funktionsfelter. Ligesom den klassiske Oberon indeholder metodebeskrivelsen en eksplicit indikation i den første parameter af den såkaldte "receiver" - en parameter, der, når en metode kaldes, refererer til det objekt, som den kaldes for. Men ud over standardreferencen til et tabelfelt gennem en prik, som kræver eksplicit at specificere modtageren i metodekaldet, understøtter Lua en ekstra syntaks: når metodehovedet er skrevet i formen " Объект:метод" i metodekaldet eller beskrivelsen , så er modtageren ikke angivet. Samtidig er den i selve metoden stadig tilgængelig under navnet self:

-- Objektkonto = { -- Objekt "konto" id , navn , saldo = 0 , -- objektegenskaber: antal, navn, saldo kredit = funktion ( selv , v ) -- metode "udgift" - beskrivelse inde i objektet med eksplicit med angivelse af modtageren, hvis selv . balance < v derefter fejl "Utilstrækkelig balance" end self . balance = selv . balance - v end } funktion Konto : debet ( v ) -- "indgående" metode - ekstern stenografibeskrivelse (selv ikke specificeret) self . balance = selv . balance + v ende Konto . debet ( Konto , 10000 ) -- metode kaldet lang version Konto : kredit ( 5000 ) -- metode kaldet kort version

Nedarvning, herunder multipel nedarvning, implementeres ved hjælp af metatables og metamethods. Ved hjælp af metametoder kan du også implementere dataskjul og kontrolleret adgang til tabelobjektets felter. Hvis man sammenligner denne tilgang med andre sprog, hvor alt ovenstående er implementeret ved hjælp af specielle sprogværktøjer, kan man se, at Lua-implementeringen er mere kompliceret og kræver mere omhyggelig kodning, men giver mere fleksibilitet og forenkler tolken.

Kodeeksempler

Klassisk program " Hej, verden!" » i Lua ser sådan ud:

print ( "Hej verden!" )

Faktoriel  er et eksempel på en rekursiv funktion:

funktion factorial ( n ) hvis n == 0 returnerer 1 ellers returnerer n * factorial ( n - 1 ) end end _

Sløjfe med tæller :

for i = 1 , 5 do -- instruktioner/operationer slutter

Arbejde med funktioner som førsteklasses objekter er demonstreret i følgende eksempel, som ændrer udskriftsfunktionens adfærd:

lav lokal oldprint = print -- Gem nuværende printfunktion som oldprint funktion print ( r ) -- Omdefiner print funktion hvis s == " foo " så oldprint ( " bar " ) ellers oldprint ( s ) end end end

Ethvert fremtidigt opkald printvil nu blive omdirigeret til den nye funktion, og takket være Luas støtte til leksikalsk kontekst vil den gamle printfunktion kun være tilgængelig via den nye, ændrede printfunktion. Lua understøtter også lukninger , som beskrevet ovenfor i det relaterede afsnit.

Et centralt træk ved Lua er dens udvidbare semantik, og den metatable mekanisme giver en masse muligheder for at tilpasse unik adfærd til Lua-tabeller. Følgende eksempel viser en "uendelig" tabel. For enhver vil give det -th Fibonacci-nummer ved hjælp af memoization . fibs[n]

fibs = { 1 , 1 } -- Startværdier for fibs[1] og fibs[2]. setmetatable ( fibs , { __index = funktion ( navn , n ) -- Kald funktion hvis fibs[n] ikke eksisterer. navn [ n ] = navn [ n - 1 ] + navn [ n - 2 ] -- Beregn og gem fibs [ n] .returnavn [ n ] ende })

Lua giver dig også mulighed for at bruge logiske operatorer andtil at orindtaste ternære konstruktioner , som for eksempel i C# , eller til at henvise til et af de eksisterende objekter.

do local num = tonumber ( io.read ()) -- Skriv til en variabel informationen indtastet fra konsollen og konverter den til en heltal type print ( num == 1 og "Du indtastede det korrekte tal" eller "Du indtastede forkert tal" ) -- Hvis talvariablen er lig med 1, så vil teksten efter og blive vist i konsollen, i alle andre tilfælde efter eller slutning

Få adgang til en eksisterende tabel og få værdien ved det første indeks:

do local tbl = nil local tbl2 = { 1 } print ( ( tbl or tbl2 )[ 1 ] ) -- Nummer 1 udskrives fordi tabel tbl2 har denne værdi ved indeks 1 slutningen

Kaldning af en funktion fra en af ​​de eksisterende tabeller:

gør lokal tbl = nul lokal tbl2 = {} tbl2 . DoSomething = funktion () print ( "Gør noget" ) ende ( tbl eller tbl2 ). DoSomething () ende

Implementering

Som mange fortolkede programmeringssprog har Lua -implementeringen en separat compiler fra kildesprog til eksekverbar bytekode og en virtuel maskine til at udføre den genererede bytekode. Desuden er bytekoden ikke kommandoerne fra stakmaskinen, men kommandoerne fra en bestemt virtuel processor med flere registre, hvilket øger effektiviteten af ​​udførelsen. Standard Lua virtuelle maskine bruger hukommelsesallokering med garbage collection (svarende til Java eller .NET).

Lua bruger en enkelt strengpulje , hvilket reducerer hukommelsesomkostningerne ved lagring af strenge.

Til tidskritiske opgaver er der en JIT - Lua compiler  - LuaJIT [15] . Der er også udviklet compileren llvm-lua [16] , som genererer kode til den virtuelle LLVM -maskine , som giver mulighed for efterfølgende kompilering til en meget effektiv maskinkode til processorer med forskellige arkitekturer.

Brug

Det bruges i øjeblikket i forskellige projekter, hvor det er påkrævet at indbygge et ret hurtigt og nemt at lære scripting programmeringssprog - for eksempel i spiludvikling , hvor Lua ofte bruges som et lag mellem spilmotoren og data til script. objekters adfærd og interaktion. På grund af dens kompakthed er den også anvendelig i bærbare enheder, især en af ​​Texas Instruments grafiske regnemaskiner bruger et sprog i stedet for BASIC , traditionelt for denne klasse af enheder .

Spil

LucasArts var den første til at introducere Lua -sproget i udviklingen af ​​computerspil, begyndende med spillet Grim Fandango [17] . Forfatterne af sproget i deres rapport på HOPL- konferencenhuske på, at de i januar 1997 modtog en besked fra Bret Mogilefsky, hovedudvikleren af ​​Grim Fandango, hvor han skrev, at efter at have læst om sproget i en artikel fra 1996 i Dr. Dobb's Journal planlægger han at erstatte deres hjemmelavede scriptsprog SCUMM med Lua [18] . Som et resultat skabte han GrimE -spilmotoren , som også bruges af en senere quest fra LucasArts - Escape from Monkey Island .

I 2003 rangerede en GameDev.net- undersøgelse Lua som det mest populære scriptsprog til spiludvikling [9] .

Et eksempel på et spil programmeret med Lua er World of Warcraft [19] [20] . Niveauerne i puslespillet Enigma [21] er beskrevet på Lua -sproget .

En række gratis spilmotorer er tilgængelige, programmerbare i Lua, såsom Defold [22][ betydningen af ​​det faktum? ] , LÖVE arkademotoren [23] [24] , spildesigneren Novashell [25] og den quest - orienterede (for det meste tekstbaserede ) I STEDET [26] .

Bruges også i X-Plane flysimulatoren, i X-Ray motoren til STALKER [27] .

Til det populære spil Minecraft er der lavet modifikationer af ComputerCraft og dets mere avancerede analoge OpenComputers, som tilføjer computere programmeret i Lua-sproget [28] .

Det berømte spil Garry's Mod er programmeret og understøtter også modifikationer skrevet i Lua.

Croteam - teamet (udviklere af Serious Sam og The Talos Principle ) har brugt Lua i scripting siden Serious Engine 3.5 [29] .

Til spillet GTA: San Andreas oprettes modifikationer skrevet på Lua-sproget og understøttes af Moonloader-plugin'et. [30] Multi Theft Auto understøtter også Lua-scripting.

Roblox -spilplatformen bruger Lua som sit spilkodningssprog og spilmiljøstyring [31] .

Ficsit-Networks-modet er blevet skabt af Satisfactory - spilfællesskabet , som gør det muligt at programmere alle handlinger på Lua-sproget [32] .

Factorio bruger Lua til at skabe mods. [33] [34]

Spillet Dual Universe bruges til in-game mekanik og spilblok programmering

LuaTeX

Computertypesætteren LuaTeX , en udvidet version af pdfTeX , bruger Lua som sit indbyggede scriptsprog [35] .

RPM

RPM - pakkehåndteringen indeholder en indbygget Lua-fortolker [36] .

IDE

Der er mindst to "native" udviklingsmiljøer for Lua, disse er:

  • ZeroBrane Studio [37]  er et multi -platform udviklingsmiljø skrevet i Lua selv.
  • Decoda  er et Windows-udviklingsmiljø skrevet i C++ med rige fejlfindingsmuligheder for Lua-scripts, herunder i kørende applikationer. For 2018 går den seneste udgivelse af miljøet tilbage til 2014 og har status som en betaversion.

Derudover understøttes Lua af nogle universelle IDE'er, især:

Der var et Lua-supportmodul til NetBeans- miljøet , men det blev udgået i 2013 og er kun tilgængeligt til NetBeans 7.4 og tidligere. Pluginnet er ikke understøttet i NetBeans 8.

Se også

  • Liste over applikationer, der bruger Lua

Noter

  1. ↑ 1 2 https://www.lua.org/authors.html
  2. ↑ Lua: ca
  3. ↑ Lua 5.1 Reference Manual - 2019.
  4. ↑ A Look at the Design of Lua  - [ New York] : Association for Computing Machinery , 2018. - ISSN 0001-0782 ; 1557-7317
  5. ↑ https://www.lua.org/license.html
  6. ↑ Lua Open Source-projektet på Open Hub: Licensside - 2006.
  7. ↑ https://www.lua.org/about.html
  8. ↑ Om Lua . Lua.org. Hentet 19. juni 2013. Arkiveret fra originalen 26. december 2018.
  9. ↑ 1 2 Hvilket sprog bruger du til scripting i din spilmotor?. GameDev.net - Afstemningsresultater
  10. ↑ 1 2 Biancuzzi, Warden, 2011 , s. 216.
  11. ↑ Udviklingen af ​​et udvidelsessprog: en historie om Lua (2001). Hentet 24. august 2016. Arkiveret fra originalen 14. oktober 2017.
  12. ↑ HOPL, 2007 , s. 2–1–2–26.
  13. ↑ Lua: et udvideligt indlejret sprog. Nogle få metamekanismer erstatter et væld af funktioner  (december 1996), s. 26-33. Arkiveret fra originalen den 20. oktober 2014. Hentet 20. september 2014.
  14. ↑ Lua 5.1 Referencemanual . Hentet 5. november 2019. Arkiveret fra originalen 15. november 2013.
  15. ↑ LuaJIT-projektet . Hentet 18. maj 2009. Arkiveret fra originalen 16. april 2009.
  16. ↑ llvm-lua. JIT/statisk compiler til Lua ved hjælp af LLVM på backend. . Hentet 21. januar 2009. Arkiveret fra originalen 22. januar 2009.
  17. ↑ Bret Mogilefsky. Lua i Grim Fandango . Hentet 9. december 2011. Arkiveret fra originalen 4. februar 2012.
  18. ↑ HOPL, 2007 , s. elleve.
  19. ↑ Paul Emmerich. Begynder Lua med World of Warcraft-tilføjelser. - Apress , juli 2009. - ISBN 1430223715 .
  20. ↑ James Whitehead II, Bryan McLemore og Matthew Orlando. World of Warcraft programmering . - Wiley , maj 2008. - ISBN 0470229810 .
  21. ↑ Tom Gutschmidt. Ch. 8. Lua-spilfællesskabet → Spilmotorer // Spilprogrammering med Python, Lua og Ruby . - Premier Press, 2003. - 472 s. - ISBN 1-59200-079-7 .
  22. ↑ Defold spiludviklingsmanual - Lua in Defold . Udfold spilmotor. Hentet 2. marts 2017. Arkiveret fra originalen 3. marts 2017.
  23. ↑ Dj Walker-Morgan. H Speed ​​​​Guide til Lua → Udvikling med Lua . The H (17. april 2012). Hentet 26. februar 2015. Arkiveret fra originalen 26. februar 2015.
  24. ↑ Darmie Akinlaja. LÖVE til Lua-spilprogrammering. — Packt, 2013. — 106 s. — ISBN 978-1-78216-160-8 .
  25. ↑ Alan Thorne. Kapitel 8. Novashell og 2D-spil // Spiludvikling på tværs af platforme . - Jones & Bartlett Learning, 2008. - S.  225-264 . — 421 s. — ISBN 978-1-59822-056-8 .
  26. ↑ Pyotr Kosykh. I STEDET: Hvordan det hele begyndte  // IFPrint.org. - 18. marts 2013. - Udgave. 1 . — ISSN 2307-535X . Arkiveret fra originalen den 26. februar 2015.
  27. ↑ Ronnie Tucker. Full Circle Magazine #90: DET UAFHÆNGIGE MAGASIN FOR UBUNTU LINUX FÆLLESSKABET . — Full Circle Magazine, 2014-10-31. - 50 sek.
  28. ↑ Matthew Monk, Simon Monk. ComputerCraft: Lua-programmering i Minecraft . - CreateSpace Independent Publishing Platform, 2013-01-28. - 58 sek. — ISBN 9781481927659 .
  29. ↑ Zero_Cool. Teknologihistorie - Seriøs motor | historie | GPU test . gamegpu.com. Hentet 10. april 2016. Arkiveret fra originalen 20. april 2016.
  30. ↑ Favoritter - Lua - ASI - MoonLoader  (russisk) , BlastHack - Snyd som kunst . Arkiveret fra originalen den 29. januar 2018. Hentet 28. januar 2018.
  31. ↑ Lær Roblox | Kodning og scripts . developer.roblox.com Hentet 23. august 2019. Arkiveret fra originalen 23. august 2019.
  32. ↑ FicsIt-Networks :: Tilfredsstillende  ændringsdokumentation . docs.fixit.app . Hentet: 24. marts 2022.
  33. ↑ Modding - Factorio Wiki . wiki.factorio.com . Hentet 1. juni 2022. Arkiveret fra originalen 1. juni 2022.
  34. ↑ API-dokumenter | factorio . lua-api.factorio.com . Hentet 1. juni 2022. Arkiveret fra originalen 18. maj 2022.
  35. ↑ CTAN : Pakke luatex  . Hentet 6. februar 2019. Arkiveret fra originalen 7. februar 2019.
  36. ↑ Lua i RPM  . Hentet 11. februar 2019. Arkiveret fra originalen 24. juni 2018.
  37. ↑ ZeroBrane Studio - Lua IDE/editor/debugger til Windows, Mac OSX og Linux . Hentet 31. juli 2013. Arkiveret fra originalen 18. januar 2016.
  38. ↑ Lua-udviklingsværktøjer . Hentet 14. februar 2012. Arkiveret fra originalen 9. februar 2012.
  39. ↑ EmmyLua :: JetBrains Plugin  Repository . JetBrains Plugin Repository. Dato for adgang: 26. februar 2018. Arkiveret fra originalen 27. februar 2018.

Litteratur

  • Roberto Jerusalem. Programmering på Lua-sproget. - 3. udgave - DMK, 2014. - ISBN 9785940747673 . (original: Roberto Ierusalimschy. Programmering i Lua. - 3. udgave.. - 2012. - ISBN 9788590379850 . )
  • Ian Dees. Lua // Syv flere sprog på syv uger. Sprog der former fremtiden / Bruce Tate, Fred Daoud, Jack Moffitt, Ian Dees. - Den pragmatiske bogreol, 2015. - S. 1-48. - 320 sek. — ISBN 978-1941222157 .
  • Mario Kasuba. Lua spiludvikling kogebog. - Packt Publishing, 2015. - 402 s. — ISBN 978-1849515504 .
  • David Young. Lær spil AI-programmering med Lua. - Packt Publishing, 2014. - 352 s. — ISBN 978-1783281336 .
  • Jayant Varma. Lær Lua til iOS-spiludvikling . - Apress, 2012. - 410 s. — ISBN 9781430246626 .
  • Kurt Jung, Aaron Brown. Begyndelse af Lua-programmering . - John Wiley & Sons, 2011. - 675 s. - (Programmer til Programmer). — ISBN 9781118079119 .
Sproghistorie
  • R. Ierusalimschy, LH de Figueiredo, W. Celes. Udviklingen af ​​Lua  // Proceedings of ACM HOPL III. 2-1–2-26. – 2007.
  • Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes. Udviklingen af ​​et udvidelsessprog: en historie om Lua . Genoptryk fra Proceedings of V Brazilian Symposium on Programming Languages ​​(2001) B-14–B-28. Hentet 9. december 2011. Arkiveret fra originalen den 4. februar 2012.
  • Federico Biancuzzi, Shane Warden. Kapitel 7. Lua // Programmeringspionerer. Samtaler med skaberne af store programmeringssprog = Masterminds of Programmering: Samtaler med skaberne af store programmeringssprog. - Symbol, 2011. - S. 211-230. — 608 s. - 1500 eksemplarer.  — ISBN 9785932861707 .
  • Interview med Robert Yeruzalimsky for Computerworld om Lua-sproget

Se også

  • Squirrel  - Lua-baseret programmeringssprog

Links

Lua på russisk

Oversættelser af manualer Artikler og anmeldelser
 Lua
KompilereRammer og DLL'erHavne og distributionerIDE'erAnsøgninger
 Programmeringssprog