Scripts in Lua-taal

Een script geschreven in Lua heeft geen speciale functie om de uitvoering ervan te starten. Een script kan eenvoudigweg worden gezien als een reeks opdrachten (instructies) die worden uitgevoerd vanaf de eerste instructie.

Een script kan heel eenvoudig zijn, bestaande uit slechts één commando, of heel complex, met tientallen, honderden en zelfs duizenden instructies. Opeenvolgende uitspraken kunnen worden gescheiden door een puntkomma (;). Deze vereiste is echter niet verplicht, dus alle onderstaande code is syntactisch correct:

Werken met variabelen in Lua

Variabelen worden gebruikt om waarden op te slaan tijdens de uitvoering van het script.

Variabelenamen in Lua

Variabelenamen (ID's) in Lua kunnen elke reeks letters, cijfers en een onderstrepingsteken zijn dat niet met een cijfer begint.

Let op

De Lua-taal is hoofdlettergevoelig, dus abc, Abc en ABC zijn verschillende namen.

De onderstaande tabel toont woorden die zijn gereserveerd door de Lua-taal en die niet kunnen worden gebruikt in variabelenamen:

en breken, anders doen

eind false voor functie if

in lokaal nul niet of

herhaal return dan waar tot

Bovendien zijn alle namen die beginnen met een onderstrepingsteken gevolgd door hoofdletters (bijvoorbeeld _VERSION) ook gereserveerd.

Welke variabelen zijn er in Lua?

Variabelen in Lua kunnen globaal of lokaal zijn. Als een variabele niet expliciet als lokaal wordt gedeclareerd, wordt deze als globaal beschouwd.

Lua globale variabelen

Er verschijnt een globale variabele wanneer de eerste waarde eraan wordt toegewezen. Voordat de eerste waarde wordt toegewezen, resulteert toegang tot de globale variabele in nul.

MsgBox(tostring (g)) --> nul

MsgBox(tostring (g)) --> 1

Een globale variabele bestaat zolang de uitvoeringsomgeving van het script bestaat en beschikbaar is voor alle Lua-code die in die omgeving wordt uitgevoerd.

Indien nodig kunt u een globale variabele expliciet verwijderen door er eenvoudigweg de waarde nul aan toe te kennen.

g = 1 - maak een globale variabele g met de waarde 1

g = nul - verwijder de globale variabele g

MsgBox(tostring (g)) --> nul

Alle globale variabelen zijn velden van een reguliere tabel die de globale omgeving wordt genoemd. Deze tabel is toegankelijk via de globale variabele _G. Omdat de velden van de mondiale omgeving allemaal globale variabelen zijn (inclusief _G zelf), dan is _G._G == _G.

Lua lokale variabelen

Eventuele lokale variabelen moeten expliciet worden gedeclareerd met behulp van het lokale sleutelwoord. U kunt overal in het script een lokale variabele declareren. De declaratie kan het toekennen van een initiële waarde aan de variabele omvatten. Als er geen waarde is toegekend, bevat de variabele nul.

local a - declareer een lokale variabele a

local b = 1 - declareer een lokale variabele b, wijs deze de waarde 1 toe

lokale c, d = 2, 3 - declareer lokale variabelen c en d, wijs ze waarden 2 en 3 toe

Het bereik van een lokale variabele begint na de declaratie en loopt door tot het einde van het blok.

Opmerking

De reikwijdte van een variabele is het gebied van de programmacode waarbinnen u toegang hebt tot de waarde die in deze variabele is opgeslagen.

Een blok betekent:

lichaam van de controlestructuur (als-dan, anders, voor, terwijl, herhaal);

functie lichaam;

een codefragment tussen de trefwoorden do...end.

Als een lokale variabele buiten een blok wordt gedefinieerd, strekt het bereik zich uit tot het einde van het script.

local i = 1 - variabele i is lokaal binnen het script

terwijl ik<= a do - цикл от 1 до 5

local a = i^2 - variabele a is lokaal binnen de while-lus

MsgBox(a) --> 1, 4, 9, 16, 25

BerichtBox(a) -->

als ik > 5 dan

local a - variabele a is dan lokaal

BerichtBox(a) --> 10

MsgBox(a) --> 5 (hier toegang tot globale a)

lokaal a = 20 - variabele a is lokaal binnen do-end

BerichtBox(a) --> 20

MsgBox(a) --> 5 (hier toegang tot globale a)

Let op

Waar mogelijk wordt aanbevolen om lokale variabelen te gebruiken in plaats van globale variabelen. Dit voorkomt vervuiling van de globale naamruimte en levert betere prestaties op (aangezien toegang tot lokale variabelen in Lua iets sneller gaat dan toegang tot globale variabelen).

Lua-gegevenstypen

Welke gegevenstypen ondersteunt Lua?

Lua ondersteunt de volgende gegevenstypen:

1. Nihil (niets). Komt overeen met het ontbreken van een waarde voor een variabele. Dit type wordt weergegeven door een enkele waarde: nul.

2. Booleaanse waarde (logisch). Dit type bevat de waarden false en true.

Bij het uitvoeren van logische bewerkingen wordt de waarde nul als onwaar behandeld. Alle andere waarden, inclusief het getal 0 en de lege tekenreeks, worden als waar beschouwd.

3. Nummer (numeriek). Wordt gebruikt om numerieke waarden weer te geven.

Numerieke constanten kunnen een optioneel gebroken deel en een optionele decimale exponent specificeren, gespecificeerd door de karakters "e" of "E". Numerieke constanten van gehele getallen kunnen in hexadecimaal worden opgegeven met behulp van het voorvoegsel 0x.

Voorbeelden van geldige numerieke constanten: 3, 3.0, 3.1415926, 314.16e-2, 0xff.

4. Snaar. Wordt gebruikt om tekenreeksen weer te geven.

Tekenreekswaarden worden gespecificeerd als een reeks tekens tussen enkele of dubbele aanhalingstekens:

a = "dit is een tekenreeks"

b = "dit is de tweede regel"

Tekenreeksen tussen dubbele aanhalingstekens kunnen worden geïnterpreteerd door C-achtige ontsnappingsreeksen, beginnend met het teken "\" (backslash):

\b (spatie),

\n (regelinvoer),

\r (koetsretour);

\t (horizontaal tabblad),

\\ (backslash);

\"" (dubbele aanhalingstekens);

\" (enkel aanhalingsteken).

Let op

Een teken in een string kan ook worden weergegeven door zijn eigen code met behulp van een escape-reeks:

waarbij ddd een reeks van niet meer dan drie cijfers is.

Naast aanhalingstekens kunnen ook dubbele vierkante haken worden gebruikt om een ​​tekenreeks te definiëren:

Door een string te definiëren met behulp van dubbele vierkante haken kunt u alle escape-reeksen negeren, dat wil zeggen dat de string volledig wordt gemaakt zoals beschreven:

lokaal a = [] in Lua]=]

Er zal een term zijn: "definitie van string[] in Lua"

5. Functie. Functies in Lua kunnen naar variabelen worden geschreven, als parameters aan andere functies worden doorgegeven en worden geretourneerd als resultaat van de functie-uitvoering.

6. Tafel (tafel). Een tabel is een verzameling sleutel-waardeparen die velden of tabelelementen worden genoemd. Zowel sleutels als tabelveldwaarden kunnen van elk type zijn, behalve nul. Tabellen hebben geen vaste grootte: er kan op elk moment een willekeurig aantal elementen aan worden toegevoegd.

Lees meer in het artikel “Tabellen maken in Lua”

7. Gebruikersgegevens (gebruikersgegevens). Is een speciaal gegevenstype. Waarden van dit type kunnen niet rechtstreeks in een Lua-script worden aangemaakt of gewijzigd.

Gebruikersdata wordt gebruikt om nieuwe typen weer te geven die zijn gemaakt in het scriptaanroepprogramma of in bibliotheken die zijn geschreven in C. De Lua-extensiebibliotheken voor CronosPRO gebruiken dit type bijvoorbeeld om objecten weer te geven zoals:

databanken (bankklasse);

databases (klasse Base);

records (recordklasse), enz.

8. Draad (stroom). Komt overeen met de uitvoeringsdraad. Deze threads zijn op geen enkele manier geassocieerd met het besturingssysteem en worden uitsluitend door Lua zelf ondersteund.

Hoe stel ik het type van een variabele in Lua in?

Lua stelt het type van een variabele niet expliciet in. Het type van een variabele wordt vastgesteld wanneer er een waarde aan de variabele wordt toegekend. Aan elke variabele kan een waarde van elk type worden toegewezen (ongeacht het type waarde dat deze voorheen bevatte).

a = 123 - variabele a heeft het typenummer

a = "123" - nu is de variabele a van het type string

a = waar - nu is variabele a van het type boolean

a = () - nu is de variabele a van het type tabel

Let op

Variabelen zoals tabel, functie, thread en gebruikersdata bevatten de gegevens zelf niet, maar slaan verwijzingen op naar de overeenkomstige objecten. Bij het toewijzen, doorgeven aan een functie als argument en als gevolg daarvan terugkeren uit de functie, worden objecten niet gekopieerd, maar worden alleen verwijzingen ernaar gekopieerd.

a = () - maak een tabel. De variabele a bevat een link naar de tabel

b = a - variabele b verwijst naar dezelfde tabel als a

a = 10 - het tabelelement met index 1 krijgt de waarde 10

BerichtBox(b) --> "10"

BerichtBox(a) --> "20"

De overige gegevens zijn directe waarden.

BerichtBox(a) --> "20"

BerichtBox(b) --> "10"

Hoe krijg ik het type van een variabele in Lua?

Het type van een waarde die in een variabele is opgeslagen, kan worden bepaald met behulp van de standaardtypefunctie. Deze functie retourneert een tekenreeks met de typenaam ("nil", "number", "string", "boolean", "table", "function", "thread", "userdata").

t = type ("dit is een string") - t is gelijk aan "string"

t = type (123) - t is gelijk aan "getal"

t = type (type) - t is gelijk aan "functie"

t = type (waar) - t is gelijk aan "boolean"

t = type (nul) - t is gelijk aan "nul"

t = type (CroApp.GetBank()) - t is gelijk aan "gebruikersgegevens"

Hoe converteer je het type van een variabele in Lua?

Lua converteert getallen automatisch naar tekenreeksen en omgekeerd wanneer dat nodig is. Als een tekenreekswaarde bijvoorbeeld een operand is in een rekenkundige bewerking, wordt deze omgezet in een getal. Op dezelfde manier zal een numerieke waarde die wordt aangetroffen op een plaats waar een stringwaarde wordt verwacht, worden geconverteerd naar een string.

a = "10" + 2 - a is gelijk aan 12

a = "10" + 2 - a is gelijk aan "10 + 2"

a = "-5.3e-10"*"2" - a is gelijk aan -1.06e-09

a = "string" + 2 - Fout! Kan 'tekenreeks' niet naar getal converteren

Een waarde van elk type kan expliciet worden geconverteerd naar een string met behulp van de standaard tostring-functie.

a = tostring(10) - a is gelijk aan "10"

a = tostring (waar) - a is gelijk aan "waar"

a = tostring (nul) - a is gelijk aan "nul"

a = tostring (( = "dit is veld 1")) - a is gelijk aan "tabel: 06DB1058"

Uit het vorige voorbeeld wordt duidelijk dat de inhoud van tabellen niet wordt geconverteerd door de functie tostring. U kunt deze transformatie uitvoeren met behulp van de renderfunctie.

a = render(10) - a is gelijk aan "10"

a = render(true) - a is gelijk aan "true"

a = render (nul) - a is gelijk aan "nul"

a = render (( = "dit is veld 1")) - a is gelijk aan "( = "dit is veld 1)"

Om een ​​waarde expliciet naar een getal te converteren, kunt u de standaardfunctie tonumber gebruiken. Als de waarde een tekenreeks is die naar een getal kan worden geconverteerd (of al een getal is), retourneert de functie het resultaat van de conversie, anders retourneert deze nul.

a = tonumber("10") - a is gelijk aan "10"

a = tonumber("10"..".5") - a is gelijk aan 10,5

a = tonumber (waar) - a is gelijk aan "nul"

a = tonumber (nul) - a is gelijk aan "nul"

Commentaar in Lua regelen

Een commentaar in Lua begint met twee mintekens (--) en gaat door tot het einde van de regel.

lokaal a = 1 - commentaar van één regel

Als de tekens "--" onmiddellijk worden gevolgd door twee vierkante haakjes openen ([[), bestaat het commentaar uit meerdere regels en loopt door tot twee vierkante haakjes sluiten (]]).

lokaal a = 1 - [[ meerdere regels

opmerking ]]

Dubbele haakjes in opmerkingen kunnen worden genest. Om ze niet te verwarren, wordt tussen de haakjes een gelijkteken (=) ingevoegd:

lokaal a = [[Kronos-bedrijf]] - [=[

lokaal a = [[Kronos Company]]

Het aantal “=” tekens bepaalt de nesting:

lokaal a = [=[definitie van een tekenreeks [] in Lua]=] --[==[

lokaal a = [=[definitie van een tekenreeks [] in Lua]=]

Operaties gebruikt in Lua

De volgende soorten bewerkingen kunnen worden gebruikt in expressies die in Lua zijn geschreven:

1. Rekenkundige bewerkingen.

Lua ondersteunt de volgende rekenkundige bewerkingen:

+ (optelling);

- (aftrekken);

* (vermenigvuldiging);

/ (divisie);

^ (machtsverheffing);

% (rest van deling).

Let op

Rekenkundige bewerkingen zijn van toepassing op zowel getallen als strings, die in dit geval worden omgezet in getallen.

2. Vergelijkingsoperaties.

De volgende waardevergelijkingsbewerkingen zijn toegestaan ​​in Lua:

== (gelijk);

~= (niet gelijk);

< (меньше);

> (meer);

<= (меньше или равно);

>= (groter dan of gelijk aan).

Let op

Vergelijkingsbewerkingen retourneren altijd de Booleaanse waarde waar of onwaar.

De regels voor het converteren van getallen naar tekenreeksen (en omgekeerd) werken niet voor vergelijkingen, d.w.z. de uitdrukking “0” == 0 resulteert in false.

3. Logische bewerkingen.

Logische bewerkingen zijn onder meer:

en (logisch EN).

De operator en retourneert de eerste operand als deze onwaar of nul is. Anders retourneert de bewerking de tweede operand (en deze operand kan van elk type zijn).

a = (nul en 5) - a is gelijk aan nul

a == (onwaar en 5) - a is gelijk aan onwaar

a == (4 en 5) - a is gelijk aan 5

of (logische OF).

De bewerking of retourneert de eerste operand als deze niet false of nul is, anders retourneert deze de tweede operand.

a == (4 of 5) - a is gelijk aan 4

a == (onwaar of 5) - a is gelijk aan 5

Let op

De logische operatoren en en of kunnen waarden van elk type retourneren.

De logische operatoren en en of evalueren de waarde van de tweede operand alleen als deze moet worden geretourneerd. Als dit niet vereist is, wordt de tweede operand niet geëvalueerd. Bijvoorbeeld:

a == (4 of f()) - de functie f() wordt niet aangeroepen

niet (logisch NIET).

De bewerking not retourneert altijd waar of onwaar.

4. Concatenatiebewerking.

Om tekenreeksen samen te voegen (verenigen), gebruikt u de bewerking ... (twee punten).

a = “Kronos.”-”..“Inform” - variabele a krijgt de waarde “Kronos-Inform”

Let op

Als een of beide operanden getallen zijn, worden ze omgezet in tekenreeksen.

a = 0..1 - variabele a krijgt de waarde “01”

5. Lengteverkrijgende werking.

Lua definieert een lengteoperator # die kan worden gebruikt om de lengte van een tekenreeks te verkrijgen.

a = "tekenreeks"

len = #a - len is gelijk aan 6

len = #“een andere regel” - len is gelijk aan 10

Let op

U kunt ook de bewerking # gebruiken om de maximale index (of grootte) van een array te achterhalen. Voor meer details, zie het artikel “Werken met arrays in Lua”.

Voorrang van operaties in Lua

In Lua worden bewerkingen uitgevoerd volgens de volgende prioriteit (in aflopende volgorde):

2. niet # - (unair)

6. < > <= >= ~= ==

Scripts oproepen vanuit formulieren

Aan elk formulier (inclusief geneste formulieren) is een afzonderlijk script gekoppeld, dat doorgaans functies bevat die gebeurtenissen voor het formulier en de elementen ervan afhandelen.

Wanneer het formulier wordt gestart, wordt het script in de globale omgeving geladen. Wanneer een gebeurtenis plaatsvindt op een formulier of een element ervan, roept het systeem de afhandelingsfunctie aan die bij deze gebeurtenis hoort.

Opgemerkt moet worden dat het formulierscript, hoewel het geen aanroep naar de modulefunctie bevat, feitelijk een module is. Dit betekent dat variabelen die in het formulierscript zijn gedeclareerd zonder het lokale trefwoord, niet in de globale omgeving worden geplaatst en alleen binnen dit script beschikbaar zijn. Als u een waarde beschikbaar moet maken voor scripts van andere vormen, moet deze expliciet worden gedefinieerd in de globale tabel _G:

lokaal a = _G.var

Blokken met uitspraken (instructies)

Basis Lua-operators omvatten:

opdracht;

voorwaardelijke exploitant;

operators voor het organiseren van lussen.

Een groep instructies kan worden gecombineerd tot een blok (samengestelde instructie) met behulp van de do... end-constructie.

do - begin van blok

<оператор1>- bloklichaam

<оператор2>

<операторN>

einde - einde van blok

Een blok opent een nieuw bereik waarin lokale variabelen kunnen worden gedefinieerd.

a = 5 - globale variabele a

local a = 20 - een lokale variabele a wordt gedefinieerd binnen het do-end

BerichtBox(a) --> 20

MsgBox(a) --> 5 (hier is de verwijzing naar globale a)

Opdrachtoperator in Lua

Een toewijzing verandert de waarde van een variabele of tabelveld. In de eenvoudigste vorm kan een opdracht er als volgt uitzien:

a = 1 - variabele a krijgt de waarde 1

a = b + c - variabele a krijgt de som van de waarden van variabelen b en c toegewezen

a = f(x) - variabele a krijgt de waarde toegewezen die wordt geretourneerd door de functie f(x)

Lua maakt zogenaamde meervoudige toewijzing mogelijk, wanneer verschillende variabelen links van de toewijzingsoperator de waarden ontvangen van verschillende expressies die rechts van de toewijzingsoperator zijn geschreven:

a, b = 1,5*c - a is gelijk aan 1; b is gelijk aan 5*c

Als er meer variabelen zijn dan waarden, krijgen de “extra” variabelen nul toegewezen.

a, b, c = 1, 2 - a is 1; b is gelijk aan 2; c is gelijk aan nul

Als er meer waarden dan variabelen zijn, worden de ‘extra’ waarden genegeerd.

a, b = 1, 2, 3 - a is gelijk aan 1; b is gelijk aan 2; waarde 3 niet gebruikt

Meervoudige toewijzing kan worden gebruikt om waarden tussen variabelen uit te wisselen:

a = 10; b = 20 - a is gelijk aan 10, b is gelijk aan 20

a, b = b, a - nu is a 20, b is 10

Voorwaardelijke verklaring (als) in Lua

De if-instructie test de waarheid van een bepaalde voorwaarde. Als de voorwaarde waar is, wordt het codegedeelte dat volgt op het trefwoord then (dan sectie) uitgevoerd. Anders wordt de code die volgt op het else-trefwoord (else-sectie) uitgevoerd.

als a > b dan

retourneer a - als a groter is dan b, retourneer a

retour b - anders - retour b

Het else-gedeelte is optioneel.

als een< 0 then

a = 0 - als a kleiner is dan 0, stel dan a in op 0

In plaats van geneste if-instructies kunt u de elseif-constructie gebruiken. Bijvoorbeeld de volgende code:

Het zal gemakkelijker te begrijpen zijn als u het vervangt door het volgende:

return "Ivan" - als a 1 is

elseif a == 2 dan

retourneer "Peter" - als a 2 is

elseif a == 3 dan

retourneer "Sergey" - als a gelijk is aan 3

return “Er is geen dergelijke speler” - indien a - geen van de bovenstaande

Terwijl lus in Lua

De while-operator is bedoeld voor het organiseren van loops met een preconditie en heeft de volgende vorm:

terwijl Doen

... - luslichaam

Vóór elke iteratie van de lus wordt de voorwaarde gecontroleerd :

als de voorwaarde onwaar is, eindigt de lus en wordt de controle overgedragen naar de eerste instructie die volgt op de while-instructie;

als de voorwaarde waar is, wordt de body van de lus uitgevoerd, waarna alle acties worden herhaald.

terwijl i > 0 do - cyclus van 10 naar 1

t[i] = "veld"..i

een = (3, 5, 8, -6, 5)

terwijl i > 0 dat wel doet - zoek naar een negatieve waarde in de array

als een[ik]< 0 then break end - если найдено, прерываем цикл

i = i - 1 - ga anders naar het volgende element

als ik > 0 dan

MsgBox("Negatieve waarde-index: "..i)

MsgBox("Array bevat geen negatieve waarden")

Opmerking

Lus met postconditie (herhaling) in Lua

De repeat-operator is bedoeld voor het organiseren van lussen met een postconditie en heeft de volgende vorm:

... - luslichaam

tot

De body van de lus wordt uitgevoerd totdat aan de voorwaarde wordt voldaan zal niet waar worden. De voorwaarde wordt gecontroleerd nadat de lusbody is uitgevoerd, zodat de lusbody in ieder geval minstens één keer wordt uitgevoerd.

Tel de waarden van array a op totdat de som niet groter is dan 10

een = (3, 2, 5, 7, 9)

som = som + a[i]

tot som > 10

MsgBox("Elementen "..i.." toegevoegd. De som is "..sum")

U kunt de break-instructie gebruiken om een ​​lus te verlaten voordat deze is voltooid.

Opmerking

Lees meer over de mogelijkheden van het gebruik van de pauze-operator in het artikel “Breek- en retouroperatoren”

Lussen met voor verklaring in Lua

De for-operator is ontworpen om lussen te organiseren en maakt twee schrijfvormen mogelijk:

eenvoudig (numeriek voor);

verlengd (universeel voor).

Eenvoudige vorm van de for-instructie

Een eenvoudige vorm van de for-instructie ziet er als volgt uit:

voor var = exp1, exp2, exp3 doen

... - luslichaam

De body van de lus wordt uitgevoerd voor elke waarde van de lusvariabele (teller) var in het interval van exp1 tot exp2, met stap exp3.

Opmerking

De stap is mogelijk niet gespecificeerd. In dit geval wordt het gelijk gesteld aan 1.

voor i = 1, 10 do - lus van 1 naar 10 met stap 1

MsgBox("i is gelijk aan "..i)

for i = 10, 1, -1 do - lus van 10 naar 1 met stap -1

MsgBox("i is gelijk aan "..i)

Let op

Expressies exp1, exp2 en exp3 worden slechts één keer geëvalueerd, vóór het begin van de lus. In het onderstaande voorbeeld wordt de functie f(x) dus slechts één keer aangeroepen om de bovengrens van de lus te berekenen:

voor i = 1, f(x) do - lus van 1 naar de waarde die wordt geretourneerd door de functie f().

MsgBox("i is gelijk aan "..i)

Een lusvariabele is lokaal voor de lusinstructie en is aan het einde van de lus niet gedefinieerd.

for i = 1, 10 do - loop van 1 naar de waarde die wordt geretourneerd door de functie f().

MsgBox("i is gelijk aan "..i)

MsgBox("Na het verlaten van de lus is i gelijk aan "..i) - Onjuist! ik is gelijk aan nul

Let op

De waarde van een lusvariabele kan binnen een lus niet worden gewijzigd; de gevolgen van een dergelijke verandering zijn onvoorspelbaar.

Om een ​​lus te verlaten voordat deze voltooid is, gebruik je de break-instructie.

een = (3, 5, 8, -6, 5)

for i = 1,#a do - zoek naar een negatieve waarde in de array

als een[ik]< 0 then - если найдено...

index = i - bewaar de index van de gevonden waarde...

break - en onderbreek de lus

MsgBox("Negatieve waarde-index: "..index)

Opmerking

Lees meer over de kenmerken van het gebruik van de pauze-operator in het artikel “Breek- en retouroperatoren”)

- Extensie (formaat) zijn de tekens aan het einde van het bestand, na de laatste punt.
- De computer bepaalt het bestandstype aan de hand van de extensie.
- Standaard toont Windows geen bestandsnaamextensies.
- Sommige tekens kunnen niet worden gebruikt in de bestandsnaam en extensie.
- Niet alle formaten zijn gerelateerd aan hetzelfde programma.
- Hieronder staan ​​alle programma's die kunnen worden gebruikt om het LUA-bestand te openen.

Veel MS Windows-gebruikers hebben al lang gemerkt dat het standaard kladblok een nogal onhandig programma is om te gebruiken. Deze gratis tekstbestandseditor, die syntaxisondersteuning biedt voor een groot aantal programmeertalen, kan deze vervangen. Het programma bevat een vrij breed scala aan opties en wordt gekenmerkt door een minimaal verbruik van processorbronnen. Het programma maakt het mogelijk om meerdere documenten tegelijk te bekijken en te bewerken, zonder onnodige vensters te sluiten. Er is ook een optie beschikbaar gekomen: hetzelfde document op verschillende plekken bewerken, wel zo handig...

Notepad2 is een eenvoudige applicatie waarmee u tekst kunt typen en bewerken. Het zal helpen bij het maken van HTML-pagina's, programmeren in verschillende talen (CSS, Java, JavaScript, Python, SQL, Perl, PHP) omdat het code kan markeren. Het programma is gebouwd op het principe van een eenvoudig notitieblok; het is lichtgewicht en compact. Deze teksteditor controleert alle haakjes op paren en ondersteunt automatisch inspringen. Notepad2 ondersteunt niet alleen ASCII- en UTF-8-coderingen, maar kan deze ook converteren. Hiermee kunt u ongewenste bewerkingen vele niveaus terugdraaien. Ondersteunt blokselectie van tekstelementen en heeft genummerde...

Komodo Edit is een handige code-editor die een breed scala aan verschillende programmeertalen ondersteunt. Het programma geeft gebruikers de mogelijkheid om met meerdere bestanden tegelijk te werken; het schrijven van code wordt efficiënter met behulp van de autocomplete-functie en hints. Met de applicatie kunt u variabelen automatisch markeren wanneer u ze selecteert. Met de editor kunt u bestanden in andere programmeertalen bekijken. Het programma ondersteunt syntaxiskleuring en inspringing. Kan syntaxisparameters controleren, fragmenten die worden gebruikt om bronkolomcode op te slaan. Heeft een eenvoudige bewerkingsmodus en ondersteunt slepen en neerzetten...

Er zijn veel programma's op internet waarmee je de broncode van een ander programma, bestand, enz. kunt bewerken. De meeste van deze programma's zijn echter slechts een teksteditor zoals Kladblok. Ze verschillen alleen van de bovenstaande editor doordat ze syntaxisaccentuering hebben. In sommige gevallen is deze programmafunctionaliteit echter niet voldoende. Een programmeur moet mogelijk snel verschillende delen van een document vinden. En nu is er eindelijk een programma verschenen waarmee je dit probleem kunt oplossen. Het programma heet SynWrite. Het onderscheidende kenmerk is de aanwezigheid van een navigatiepaneel met een boom...

LUA-plug-in - vereist voor sommige mods die zijn geschreven in Script Hook V voor GTA 5.

Lua is een script-programmeertaal ontwikkeld door de afdeling Tecgraf (Computer Graphics Technology Group) van de Katholieke Universiteit van Rio de Janeiro (Brazilië). De taaltolk is vrij verspreid, open source in de C-taal.

Qua mogelijkheden, ideologie en implementatie ligt de taal het dichtst bij JavaScript, maar Lua heeft krachtigere en veel flexibelere ontwerpen. Hoewel Lua het concept van klasse en object niet expliciet omvat, kunnen de mechanismen van objectgeoriënteerd programmeren, inclusief meervoudige overerving, eenvoudig worden geïmplementeerd met behulp van metatables, die ook verantwoordelijk zijn voor overbelasting van operators, enz. Het objectgeoriënteerde programmeermodel dat wordt geïmplementeerd is prototypisch (zoals in JavaScript).

LUA-plug-in voor Script Hook V

De taal wordt veel gebruikt om repliceerbare software te maken (de grafische interface van het Adobe Lightroom-pakket is er bijvoorbeeld in geschreven). Het is ook populair geworden als programmeertaal voor niveaus en uitbreidingen in veel games (waaronder World of Warcraft) vanwege het gemak van insluiten, de snelheid van code-uitvoering en het leergemak.

Hoe te installeren

1. Moet je geïnstalleerd worden
2. Kopieer vervolgens eenvoudig alle bestanden uit het archief (inclusief mappen) naar de GTA 5-hoofdmap.
3. Vervolgens worden LUA-scripts in de map “/scripts/addins” geladen

Lua voor Windows (LfW) is een geïnterpreteerde programmeertaal ontwikkeld door de Tecgraf-divisie van de Katholieke Universiteit van Rio de Janeiro (Computer Graphics Technology Group van de Pauselijke Katholieke Universiteit van Rio de Janeiro in Brazilië). De ontwikkelde tolk is vrij verspreid, open source in de C-taal.

Qua mogelijkheden, ideologie en implementatie ligt de taal het dichtst bij JavaScript, maar Lua heeft krachtigere en veel flexibelere ontwerpen. Hoewel Lua het concept van klasse en object niet expliciet omvat, kunnen de mechanismen van objectgeoriënteerd programmeren, inclusief meervoudige overerving, eenvoudig worden geïmplementeerd met behulp van metatables, die ook verantwoordelijk zijn voor overbelasting van operators, enz. Het objectgeoriënteerde programmeermodel dat wordt geïmplementeerd is prototypisch (zoals en in JavaScript).

De taal wordt veel gebruikt om repliceerbare software te maken - met name de grafische interface van het Adobe Photoshop Lightroom-pakket is erin geschreven. Het is ook populair geworden als programmeertaal voor niveaus en uitbreidingen in veel games (bijvoorbeeld World of Warcraft) vanwege het gemak van insluiten, de snelheid van code-uitvoering en het gemak van leren.

Lua wordt gewoonlijk een taal met meerdere paradigma's genoemd. Het biedt een kleine reeks basismechanismen die kunnen worden uitgebreid om verschillende problemen op te lossen, in plaats van een reeks complexe, rigide specificaties die programmering in één enkel paradigma afdwingen.

Lua ondersteunt dus niet expliciet overerving, maar kan eenvoudig worden geïmplementeerd met behulp van metatabelen.

In deze tutorialserie die ik in gedachten heb, wordt de programmeertaal Lua besproken. Ik zal proberen de presentatie zo toegankelijk mogelijk te maken voor beginners, en ik zal mij daarop concentreren. Dat wil zeggen, ervaren Lua-codeerders zullen hier waarschijnlijk niets nieuws van leren (ik ben er zeker van dat ze alleen ruimte zullen vinden voor gezeur en commentaar, wat in feite zelfs welkom is van hun kant), maar als je dat niet hebt gedaan ruime programmeerervaring achter de rug, dan neem je denk ik iets mee.

De hele serie zal aan geen enkel systeem gehoorzamen. In de lessen wordt achtereenvolgens een aantal taalconstructies geïntroduceerd, zodat je in de derde of vierde les al je eigen programma's kunt schrijven. Mijn doel is om je ertoe aan te zetten de taal zelf te leren, je te helpen de taal te voelen, en niet om het van A tot Z uit te leggen. Als je de taal volledig onder de knie wilt krijgen, lees dan de naslaggids (die, hoewel slecht, vertaald in het Russisch: http://www.lua.ru/doc/). Hoe eerder u van “voor dummies”-lessen op internet overstapt op het bestuderen van het naslagwerk, hoe beter.

Als iets onduidelijk is, stel dan zeker een vraag in de reacties, dan zullen ik en andere deelnemers proberen je te helpen.

Lua is een populaire, gemakkelijk te leren, ingebedde, geïnterpreteerde, dynamisch getypeerde programmeertaal voor algemene doeleinden. Nee, je hoeft de helft van de woorden in de vorige zin niet te begrijpen - het belangrijkste is om te weten dat het populair en ongecompliceerd is. Trouwens, het heeft zijn populariteit verdiend vanwege zijn eenvoud, evenals de kleine omvang van de distributie (ongeveer 150 kilobytes). Lua-scripts worden ondersteund door een groot aantal applicaties, waaronder games. World of Warcraft en S.T.A.L.K.E.R. gebruik de Lua-taal. Met mijn favoriete game-engine kun je eenvoudig een verscheidenheid aan games maken met Lua. Zoals je ziet opent Lua veel horizonten voor je!

Voordat we beginnen, moet u een programmeeromgeving opzetten: dat wil zeggen: zoek een programma dat de Lua-code die u schrijft accepteert en voer het uit: een tolk. Er zijn drie opties:

1. Download de officiële Lua-distributie van een van de sites die deze levert.

Vanaf de officiële Lua-website kunt u alleen de broncodes van de tolk downloaden. Als u echter naar http://lua.org/download.html in de sectie Binaire bestanden kijkt, vindt u mogelijk links naar sites met uitvoerbare bestanden voor Windows. Een van hen: . Download daar een van de archieven (passend bij uw platform: Win32 of Win64) en pak het ergens uit, bij voorkeur in een map met een kort pad: zoals C:\lua. Vanaf nu ga ik ervan uit dat u Windows gebruikt en dat uw tolk aanwezig is.

In die zin is het gemakkelijker voor gebruikers van op Linux gebaseerde besturingssystemen: ze hoeven alleen maar een pakketbeheerder te gebruiken en Lua vanuit de repository's te installeren. Op Debian en Ubuntu gebeurt dit met het commando apt-get install lua, en op Fedora, Red Hat en afgeleide distributies - yum install lua. Vertrouw mij echter niet blindelings en raadpleeg de handleiding van uw besturingssysteem om erachter te komen hoe dit precies voor u wordt gedaan.

2. Gebruik een online tolk.

Gevonden op http://www.lua.org/demo.html. In eerste instantie kan dit voldoende zijn, maar later, als we het over modules hebben, zul je gedwongen worden om de offline versie te gebruiken. Het gebruik van de online tolk is heel eenvoudig: voer uw programma in het tekstvak in en klik op de knop Uitvoeren. Het programma wordt uitgevoerd en het Output-venster toont de uitvoer van uw programma, evenals eventuele foutrapporten die u heeft gemaakt.

3. Gebruik een IDE.

Bijvoorbeeld ZeroBrane Studio: http://studio.zerobrane.com/. Er zijn er nog meer - kijk op internet.

Er zijn momenteel twee enigszins verschillende versies van Lua in gebruik: 5.1 en 5.2. Ik zal me concentreren op de meest recente versie - versie 5.2, maar ik zal zeker wijzen op belangrijke verschillen tussen deze versie en 5.1, aangezien deze laatste ook vrij gebruikelijk is. Trouwens, Lua 5.1 voert code anderhalf keer sneller uit dan Lua 5.2, zodat je het weet.

=== Les nr. 1 ===

Dus laten we beginnen. Maak een main.lua-bestand in een map die is geïsoleerd van externe bestanden en schrijf daarin:

200?"200px"+(deze.scrollHeight+5)+"px");">
-- hoofd.lua --
print("Hallo wereld!")

Voer het vervolgens uit op de opdrachtregel (vergeet niet om naar de map met main.lua te gaan met behulp van het cd-commando):

200?"200px"+(deze.scrollHeight+5)+"px");">
> C:\lua\lua.exe hoofd.lua

De Lua-tolk zal antwoorden met:

200?"200px"+(deze.scrollHeight+5)+"px");">
Hallo wereld!

In principe was dit te verwachten. In het programma noemden we de printfunctie. De printfunctie neemt een willekeurig aantal parameters en geeft deze achtereenvolgens op het scherm weer. In dit voorbeeld hebben we de string (tekenreeks) "Hallo wereld!" doorgegeven. Je kunt het net zo gemakkelijk doorgeven als een parameter:

200?"200px"+(deze.scrollHeight+5)+"px");">
print(8) -- een decimaal getal
-- zal uitvoeren: 8

Afdrukken(0xDEADBEEF) -- hexadecimaal getal
-- zal uitvoeren: 3735928559

Print("0xDEADBEEF") - maar dit is een string, geen getal! Zie jij de citaten?
-- zal uitvoeren: 0xDEADBEEF

Print(1.35e-4) -- drijvende-kommagetal (fractioneel getal)
-- Zal 0,000135 opleveren. 1.35e-4 moet worden opgevat als "1,35 keer
– met tien tot de minus vierde macht,” als iemand het niet weet.

Afdrukken((198*99)-3*500 + 14/88) -- expressie
-- Drukt de waarde van de uitdrukking af: 18102.159090909. Geen slecht alternatief
-- bureaurekenmachine!

Print(198/7, "meststof", 2^9) -- verschillende willekeurige parameters
-- soort van. De waarden van elk van hen worden weergegeven, gescheiden door tekens
-- tabbladen:
-- 28.285714285714 kunstmest 512
-- Houd er rekening mee dat citaten rond kunstmest niet worden weergegeven!

Print(1.35) -- twee cijfers, niet de decimale breuk 1,35!
-- Er wordt een komma gebruikt om parameters van elkaar te scheiden.
-- Zal uitvoeren:
-- 1 35

Het "--"-teken is niet alleen een imitatie van het streepjes-teken, dat voor de schoonheid is ingevoegd. Het "--" teken in Lua markeert commentaar: hints voor de programmeur die door de tolk worden genegeerd en bedoeld om de code begrijpelijker te maken. Je kunt proberen in het programma te schrijven:

200?"200px"+(deze.scrollHeight+5)+"px");">
--print("niets")

De tolk zal denken dat dit een opmerking is en zal de instructie niet uitvoeren.

Opmerking voor de gastvrouw: als u slechts één regel wilt afdrukken, kunt u de printoproep als volgt schrijven, zonder haakjes:

200?"200px"+(deze.scrollHeight+5)+"px");">
afdrukken "Slechts één string"

Gemak is zeker twijfelachtig: houd er gewoon rekening mee dat dit mogelijk is. Dergelijke oproepen zijn echter onaanvaardbaar:

200?"200px"+(deze.scrollHeight+5)+"px");">
print 2 werkt niet, 2 is geen string.
print 2*2 + 6 -- het zal toch niet werken

Str = "tekenreeks!!" -- heeft de waarde "string!!" toegekend aan de variabele str
-- lees hieronder over variabelen
print str -- zal ook niet werken.

In elk van de bovenstaande gevallen zal het programma eenvoudigweg weigeren te werken. Bij een oproep zonder haakjes kan de functienaam dus alleen worden gevolgd door een letterlijke tekenreeks (dat wil zeggen een reeks tekens tussen aanhalingstekens), en niets anders. Ik zal in de toekomst wat gedetailleerder over deze functie praten, maar voor nu is dat genoeg.

Met elke goede programmeertaal kun je variabelen declareren: kleine containers die wat gegevens kunnen bevatten. In Lua gebeurt dit als volgt:

200?"200px"+(deze.scrollHeight+5)+"px");">
<имя_переменной> = <выражение>

Bijvoorbeeld:

200?"200px"+(deze.scrollHeight+5)+"px");">
ster = 8 -- Nu slaat de variabele ster het getal 8 op
wars = "owl" -- In de wars-variabele - de string "owl"
jedi = 42/2 -- In de variabele jedi - het getal 21
luke = star*jedi -- In de variabele luke - het getal 168 (ja, 21 keer 8)

De waarden van variabelen en uitdrukkingen daarmee kunnen ook worden weergegeven:

200?"200px"+(deze.scrollHeight+5)+"px");">
print(ster, oorlogen, jedi, jedi-ster+luke)
-- Zal uitvoeren:
-- 8 uil 21 181

Probeer gewoon niet de variabelen ster en oorlogen toe te voegen - proberen 8 toe te voegen aan "uil" zal je geen goed doen!

Zoals je zou moeten hebben opgemerkt, kan de naam van een variabele bijna alles zijn: het belangrijkste is dat deze niet met een getal begint. Serieus, je kunt zelfs een variabele declareren met de naam print en dan stopt de printfunctie met werken omdat de naam print verwijst naar de nieuw gedeclareerde variabele. Maar er is een groep woorden die niet als variabelenaam mogen worden gebruikt - dit zijn taalzoekwoorden waar we nog niet bekend mee zijn, maar die zeker de moeite van het bekijken waard zijn:

200?"200px"+(deze.scrollHeight+5)+"px");">
en breken doe anders als einde
false voor functie goto if in
lokaal nul niet of herhaald rendement
dan waar tot een tijdje

Door een variabele met een van deze namen aan te maken, veroorzaakt u een fout in het programma, en deze zal beslist niet werken. Let op: in Lua 5.1 is er geen goto trefwoord, en je kunt op die manier een variabele aanroepen, maar dat kun je beter niet doen.
Houd er ook rekening mee dat namen van variabelen hoofdlettergevoelig zijn. Dit betekent dat foo, fOo, fOO en FOO vier verschillende variabelen zijn, dus als u de naam van een variabele in kleine letters schrijft en deze later in hoofdletters, zal het programma hoogstwaarschijnlijk niet correct werken.

En nu een belangrijk punt: wat gebeurt er als je, per ongeluk of opzettelijk, naar een niet-bestaande variabele verwijst? In de meeste andere talen zal dit een fout veroorzaken, maar in Lua is deze situatie acceptabel. Er wordt behandeld alsof de niet-bestaande variabele daadwerkelijk bestaat, maar de waarde ervan is dat wel nul. nul- onthoud dit woord! is een speciaal waardetype in Lua dat "niets" betekent. Niet nul en geen lege string (een string als "" - probeer hem eens op het scherm weer te geven), maar gewoon niets. Vergelijk dit met dit model: er zijn twee mensen, een van hen heeft een bankrekening maar er staat geen geld op, en de ander heeft helemaal geen bankrekening. In Lua-termen wordt ervan uitgegaan dat de eerste $0 op zijn rekening heeft, en de tweede $0 op zijn rekening. nul. En niet eens dollars, maar gewoon nul. Ik hoop dat ik je niet in verwarring heb gebracht.

Probeer bijvoorbeeld dit programma uit te voeren:

200?"200px"+(deze.scrollHeight+5)+"px");">
-- hoofd.lua --
foo = "bar"
afdrukken(foo, baz)
-- Zal uitvoeren:
--bar nul

De variabele baz, die niet bestaat maar wel wordt verondersteld te bestaan, heeft dus de waarde nul, en de printfunctie begrijpt dit en drukt dit op het scherm af als de string "nil". Lua heeft een goede methode om het bestaan ​​van een variabele te controleren: als de waarde van de variabele niet nul is, wordt deze in ieder geval gedeclareerd. Aan de andere kant kun je expliciet een variabele declareren die gelijk is aan nul:

200?"200px"+(deze.scrollHeight+5)+"px");">
cool_var = nul

Dit kan worden gedaan, en hoewel het op het eerste gezicht dom lijkt, wordt het soms gedaan. In de volgende lessen leer je wie en waarom, en waarschijnlijk ga je hetzelfde doen. Soms natuurlijk.
Wees voorzichtig met nil: je kunt nil afdrukken, maar je kunt er geen rekenkundige bewerkingen mee uitvoeren. Dat wil zeggen: als je weg kunt komen met print(nil), zal een constructie als 99+nil een fout veroorzaken, zelfs als je dat wel zou doen! zoals 99+ nul was 99. Geloof me, ik was ook boos toen ik erachter kwam.

Cv:
1. We leerden over de afdrukfunctie, wat deze kan doen en hoe we deze zonder haakjes correct kunnen aanroepen.
2. We hebben geleerd hoe we variabelen kunnen declareren, hoe we uitdrukkingen kunnen evalueren (al is het maar een beetje), welke namen variabelen kunnen hebben.
3. We leerden over nul, raakten doordrenkt met het mystieke mysterie ervan en kregen het vertrouwen dat we er in de toekomst veel mee te maken zullen hebben.

Voor degenen die nieuwsgierig zijn en hun kennis willen versterken, bied ik eenvoudige oefeningen aan, wat u niet hoeft te doen als u zich al competent genoeg voelt:
1. Schrijf een programma dat het refrein van je favoriete nummer afdrukt.
2. Probeer de waarden van de volgende uitdrukkingen af ​​te leiden. Probeer te begrijpen waarom sommige ervan werken en andere niet. Bekijk welke fouten worden veroorzaakt door expressies die niet werken.

200?"200px"+(deze.scrollHeight+5)+"px");">
2 + "reeks";
6 + "14";
"doos" - "vox";
1 * "11b"
"148" * "1e6";

3. Schrijf een programma dat waarden tussen twee variabelen uitwisselt. Dat is:

200?"200px"+(deze.scrollHeight+5)+"px");">
a = 6502
b=8086

Maak a gelijk aan 8086 en b gelijk aan 6502. Om dit te doen, maakt u een derde variabele en voert u enkele eenvoudige herschikkingen uit. Zorg ervoor dat het probleem correct is opgelost door vóór de uitwisseling print(a,b) en daarna print(a,b) aan te roepen.