Typer, värden och uttryck i Lua

Lua Det är ett dynamiskt språk när det gäller datatyper och deras värden, det vill säga att det inte finns några definitioner av någon typ när man skapar en variabel och anger att det är en sträng, ett tal eller till och med en booleskt.
Uttryck går hand i hand med värden, dessa låter oss utföra operationer med dem, som kan sträcka sig från aritmetiska, relationella och till och med villkorliga operationer för att ge dynamik till våra program, men innan vi går vidare till uttryck, låt oss se vilka typer av värden som vi äger i Lua och hur de fungerar inom språket.
I Lua Varje värde laddar sin egen typ, där vi kan hitta åtta olika typer av dessa: noll, booleskt, tal, sträng, användardata, funktion, tråd och tabell, var med funktionen typ () vi kan känna typnamnet för det angivna värdet. Låt oss se ett enkelt exempel på hur Lua tolka detta enligt typ ():

Som vi ser typen ges av värdet som den laddar och den utsedda funktionen hjälper oss att veta vad det är, kan vi se att även i det sista fallet av variabeln H är resultatet sträng och det beror på att funktionen typ () är alltid sträng. Sedan vi såg hur Lua tolka datatyperna, låt oss titta närmare på var och en av dessa:
NollDetta är en typ av värde vars huvudsakliga egenskap ska skilja sig från andra värden. Som vi såg i den senaste självstudien har en global variabel värdet som standard noll och om vi vill eliminera det, tilldelar vi detta värde, vi kan till och med använda det för att representera frånvaron av ett användbart värde.
BooleanBoolska värden, liksom i resten av programmeringsspråken, har två värden, sanna och falska, men till skillnad från andra språk har denna typ av data inte en total domän över förhållanden eftersom alla kan representera ett villkor.
siffraDenna datatyp representerar både heltal och decimaler. Lua har inte en heltalstyp och behöver den inte sedan Lua det kan representera alla 32-bitars heltal utan avrundningsproblem, men det mest intressanta med språket är att vi kan kompilera det för att använda en annan typ, till exempel långa heltal eller floats, vilket är ganska användbart för fall där hårdvaran inte har stöd för decimaler.
SträngSträngarna in Lua De är en sekvens av tecken, de är värden som är oföränderliga, det vill säga att vi inte kan ändra ett tecken i strängen. De hanteras av det automatiska minnet för språket som resten av objekten och strängens tilldelning kan vara med dubbla eller enkla citattecken.
TabellTabellen datatyp implementerar en associativ array, som är en array som kan indexeras inte bara med siffror utan med strängar eller något annat språkvärde, förutom noll. Tabellerna har inte en fast storlek så vi kan inkludera så många element som vi vill och med dem kan vi representera moduler, paket och objekt lika. Slutligen är skapandet lika enkelt som att använda parenteser {} vid tabellinitialisering.
FunktionerFunktionerna i Lua de har ett ganska märkligt beteende, vi kan spara dem i variabler, skicka dem som argument till andra funktioner och returnera dem även som resultat, där Lua du kan kalla dessa funktioner skrivna både på själva språket och i C.
AnvändardataTyp av data användardata tillåter att lagra i variabler av Lua godtycklig information från C. Den har inga fördefinierade operationer på Lua, med undantag för uppdrags- och jämlikhetstester, där huvudfunktionen för denna typ är att representera nya typer som sådana skapade av en applikation eller ett bibliotek skrivet i C.
Som vi kan se skiljer sig typerna inte mycket från vad vi kan hitta på nuvarande språk, men det som är säkert är att enkelheten vi har att representera dem är mycket större, låt oss se vilken roll uttrycken har och hur vi kan använda dem med våra värderingar.
Aritmetiska operationer är oerhört viktiga för alla program och det är viktigt att veta hur man hanterar dem och vilka begränsningar som kan finnas på det språk vi använder. Lua den stöder de konventionella operatörer vi är vana vid: addition, subtraktion, multiplikation, division, exponential, procent och negation.
Låt oss se en enkel kod där vi visar användningen av vissa operatörer av Lua:

 x = 8 + 5 y = 9 - 2 utskrifter (x * y% 0,01)

Vi använder addition, subtraktion och division med 2 på resultatet av en multiplikationsoperation, låt oss se hur tolkens svar när vi kör vår kod genom konsolen:

FÖRSTORA

Som vi kan se skiljer Lua sig inte mycket från resten av språken för räkneoperationer, men dess enkelhet för att skriva kod gör det ganska lätt att hantera för programutveckling.
Lua som andra språk ger det oss relationsoperatorer som större än>, mindre än <, mindre än eller lika =, lika-lika == och negation ~ =. Vi ser att den enda som kanske skiljer sig är förnekelsen men efter att vi har vant oss vid det kommer det inte att finnas några problem med dess användning.
Alla dessa operatörer kan returnera sant eller falskt, där vi till och med kan tillämpa både jämställdhetsoperatören och negationsoperatören på två värden. Dessa jämförelser Lua det gör dem baserat på typen utöver andra faktorer, låt oss se i följande kod där jämförelsen görs baserat på samma objekt:

 a = {}; a.x = 1; a.y = 0 b = {}; b.x = 1; b.y = 0 c = a

Om vi ​​jämför detsamma, ger resultatet av operationen oss att a är lika med c men att a skiljer sig från b, beror detta på att de är samma objekt. Dessutom måste vi vara mycket försiktiga när vi jämför olika typer, eftersom till exempel 6 skiljer sig från "6" och om vi gör något som "3" <"8" Lua det kommer att ge ett fel eftersom vi blandar strängarna.
De logiska operatörerna i Lua de är och och eller inte. När en jämförelse görs med dessa operatörer returneras det första argumentet om det är falskt, annars returneras det andra. Låt oss se en serie exempel i den interaktiva konsolen för att demonstrera det ovan nämnda.

FÖRSTORA

För att utföra sammanfogning i Lua är genom kolon, det ändrar syntaxen lite med avseende på andra språk men på samma sätt är det ganska enkelt, men Lua Det går alltid lite längre och om det hittar ett tal och det finns en sammanfogningsoperation, konverterar det det till en sträng, låt oss se två enkla exempel på denna operation:

FÖRSTORA

Som vi ser för det första fallet utförs operationen utan problem, och för det andra fallet har vi nummer, Lua konverterar dem automatiskt till sträng. Det är viktigt att komma ihåg att strängar är oföränderliga så den här operationen skapar alltid en ny sträng utan att göra några ändringar av dess operand.
Slutligen har vi konstruktörerna, som är uttryck som gör att vi kan skapa och initiera tabeller, den här funktionen är unik för Lua och det är en av dess mest mångsidiga och kraftfulla mekanismer. Vi kan använda en tom konstruktör utan problem med bara fästena {} som kommer att skapa en tom tabell som sådan. Dessa kan också initiera matriser eller listor, låt oss se ett exempel:

 dagar = {"söndag", "måndag", "tisdag", "onsdag", "torsdag", "fredag", "lördag"}

Här skapar vi en lista med veckodagarna och om vi vill komma åt dess element genom att ange index för samma som vi har, till exempel för att erhålla torsdag skulle det vara index nummer 5 eller söndag skulle det vara nummer 1, eftersom Lua Det initieras inte till noll som resten av språken, låt oss se hur det ser ut när vi kör det i vår konsol:

Vi kan också skapa våra egna associerande matriser av nyckelvärdetypen:
array = {x = 26, y = 67}
Men det är viktigt att för att komma åt dess värden refererar vi till indexet med dubbla viloteckningar, vi får värdet noll, vi ser vår funktion i den interaktiva konsolen:

Med detta avslutar vi handledningen, där vi kunde se det Lua sträcker sin enkelhet till alla kanter som komponerar den, från de dynamiska typerna den hanterar, det enkla sättet att göra uppdrag, hanteringen av relations- och logiska operatörer, samt att ge oss extremt användbara verktyg som sammankopplingar och konstruktörer för att göra våra uppleva språket så trevligt och trevligt som möjligt.Gillade du och hjälpte denna handledning?Du kan belöna författaren genom att trycka på den här knappen för att ge honom en positiv poäng