Lehrreiche Tipps, Tricks & Shortcuts im Code

Hallo,

in den letzten Wochen ist mir immer mehr aufgefallen, wie kompliziert einige Forumnutzer ihren Code schreiben, obwohl es auch leichter und schneller geht.

Sicherlich wird es in diesem Forum einige geben, welche von diesen Shortcuts noch nichts wussten, zumindest denke ich so. Daher wird dies euch von Vorteil sein.

Außerdem wird auch noch über die ressourcensparende Tipps und Tricks am Ende gesprochen, welche nützlich und interessant sein dürften.

Ignorieren von Klammern

Ein kleiner Trick, welcher euch 2 Zeichen sparen kann. Sicherlich ist dieser relativ vielen unbekannt und man wird es kaum glauben - aber es funktioniert.

Dabei muss beachtet werden, dass der Trick vorausgesetzt nur dann angewendet werden kann, wenn die Anzahl der übergebenen Argumente < 1 ist und es sich um eine Tabelle (array) oder Zeichenkette (string) handelt.

Aus folgendem Snippet

function greet_client(name)
    if (type(name) == "string") then print(name) end
end

greet_client("User_14513")

wird dementsprechend

function greet_client(name)
    if (type(name) == "string") then print(name) end
end

greet_client"User_14513" -- Bitte genauer darauf achten - das ist kein Tippfehler.

Singuläre Checks

Als "Singuläre Checks" (auf Englisch: "Singular Checks") bezeichnet man in der Programmierung das Verkürzen von einer gesamten Abfrage in einen einzeiligen Code.

Sobald die Bedingung bzw. der "Check" wahr ist, wird der Wert von someVar dem zugewiesen, was auch immer der Wert nach dem and-Operator ist.

Wenn dieser dann falsch bzw. = null ist, wird der Wert nach dem or-Operator zugewiesen.

Aus folgendem Snippet

local condition = "true"
local var = "Check steht aus"

if (condition == "true") then
    var = "Erfolg"
else
    var = "Fehlgeschlagen"
end

wird dementsprechend

local condition = "true"
local var = (condition == "true") and "Erfolg" or "Fehlgeschlagen"

Named Arguments

Folgendes Beispiel ist vielen Anfängern aber auch Fortgeschrittenen unbekannt.

Als "Named Arguments" bezeichnet man eine Möglichkeit, bei der die Funktion statt individuellen und separaten Argumenten, "abgespeicherte" Argumente verwendet.

Ein guter Weg, um unwichtige Parameter nicht übergeben zu müssen und sie auszulassen. Außerdem spart es wieder Code.

function print_specs(computer)
    print(computer.Name)
    print(computer.RAM)
    print(computer.Age)
end

print_specs{Name = "Computer-41451", RAM = "8 GB", Age = 2}

Snippet 2 zeigt, dass man Parameter, welche mittendrin eigentlich gesetzt werden müssten, ausgelassen werden.

function print_specs(computer)
    print(computer.Name)
    print(computer.RAM)
    print(computer.Age)
end

print_specs{Name = "Computer-41451", Age = 2}

statt

function print_specs(name, ram, age)
    print(name)
    print(ram)
    print(age)
end

print_specs("Computer-41451", nil, 2)

Save performance and localize!

Wer im letzten Abschnitt "Named Arguments" richtig auf den Code geachtet hat, sollte bemerkt haben, dass bei Example 1 & 2 auch der Teil von "Ignorieren von Klammern" (auf Englisch: "Ignore Parenthesis") verwendet wurde.

Es sollte für die meisten im Eigentlichen nicht allzu schwer sein, Locals zu nutzen. more characters !== less speed - das sollte damit klar gestellt werden.

Vielleicht mag es extrem dargestellt sein, wenn man sagt, dass man es darauf anlegen möchte, den Computer oder Server völlig auf seine Grenzen zu bringen.

Da die folgenden Tests sich nur auf mathematische Funktionen beziehen, ist mir aktuell unklar, ob das nur auf diese und nicht andere zutreffend ist.

Allerdings ist das auch erwähnenswert, daher seht ihr nun ein Beispiel, in der ungefähr ~30% der Geschwindigkeit durch diese Kleinigkeit gespart wird.

for i = 1, 1000000 do
    local x = math.sin(i)
end

ist deutlich langsamer (~30%) als

local sin = math.sin

for i = 1, 1000000 do
    local x = sin(i)
end

Save performance - Tabelleneinträge hinzufügen - table.insert() vs. [ ]

local tinsert = table.insert
for i = 1, 1000000 do
    tinsert(a, i)
end

for i = 1, 1000000 do
    a[i] = i
end

for i = 1, 1000000 do
    a[#a+1] = i
end

local count = 1
for i = 1, 1000000 do
    d[count] = i
    count = count+1
end

Resultate:

table.insert: 1.250 (727%)

a[i]: 0.172 (100%)

a[#a+1] = x: 0.453 (263%)

a[count++] = x: 0.203 (118%)

Schlussfolgerung:

table.insert ist sehr langsam (!) und sollte im besten Fall nicht verwendet werden. Es bietet sich stattdessen an, an einer anderen Stelle abzuspeichern und dann a[count+1] = x zu nutzen.

Selbstverständlich hoffe ich, dass dieses Tutorial einigen Forumnutzern die Möglichkeiten im Bezug zu "Ease your code" näher gebracht hat.

Der performance-technische Teil wird höchstwahrscheinlich die wenigsten interessiert haben, allerdings ist dieser trotzdem interessant, wenn man seinen Code möglichst ressourcensparend halten möchte.

Bezüglich des Tutorials wird in naher Zukunft eventuell noch mehr hinzugefügt, dennoch sollten sich unter den Lesern einige finden, bei welchen die gezeigten Tricks direkt Anklang gefunden haben.

Falls Grammatik-, Tipp & Text- oder Logikfehler zu finden sind, kann man diese mir gerne melden.

Vielen Dank für eure Aufmerksamkeit und nehmt davon etwas mit,

- Str1ker