Eerste stappen met Lua

Lua is een geïnterpreteerde, eenvoudige, draagbare en uitbreidbare taal die oorspronkelijk is gemaakt om te worden geïntegreerd met C en andere conventionele talen, maar het gebruik ervan is uitgebreid naar webapplicaties, mobiele applicaties, webservices en zelfs videogames.
Hij gebruikt de API van C om bepaalde taken uit te voeren, variërend van bewerkingen op laag niveau, prestaties en interfaces met programma's van derden. Lua het blinkt ook vanzelf uit, het maakt het werken met dynamische structuren mogelijk, elimineert redundanties, maakt automatisch geheugenbeheer mogelijk en biedt de mogelijkheid voor testen en debuggen.
Lua Het dient ook als een "lijm" -taal om het op de een of andere manier te noemen, omdat het een component voor softwareontwikkeling heeft die is gericht op het maken van applicaties met behulp van componenten op hoog niveau die zijn geschreven en gecompileerd in talen zoals C of C ++.
We weten al iets meer over Lua, maar met alle programmeertalen die tegenwoordig beschikbaar zijn en hetzelfde doel dienen, denken velen misschien: waarom zou je kiezen? Lua boven de anderen? Maar de waarheid is dat Lua Het heeft een reeks kenmerken waardoor het zich onderscheidt van de rest, laten we eens kijken:
UitbreidbaarheidDe uitbreidbaarheid van Lua het is zodanig dat veel ontwikkelaars het niet als een taal beschouwen, maar als een gereedschapskist voor het bouwen van specifieke talen. Lua is vanaf de grond af ontworpen om te worden uitgebreid met uw eigen code en code, waar een bewijs hiervan is: Lua implementeert de meeste van zijn basisfunctionaliteit via externe bibliotheken. De integratie van Lua met C / C ++ is uiterst eenvoudig en is gebruikt in combinatie met andere talen zoals Fortrand, Java, C# en zelfs met andere talen geïnterpreteerd als Robijn Y Perl.
EenvoudLua het is een eenvoudige en kleine taal met weinig concepten, met uitgebreide documentatie en door zijn eenvoud heel gemakkelijk te leren.
efficiëntieDe implementatie is zeer efficiënt en uitgevoerde studies tonen aan dat: Lua als een van de snelst geïnterpreteerde talen van vandaag.
DraagbaarheidTot slot, als we het hebben over draagbaarheid, hebben we het niet alleen over wat: Lua kan zowel in . worden uitgevoerd ramen als in LinuxWe hebben het erover dat het draait op alle platforms die we kennen: Mac, OS X, Symbian OS, PlayStation, Xbox, ARM-processors en natuurlijk alle smaken van Unix en Windows. De code voor al deze platforms is praktisch hetzelfde en Lua gebruikt geen voorwaardelijke compilatie, maar blijft bij de compiler ANSI C, op deze manier is het niet nodig om het aan te passen aan een nieuwe omgeving.
Zoals we zien Lua het heeft bepaalde kenmerken waardoor het zich onderscheidt van andere geïnterpreteerde talen. We hebben al een breder panorama van de taal, laten we eens kijken hoe we het kunnen installeren en hoe we een eenvoudig voorbeeld kunnen maken.
Voor deze tutorial gaan we installeren Lua in Ubuntu om de stappen en het gebruik ervan te vereenvoudigen. Eerst openen we onze terminal en gaan we het volgende commando uitvoeren:

 sudo apt-get install lua5.2

Hiermee hebben we de nieuwste versie van de taal en kunnen we ermee beginnen met ontwikkelen, omdat we kunnen zien dat het vrij eenvoudig te installeren was, dus controleer de eenvoud ervan. Nu gaan we een klein bestand maken met de naam hallo_world.lua die de volgende code zal hebben:

 print ("Hallo wereld, Lua is probleemloos geïnstalleerd")

We gaan naar onze terminal naar het pad waar we het bestand hebben gemaakt en we gaan het uitvoeren om te verifiëren dat we hebben Lua zonder problemen geïnstalleerd, hiervoor gebruiken we alleen het gereserveerde woord lua en de naam van het bestand, laten we eens kijken wat de uitvoer van ons programma is:

Laten we een complexer voorbeeld bekijken waarmee een gebruiker gegevens kan invoeren en met een functie zullen we de faculteit van een getal berekenen:

 functie faculteit (n) if n == 0 dan retour 1 else return n * faculteit (n-1) end end print ("Voer een getal in:") a = io.read ("* nummer") print (faculteit (a ))

Laten we onze code vanaf de terminal uitvoeren en kijken hoe het werkt:

We voeren verschillende getallen in om de faculteit van elk ervan te verkrijgen, en dit met een paar eenvoudige regels code. Dat hebben we al geverifieerd Lua Het is correct geïnstalleerd en we kunnen onze programma's zonder enig probleem uitvoeren, maar er zijn enkele concepten van de taal die we moeten kennen voordat we verder gaan met leren.
Elk stukje code dat Lua wordt uitgevoerd, zoals een bestand of een regel wordt genoemd brok of deel, waar het niets meer is dan een reeks opdrachten of instructies. De eigenaardigheid van Lua is dat het geen scheidingstekens tussen de zinnen nodig heeft, maar we kunnen de beroemde puntkomma gebruiken als we dat willen.
We raden aan om de puntkomma te gebruiken om twee instructies die op dezelfde regel staan ​​te scheiden om enige orde in de code en leesbaarheid te behouden. Het is belangrijk om te vermelden dat het regeleinde van Lua niet bestaat, laten we, om te zien hoe het hierboven beschreven werk werkt, naar het volgende voorbeeld kijken waarbij elk deel even geldig is:

We kunnen zien dat zelfs de laatste regel aan geen enkele conventie voldoet, maar deze is volledig geldig en functioneel in de taal. Bovendien kunnen de delen regel voor regel worden uitgevoerd in plaats van een bestand te maken via de interactieve console van Lua, waar met het plaatsen van het gereserveerde woord lua zonder argumenten kunnen we het invoeren, laten we eens kijken:

Zoals we kunnen zien, voeren we onze afdruk uit zonder een bestand te hoeven maken, zelfs Lua Het is in staat om te detecteren wanneer een regel geen geldig gedeelte is en geeft ons een andere invoer om de rest toe te voegen, maar nogmaals, velen zullen zich afvragen: wat heeft het voor zin om regel voor regel uit te voeren als we een bestand kunnen maken en het in een enkele stap? Het antwoord is twee woorden; testen en debuggen, door middel van de interactieve console, zijn deze processen uiterst eenvoudig en praktisch. We gaan dan een klein programma maken en met de interactieve console gaan we elk deel ervan evalueren, laten we de inhoud ervan bekijken:

 functie norm (x, y) return (x 2 + y 2) 0,5 end functie double (x) return 2 * x end

Om nu toegang te krijgen tot de interactieve console en ons programma te kunnen debuggen, moeten we het volgende plaatsen:

 lua -i test.lua

De interactieve console wordt geopend en we kunnen ons programma evalueren, hiervoor gebruiken we de functie dofile () die verantwoordelijk is voor het laden van onze code en dan kunnen we de argumenten naar onze functies sturen en uitvoeren, laten we eens kijken hoe we dit bereiken:

Zoals we zagen konden we onze code probleemloos testen, dit is best handig als we een vrij uitgebreide code hebben met fouten en we niet weten waar ze zijn.
We hebben al een reeks nuttige concepten doorlopen om onze programma's uit te voeren en er tests op uit te voeren in geval van fouten, maar om deze fouten te verminderen, is het noodzakelijk om enkele conventies te kennen met betrekking tot welke gereserveerde woorden we niet kunnen gebruiken of zelfs hoe we onze variabelen moeten noemen of identificatiegegevens.
Voor de laatste kan het elke tekenreeks zijn die bestaat uit letters, cijfers en onderstrepingstekens, waarbij u ervoor moet zorgen dat u niet met een cijfer begint, bijvoorbeeld:

• identificatie
• identificatie2
• aVariabeleVeryLang
• _identificatie
• _ENTRADADATEN

Daarnaast hebben we de volgende gereserveerde woorden die we niet kunnen gebruiken om onze identifiers een naam te geven:

Het is belangrijk om te vermelden dat Lua is hoofdlettergevoelig dus herhalen is anders dan HERHALEN, iets om in gedachten te houden bij het ontwikkelen met de taal. Ten slotte, om opmerkingen te maken door het dubbele koppelteken op te nemen dat we voor een regel hebben, en als we een blok met opmerkingen willen opnemen, plaatsen we ze tussen haakjes zoals we kunnen zien in het volgende gedeelte van de code:

 - [[afdrukken ("Hallo wereld") -]]

En als we die opmerking willen deactiveren door een extra script aan het begin ervan toe te voegen, hebben we:

Om af te sluiten hebben we de globale variabelen, die niet hoeven te worden gedeclareerd, alleen door de waarden eraan toe te wijzen, kunnen we ze maken en in het geval dat we ze openen voordat we ze hebben gemaakt, verkrijgen we de waarde nul wat aangeeft dat het een andere waarde is dan de andere, wat ons zelfs helpt om de variabele op het moment van toewijzing te elimineren, laten we een voorbeeld hiervan bekijken:

Zoals we de eenvoud van zien Lua het strekt zich uit tot elk aspect van de taal, zelfs met de declaraties van onze variabelen. Hiermee hebben we deze tutorial afgerond, waar we onze eerste stappen mee konden zetten Lua, het demonstreren van de kracht van taal en hoe gemakkelijk het is om het te gebruiken, wat ons een alternatief biedt voor de uitgebreide catalogus van geïnterpreteerde talen voor de ontwikkeling van onze applicaties.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven