luacheck - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

luacheck - luacheck-Dokumentation

Inhaltsverzeichnis:

LISTE OF HINWEISE

Von Luacheck erzeugte Warnungen werden anhand von dreistelligen Warncodes kategorisiert. Warnung
Codes können in der CLI-Ausgabe angezeigt werden mit --codes CLI-Option oder Codes config-Option.
Fehler haben auch Codes, die mit Null beginnen.

┌─────┬───────────────────────────────── ─┐
│Code │ Beschreibung │
├─────┼───────────────────────────────────
│011 │ Ein Syntaxfehler. │
├─────┼───────────────────────────────────
│021 │ Eine ungültige Inline-Option. │
├─────┼───────────────────────────────────
│022 │ Ein upaired Inline-Push │
│ │ Direktive. │
├─────┼───────────────────────────────────
023 │ Eine aktualisierte Inline-Pop-Direktive. │
├─────┼───────────────────────────────────
│111 │ Festlegen einer undefinierten globalen │
│ │ variabel. │
├─────┼───────────────────────────────────
│112 │ Mutation einer undefinierten globalen │
│ │ variabel. │
├─────┼───────────────────────────────────
│113 │ Zugriff auf eine undefinierte globale │
│ │ variabel. │
├─────┼───────────────────────────────────
│121 │ Festlegen einer schreibgeschützten globalen │
│ │ variabel. │
├─────┼───────────────────────────────────
│122 │ Mutieren einer schreibgeschützten globalen │
│ │ variabel. │
├─────┼───────────────────────────────────
│131 │ Unbenutzt implizit definiert global │
│ │ variabel. │
├─────┼───────────────────────────────────
211 │ Unbenutzte lokale Variable. │
├─────┼───────────────────────────────────
212 │ Unbenutztes Argument. │
├─────┼───────────────────────────────────
│213 │ Unbenutzte Schleifenvariable. │
├─────┼───────────────────────────────────
│221 │ Auf lokale Variable wird zugegriffen, aber │
│ │ nie eingestellt. │
├─────┼───────────────────────────────────
│231 │ Lokale Variable ist gesetzt aber nie │
│ │ aufgerufen. │
├─────┼───────────────────────────────────
│232 │ Ein Argument wird gesetzt, aber nie │
│ │ aufgerufen. │
├─────┼───────────────────────────────────
│233 │ Schleifenvariable ist gesetzt, aber nie │
│ │ aufgerufen. │
├─────┼───────────────────────────────────
│311 │ Wert, der einem lokalen . zugewiesen wird
│ │ Variable wird nicht verwendet. │
└─────┴───────────────────────────────── ─┘

312 │ Der Wert eines Arguments wird nicht verwendet. │
├─────┼───────────────────────────────────
│313 │ Wert einer Schleifenvariablen ist │
│ │ unbenutzt. │
├─────┼───────────────────────────────────
│321 │ Zugriff auf nicht initialisierte lokale │
│ │ variabel. │
├─────┼───────────────────────────────────
411 │ Eine lokale Variable neu definieren. │
├─────┼───────────────────────────────────
│412 │ Ein Argument neu definieren. │
├─────┼───────────────────────────────────
│413 │ Eine Schleifenvariable neu definieren. │
├─────┼───────────────────────────────────
421 │ Shadowing einer lokalen Variablen. │
├─────┼───────────────────────────────────
422 │ Ein Argument überschatten. │
├─────┼───────────────────────────────────
423 Shadowing einer Schleifenvariable. │
├─────┼───────────────────────────────────
431 │ Shadowing einer Aufwertung. │
├─────┼───────────────────────────────────
432 │ Shadowing eines Upvalue-Arguments. │
├─────┼───────────────────────────────────
│433 │ Shadowing einer Aufwertungsschleife │
│ │ variabel. │
├─────┼───────────────────────────────────
511 │ Nicht erreichbarer Code. │
├─────┼───────────────────────────────────
│512 │ Schleife kann höchstens ausgeführt werden │
│ │ einmal. │
├─────┼───────────────────────────────────
│521 │ Unbenutztes Etikett. │
├─────┼───────────────────────────────────
│531 │ Linke Seite einer Aufgabe │
│ │ ist zu kurz. │
├─────┼───────────────────────────────────
│532 │ Linke Seite einer Aufgabe │
│ │ ist zu lang. │
├─────┼───────────────────────────────────
│541 │ Eine leere do Ende Block. │
├─────┼───────────────────────────────────
│542 │ Eine leere if Zweig. │
├─────┼───────────────────────────────────
│551 │ Eine leere Anweisung. │
└─────┴───────────────────────────────── ─┘

Global Variablen
Luacheck erstellt für jede Datei eine Liste von definierten Globals, die dort verwendet werden können. Standardmäßig
nur Globals aus der Lua-Standardbibliothek sind definiert; benutzerdefinierte globales können hinzugefügt werden mit
--globals CLI-Option oder globals config-Option und Version der Standardbibliothek können
ausgewählt mit --std CLI-Option oder std config-Option. Wenn eine undefinierte globale festgelegt ist,
mutiert oder auf sie zugegriffen wird, gibt Luacheck eine Warnung aus.

Nur-Lese- globals
Standardmäßig sind alle Standard-Globals außer _G und Paket sind als schreibgeschützt markiert, damit
das Setzen oder Verändern dieser erzeugt eine Warnung. Benutzerdefinierte schreibgeschützte Globals können hinzugefügt werden mit
--read-globals CLI-Option oder read_globals config-Option.

Implizit definiert globals
Luacheck kann so konfiguriert werden, dass unter bestimmten Bedingungen zugewiesene Globals als
implizit definiert. Wann -d/--allow_definiert CLI-Option oder erlauben_definiert Konfigurationsoption ist
verwendet, alle Zuweisungen zu Globals definieren diese; Wenn -t/--allow_defined_top CLI-Option oder
erlauben_definiert_top config-Option wird verwendet, Zuweisungen zu Globals in der Top-Level-Funktion
Scope (auch bekannt als main chunk) definieren sie. Eine Warnung wird ausgegeben, wenn implizit
definiert global wird nirgendwo zugegriffen.

Module
Dateien können mit . als Module markiert werden -m/--Modul CLI-Option oder Modulen Konfigurationsoption zu
simulieren Semantik des veralteten Modulen Funktion. Globale implizit in a . definiert
Modul gelten als Teil seiner Schnittstelle, sind von außen nicht sichtbar und werden nicht gemeldet
als unbenutzt. Zuweisungen an andere Globals sind nicht erlaubt, auch nicht an definierte.

ungebraucht Variablen und Werte
Luacheck generiert Warnungen für alle nicht verwendeten lokalen Variablen außer einer benannten _. Außerdem
erkennt Variablen, auf die gesetzt, aber nie zugegriffen wurde, oder auf die zugegriffen, aber nie gesetzt wurde.

ungebraucht Werte und nicht initialisiert Variablen
Für jeden einer lokalen Variablen zugewiesenen Wert berechnet Luacheck einen Satz von Ausdrücken, wobei es
könnte verwendet werden. Warnungen werden für nicht verwendete Werte ausgegeben (wenn ein Wert nicht verwendet werden kann
überall) und für den Zugriff auf nicht initialisierte Variablen (wenn keine Werte eine
Ausdruck). ZB im folgenden Snippet Wert zugewiesen zu foo auf Zeile 1 ist ungenutzt, und
Variable Bar ist in Zeile 9 nicht initialisiert:

lokales foo = expr1()
lokale Bar

wenn Bedingung () dann
foo = expr2()
Balken = Ausdruck3()
sonst
foo = expr4()
Drucken (Leiste)
Ende

Rückkehr foo, bar

Sekundär Werte und Variablen
Nicht verwendeter Wert, der einer lokalen Variablen zugewiesen wird, ist sekundär, wenn sein Ursprung das letzte Element ist
das RHS der Zuweisung, und ein anderer Wert aus diesem Element wird verwendet. Sekundärwerte
erscheinen normalerweise, wenn das Ergebnis eines Funktionsaufrufs in Locals eingefügt wird, und nur einige von ihnen
werden später verwendet. Zum Beispiel hier Wert zugewiesen zu b ist sekundär, Wert wird zugewiesen c is
verwendet und Wert zugewiesen a ist einfach ungenutzt:

lokal a, b, c = f(), g()

Rückkehr c

Eine Variable ist sekundär, wenn alle ihr zugewiesenen Werte sekundär sind. Im Ausschnitt oben,
b ist eine sekundäre Variable.

Warnungen zu nicht verwendeten sekundären Werten und Variablen können entfernt werden mit
-s/--no-unused-secondaries CLI-Option oder ungenutzte_sekundäre config-Option.

Beschatten Erklärungen
Luacheck erkennt Deklarationen lokaler Variablen, die vorherige Deklarationen überschatten, es sei denn
die Variable heißt _. Wenn die vorherige Erklärung den gleichen Geltungsbereich hat wie die neue,
es heißt neu definieren.

Beachten Sie, dass es nicht notwendig, um beim Überschreiben eines Arguments eine neue lokale Variable zu definieren:

lokale Funktion f(x)
local x = x oder "default" -- schlecht
Ende

lokale Funktion f(x)
x = x oder "Standard" -- gut
Ende

Kontrollieren Fluss und die Datenerfassung Fluss Probleme
Die folgenden Kontrollfluss- und Datenflussprobleme werden erkannt:

· Unerreichbarer Code und Schleifen, die höchstens einmal ausgeführt werden können (z. B. aufgrund eines
unbedingte Pause);

· Unbenutzte Etiketten;

· Unausgewogene Zuordnungen;

· Leere Blöcke.

· Leere Anweisungen (Semikolon ohne vorangehende Anweisungen).

COMMAND LINE INTERFACE

laucheck Programm akzeptiert Dateien, Verzeichnisse und Rockspecs als Argumente.

· Gegeben eine Datei, laucheck werde es prüfen.

· Gegeben -, laucheck wird stdin überprüfen.

· Gegeben ein Verzeichnis, laucheck überprüft alle darin enthaltenen Dateien und wählt nur Dateien mit . aus
.moon Verlängerung, es sei denn --include-Dateien Option verwendet wird. Diese Funktion erfordert
LuaFileSystem (wird automatisch installiert, wenn LuaRocks zur Installation von Luacheck verwendet wurde).

· Gegeben eine Rockspec (eine Datei mit .rockspec Verlängerung), laucheck überprüft alle Dateien mit
.moon Erweiterung in der Rockspec in . erwähnt build.install.lua, build.install.bin und
build.module Tabellen.

Die Ausgabe von laucheck besteht aus separaten Berichten für jede geprüfte Datei und endet mit a
Zusammenfassung:

$luacheck-Quelle
Überprüfung von src/bad_code.lua 5-Warnungen

src/bad_code.lua:3:16: unbenutzter Variablen-Helfer
src/bad_code.lua:3:23: unbenutztes Argument mit variabler Länge
src/bad_code.lua:7:10: Einstellung einer nicht standardmäßigen globalen Variablenumarmung
src/bad_code.lua:8:10: Variable opt wurde zuvor in Zeile 7 als Argument definiert
src/bad_code.lua:9:11: Zugriff auf undefinierte Variablen-Hepler

Überprüfung von src/good_code.lua OK
Überprüfung von src/python_code.lua 1 Fehler

src/python_code.lua:1:6: erwartetes '=' in der Nähe von '__future__'

Überprüfung der Warnungen von src/unused_code.lua 9

src/unused_code.lua:3:18: unbenutztes Argument baz
src/unused_code.lua:4:8: unbenutzte Schleifenvariable i
src/unused_code.lua:5:13: unbenutzte Variable q
src/unused_code.lua:7:11: unbenutzte Schleifenvariable a
src/unused_code.lua:7:14: unbenutzte Schleifenvariable b
src/unused_code.lua:7:17: unbenutzte Schleifenvariable c
src/unused_code.lua:13:7: der Variable x zugewiesener Wert ist unbenutzt
src/unused_code.lua:14:1: der Variable x zugewiesener Wert ist unbenutzt
src/unused_code.lua:22:1: der Variable z zugewiesener Wert wird nicht verwendet

Gesamt: 14 Warnungen / 1 Fehler in 4 Dateien

laucheck endet mit 0, wenn keine Warnungen oder Fehler aufgetreten sind und mit einer positiven Zahl
Andernfalls.

Befehl Linie Optionen
Kurze Optionen, die kein Argument annehmen, können zu einer kombiniert werden, so dass -qqu is
entspricht -q -q -u. Für lange Optionen beide --Möglichkeit Wert or --option=Wert kann sein
benutzt.

Optionen mit mehreren Argumenten können mehrmals verwendet werden; --ignorieren foo --ignorieren Bar is
entspricht --ignorieren foo Bar.

Beachten Sie, dass Optionen, die mehrere Argumente annehmen können, wie z --globals, sollte nicht benutzt werden
unmittelbar vor Positionsargumenten; gegeben --globals foo Bar Datei.lua, laucheck werden wir
bedenke alles foo, Bar und Datei.lua global und dann Panik, da keine Dateinamen mehr vorhanden sind.

┌─────────────────────────────────┬─────────────── ───────────────────┐
│Option │ Bedeutung │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-g | --no-global │ Warnungen zu . herausfiltern
│ │ globale Variablen. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-u | --keine-unbenutzt │ Warnungen zu . herausfiltern
│ │ nicht verwendete Variablen und Werte. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-r | --no-redefiniert │ Warnungen zu . herausfiltern
│ │ Variablen neu definiert. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-a | --no-unused-args │ Warnungen zu . herausfiltern
│ │ unbenutzte Argumente und Schleife │
│ │ Variablen. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-s | --no-unused-secondaries │ Warnungen zu . herausfiltern
│ │ nicht verwendete Variablen zusammen gesetzt │
│ │ mit gebrauchten. │
│ │ │
│ │ Siehe SekundärwerteundVariablen │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--kein-selbst │ Warnungen zu . herausfiltern
│ │ implizit selbst Streit. │
└─────────────────────────────────┴─────────────── ───────────────────┘

│--std │ Standard-Globals festlegen. kann
│ │ sei einer von: │
│ │ │
│ │ · _G - Globals der Lua │
│ │ Dolmetscher laucheck │
│ │ läuft weiter (Standard); │
│ │ │
│ │ · lua51 - Globals von Lua │
│ 5.1; │
│ │ │
│ │ · lua52 - Globals von Lua │
│ 5.2; │
│ │ │
│ │ · lua52c - Globals von Lua │
│ │ 5.2 kompiliert mit │
LUA_COMPAT_ALL; │
│ │ │
│ │ · lua53 - Globals von Lua │
│ 5.3; │
│ │ │
│ │ · lua53c - Globals von Lua │
│ │ 5.3 kompiliert mit │
│ LUA_COMPAT_5_2; │
│ │ │
│ │ · luajit - Globale von │
LuaJIT 2.0; │
│ │ │
│ │ · ngx_lua - Globale von │
│ │ Openresty │
│ │ lua-nginx-modul mit
LuaJIT 2.0; │
│ │ │
│ │ · Min. - Schnittpunkt von │
│ │ Globals von Lua 5.1, Lua │
│ 5.2 und LuaJIT 2.0; │
│ │ │
│ │ · max - Vereinigung der Globalen │
│ │ von Lua 5.1, Lua 5.2 und │
LuaJIT 2.0; │
│ │ │
│ │ · Busted - Globals hinzugefügt │
│ von Busted 2.0; │
│ │ │
│ │ · keine - kein Standard │
│ │ global. │
│ │ │
│ │ Siehe Sets of Standard │
│ │ globals │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--globals [ ] ... │ Fügen Sie benutzerdefinierte Globals über │ . hinzu
│ │ Standard. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--read-globals [ ] ... │ Fügen Sie schreibgeschützte Globals hinzu. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--new-globals [ ] ... │ Legen Sie benutzerdefinierte Globals fest. Entfernt
│ │ zuvor hinzugefügte benutzerdefinierte Globals. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--new-read-globals [ ] │ Festlegen von schreibgeschützten Globals. Entfernt
│... │ schreibgeschützte Globals hinzugefügt │
│ │ vorher. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-c | --kompat │ Äquivalent zu --std max. │.
└─────────────────────────────────┴─────────────── ───────────────────┘

│-d | --allow-definiert │ Erlaube das Definieren von Globals │
│ │ implizit durch Setzen. │
│ │ │
│ │ Siehe implizit definierte globales │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-t | --allow-definiert-top │ Erlaube das Definieren von Globals │
│ │ implizit durch Setzen in │
│ │ der oberste Bereich. │
│ │ │
│ │ Siehe implizit definierte globales │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-m | --Modul │ Sichtbarkeit von impliziten │ . einschränken
│ │ definierte Globals zu ihren Dateien. │
│ │ │
│ │ Siehe Module │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--ignorieren | -i [ ] │ Passende Warnungen herausfiltern │
│... │ Muster. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--aktivieren | -e [ ] │ Warnungen nicht herausfiltern │
│... │ passende Muster. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--nur | -o [ ] ... │ Warnungen herausfiltern, die nicht übereinstimmen │
│ │ Muster. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--no-inline │ Deaktivieren Sie die Inline-Optionen. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--config │ Pfad zur benutzerdefinierten Konfiguration │
│ │ Datei (Standard: .luacheckrc). │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--no-config │ Suchen Sie nicht nach benutzerdefinierten │
│ │ Konfigurationsdatei. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--Dateiname │ Verwenden Sie einen anderen Dateinamen in der Ausgabe,
│ │ zur Auswahl der Konfiguration │
│ │ überschreibt und für Datei │
│ │ Filterung. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--exclude-Dateien [ ] │ Überprüfen Sie keine Dateien, die mit │ . übereinstimmen
│... │ diese globbing Muster. │
│ │ Rekursive Globs wie **/*.lua │
│ │ werden unterstützt. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--include-Dateien [ ] │ Nicht übereinstimmende Dateien nicht überprüfen │
│... │ diese globbing Muster. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--Zwischenspeicher [ ] │ Pfad zur Cache-Datei. (Standard: │
│ │ .luacheckcache). Sehen Caching │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--no-cache │ Verwenden Sie keinen Cache. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-j | --Arbeitsplätze │ Überprüfen Dateien parallel. │
│ │ Benötigt Lua Lanes. │.
└─────────────────────────────────┴─────────────── ───────────────────┘

│--formatierer │ Verwenden Sie benutzerdefinierten Formatierer. │
│ │ muss ein Modul sein
│ │ Name oder einer der folgenden: │
│ │ │
│ │ · TAP - Alles testen │
│ │ Protokollformatierer; │
│ │ │
│ │ · JUnit - JUnit XML-Dateien
│ │ Formatierer; │
│ │ │
│ │ · Ebene - einfach
│ │ Warnung-pro-Zeile │
│ │ Formatierer; │
│ │ │
│ │ · Standard - Standard
│ │ Formatierer. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-q | --ruhig │ Berichtsausgabe für Dateien unterdrücken │
│ │ ohne Warnungen. │
│ │ │
│ │ · -qq - Ausgabe unterdrücken │
│ │ von Warnungen. │
│ │ │
│ │ · -qqq - Nur Ausgabe │
│ │ Zusammenfassung. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--codes │ Warncodes anzeigen. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--Bereiche │ Spaltenbereiche anzeigen, die sich auf . beziehen
│ │ zu Warnungen. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│--keine Farbe │ Die Ausgabe nicht einfärben. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-v | --Version │ Version von Luacheck und seinen anzeigen
│ │ Abhängigkeiten und Exit. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│-h | --help │ Hilfe anzeigen und beenden. │
└─────────────────────────────────┴─────────────── ───────────────────┘

Patterns
CLI-Optionen --ignorieren, --aktivieren und --nur und entsprechende Konfigurationsoptionen erlauben das Filtern
Warnungen mit Musterabgleich für Warncodes, Variablennamen oder beides. Wenn ein Muster
enthält einen Schrägstrich, der Teil vor dem Schrägstrich entspricht dem Warncode und der Teil nach dem Schrägstrich
Variablennamen. Andernfalls, wenn ein Muster einen Buchstaben oder einen Unterstrich enthält, stimmt es überein
Variablennamen. Andernfalls entspricht es dem Warncode. Z.B:

┌────────┬────────────────────────────────┐
│Muster │ Passende Warnungen │
├────────┼───────────────────────────────┤┤
│4.2 │ Shadowing-Deklarationen von │
│ │ Argumente oder deren Neudefinition. │
├────────┼───────────────────────────────┤┤
│.*_ │ Warnungen zu Variablen │
│ │ mit _ Suffix. │
├────────┼───────────────────────────────┤┤
│4.2/.*_ │ Shadowing-Deklarationen von │
│ │ Argumente mit _ Suffix oder │
│ │ sie neu zu definieren. │
└────────┴────────────────────────────────

Sofern nicht bereits verankert, werden Muster, die mit Variablennamen übereinstimmen, auf beiden Seiten verankert und
Muster, die Warncodes entsprechen, sind an ihren Anfängen verankert. Dadurch kann man
Warnungen nach Kategorie filtern (z. B. --nur 1 konzentriert laucheck zu globalen Warnungen).

Sets of Standard globals
CLI-Option --Std ermöglicht das Kombinieren der oben beschriebenen eingebauten Sets mit +. Beispielsweise,
--std max entspricht --std=lua51+lua52+lua53. Führendes Pluszeichen fügt neue Sets hinzu
Standard, anstatt ihn zu ersetzen. Zum Beispiel, --std + kaputt eignet sich zur Kontrolle
Testdateien, die verwenden Busted Rahmen testen. Benutzerdefinierte Sätze von Globals können definiert werden durch
mutierende globale Variable Std im Konfig. Siehe custom_stds

Formatierer
CLI-Option --formatierer ermöglicht die Auswahl eines benutzerdefinierten Formatierers für laucheck Ausgang. Ein Brauch
formatter ist ein Lua-Modul, das eine Funktion mit drei Argumenten zurückgibt: Bericht als zurückgegeben von
laucheck Modul (siehe Bericht), Array von Dateinamen und Optionstabelle. Optionen enthalten
Werte zugeordnet ruhig, Farbe, begrenzen, Codes, Bereiche und Formatierer Optionen in CLI oder
konfig. Die Formatter-Funktion muss einen String zurückgeben.

Caching
Wenn LuaFileSystem verfügbar ist, kann Luacheck Ergebnisse der Überprüfung von Dateien zwischenspeichern. Auf nachfolgende
Überprüfungen, nur Dateien, die sich seit der letzten Überprüfung geändert haben, werden erneut überprüft, Verbesserung
Laufzeit deutlich. Das Ändern von Optionen (z. B. Definieren zusätzlicher Globals) funktioniert nicht
Cache ungültig machen. Caching kann aktiviert werden mit --Zwischenspeicher Option oder Cache-Speicher Config
Möglichkeit. Verwenden von --Zwischenspeicher ohne Argument oder Einstellung Cache-Speicher Konfigurationsoption zu was immer dies auch sein sollte. Sets
.luacheckcache als Cache-Datei. Beachten Sie, dass --Zwischenspeicher muss jedes Mal verwendet werden laucheck is
laufen, nicht nur beim ersten Durchlauf.

Stabil Schnittstelle für Herausgeber Plugins und Werkzeuge
Die Befehlszeilenschnittstelle von Luacheck kann zwischen Nebenversionen wechseln. Ab 0.11.0
Version, die folgende Schnittstelle ist mindestens bis Version 1.0.0 garantiert und sollte sein
Wird von Tools verwendet, die Luacheck-Ausgaben verwenden, zB Editor-Plugins.

· Luacheck sollte aus dem Verzeichnis gestartet werden, das die geprüfte Datei enthält.

· Datei kann über stdin mit . übergeben werden - als Argument oder mit einer temporären Datei. Real
Dateiname sollte mit . übergeben werden --Dateiname .

· Es sollte ein einfacher Formatierer verwendet werden. Es gibt ein Problem (Warnung oder Fehler) pro Zeile aus.

· Um eine genaue Fehlerposition zu erhalten, --Bereiche Option verwendet werden kann. Jede Zeile beginnt mit real
Dateiname (übergeben mit --Dateiname), gefolgt von : : - :,
woher ist die Zeilennummer, bei der das Problem aufgetreten ist und - is
einschließlich Bereich von Token-Spalten, die sich auf das Problem beziehen. Die Nummerierung beginnt mit 1. Wenn
--Bereiche wird nicht verwendet, Endspalte und Bindestrich werden nicht gedruckt.

· Um Warn- und Fehlercodes zu erhalten, --codes Option verwendet werden kann. Für jede Zeile, Teilzeichenfolge
zwischen Klammern enthält einen dreistelligen Problemcode mit dem Präfix E für Fehler und W
für Warnungen. Das Fehlen eines solchen Teilstrings weist auf einen schwerwiegenden Fehler hin (zB E/A-Fehler).

· Der Rest der Zeile ist eine Warnmeldung.

Wenn Kompatibilität zu älteren Luacheck-Versionen gewünscht wird, Ausgabe von laucheck --help kann sein
verwendet, um seine Version zu erhalten. Wenn es eine Zeichenfolge enthält 0. ., Wobei ist
mindestens 11 und Flicken eine beliebige Zahl ist, sollte die oben beschriebene Schnittstelle verwendet werden.

CONFIGURATION FILE

laucheck versucht, die Konfiguration von . zu laden .luacheckrc Datei im aktuellen Verzeichnis. Wenn
nicht gefunden wird, wird im übergeordneten Verzeichnis danach gesucht und so weiter, bis es
erreicht das Dateisystem-Root. Pfad zur Konfiguration kann eingestellt werden mit --config Option, in welchem ​​Fall
es wird beim rekursiven Laden verwendet. Das Laden der Config kann deaktiviert werden mit --no-config
Flagge.

Config ist einfach ein Lua-Skript, das von . ausgeführt wird laucheck. Es kann verschiedene Optionen einstellen, indem
Zuweisen zu Globals oder durch Zurückgeben einer Tabelle mit Optionsnamen als Schlüssel.

Config Optionen
┌───────────────────┬──────────────────────────┬── ───────────────────┐
│Option │ Typ │ Standardwert │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Farbe │ Boolesches was immer dies auch sein sollte. │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Codes │ Boolesches falsch │
└───────────────────┴──────────────────────────┴── ───────────────────┘

│Formatierer │ String oder Funktion │ "Default" │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Cache-Speicher │ Boolean oder String │ falsch │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Jobs & Karriere │ Positive ganze Zahl │ 1 │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Ausschluss_Dateien │ String-Array │ {} │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│include_files │ String-Array │ (Alle Dateien einschließen) │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│globale │ Boolesches was immer dies auch sein sollte. │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│ungenutzt │ Boolesches was immer dies auch sein sollte. │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│neu definiert │ Boolesches was immer dies auch sein sollte. │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│ungenutzte_args │ Boolesches was immer dies auch sein sollte. │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│ungenutzte_sekundäre │ Boolesches was immer dies auch sein sollte. │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│selbst │ Boolesches was immer dies auch sein sollte. │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│std │ String oder Satz von │ "_G" │
│ │ Standard-Globals │ │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│globals │ String-Array │ {} │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│neue_globals │ String-Array │ (Nicht überschreiben) │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│read_globals │ String-Array │ {} │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│new_read_globals │ String-Array │ (Nicht überschreiben) │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Comp │ Boolesches falsch │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│erlauben_definiert │ Boolesches falsch │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│erlauben_definiert_top │ Boolesches falsch │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Modulen │ Boolesches falsch │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│ignorieren │ Musteranordnung (siehe │ {} │
│ │ Muster) │ │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│ermöglichen │ Musterreihe │ {} │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│einzige │ Musteranordnung │ (Nicht filtern) │
├───────────────────┼──────────────────────────┼── ───────────────────┤
│Inline- │ Boolesches was immer dies auch sein sollte. │
└───────────────────┴──────────────────────────┴── ───────────────────┘

Ein Beispiel für eine Konfiguration, die laucheck Stellen Sie sicher, dass nur Globals vom tragbaren
Kreuzung von Lua 5.1, Lua 5.2, Lua 5.3 und LuaJIT 2.0 verwendet, sowie deaktiviert
Erkennung nicht verwendeter Argumente:

std = "min"
ignorieren = {"212"}

Maßgeschneidert Sets of globals
std Option ermöglicht das Festlegen eines benutzerdefinierten Standardsatzes von Globals mithilfe einer Tabelle. In dieser Tabelle,
String-Schlüssel sind Globals und String im Array-Teil sind schreibgeschützte Globals.

Darüber hinaus können benutzerdefinierten Sets Namen gegeben werden, indem global . mutiert wird Std Variable. Zum
Beispiel bei der Verwendung LPEG Bibliothek ist es sinnvoll, auf deren Funktionen knapp über zuzugreifen
Globale. In diesem Fall ermöglicht die folgende Konfiguration das Entfernen falsch positiver Ergebnisse im Zusammenhang mit
globaler Zugriff einfach:

stds.lpeg = "lpeg" benötigen

local lpeg = "lpeg" erforderlich

lokale Funktion parse1(...)
-- Diese Funktion verwendet nur lpeg-Funktionen als Globals.
lokale _ENV = lpeg
-- luacheck: std-lpeg
lokale Ziffer, Leerzeichen = R "09", S " "
- ...
Ende

lokale Funktion parse2(...)
-- Diese Funktion verwendet lpeg-Funktionen sowie Standard-Globals.
local _ENV = setmetatable({}, {__index = function(_, k) return _ENV[k] oder lpeg[k] end})
-- luacheck: std +lpeg
lokale Ziffer, Leerzeichen = R "09", S " "
lokale Nummer = C(Ziffer^1) / bisNummer
- ...
Ende

Pro Datei und pro Pfad Überschreibungen
Die Umgebung, in der laucheck lädt die config enthält ein spezielles globales Dateien. Wenn
eine Datei überprüfen , laucheck überschreibt Optionen aus der Hauptkonfiguration mit Einträgen
von Dateien[ ] und Dateien[ ], indem Sie zuerst Einträge für kürzere Pfade anwenden. Zum
Beispiel: Die folgende Konfiguration aktiviert die Erkennung nicht verwendeter Argumente nur für Dateien in
Quelle/Verz, aber nicht für src/dir/meinedatei.lua, und ermöglicht die Verwendung Busted Globale innerhalb spec /:

std = "min"
ignorieren = {"212"}
files["src/dir"] = {enable = {"212"}}
files["src/dir/myfile.lua"] = {ignore = {"212"}}
files["spec"] = {std = "+busted"}

Beachten Sie, dass Dateien Tabelle unterstützt Autovivifizierung, so dass

files["myfile.lua"].ignore = {"212"}

und

files["myfile.lua"] = {ignore = {"212"}}

sind gleichwertig.

IN DER REIHE OPTIONAL

Luacheck unterstützt das Setzen einiger Optionen direkt in den geprüften Dateien mit Inline
Konfigurationskommentare. Ein Kommentar zur Inline-Konfiguration beginnt mit laucheck: Etikette,
möglicherweise nach einigen Leerzeichen. Der Text des Kommentars sollte durch Kommas getrennt sein
Optionen, wobei der Optionsaufruf aus ihrem Namen plus durch Leerzeichen getrennten Argumenten besteht. Die
Folgende Optionen werden unterstützt:

┌───────────────────┬───────────────────────────── ─────┐
│Option │ Anzahl der Argumente │
├───────────────────┼───────────────────────────── ─────┤
│global │ 0 │
├───────────────────┼───────────────────────────── ─────┤
│unbenutzt │ 0 │
├───────────────────┼───────────────────────────── ─────┤
│neu definiert │ 0 │
├───────────────────┼───────────────────────────── ─────┤
│unbenutzte Argumente │ 0 │
├───────────────────┼───────────────────────────── ─────┤
│unbenutzte Sekundärteile │ 0 │
├───────────────────┼───────────────────────────── ─────┤
selbst │ 0 │
└───────────────────┴───────────────────────────── ─────┘

│kompat │ 0 │
├───────────────────┼───────────────────────────── ─────┤
│Modul │ 0 │
├───────────────────┼───────────────────────────── ─────┤
│definiert zulassen │ 0 │
├───────────────────┼───────────────────────────── ─────┤
│definierte Spitze zulassen │ 0 │
├───────────────────┼───────────────────────────── ─────┤
std │ 1 │
├───────────────────┼───────────────────────────── ─────┤
│Globale │ 0+ │
├───────────────────┼───────────────────────────── ─────┤
│neue Globale │ 0+ │
├───────────────────┼───────────────────────────── ─────┤
│Globale lesen │ 0+ │
├───────────────────┼───────────────────────────── ─────┤
│Neue Lese-Globals │ 0+ │
├───────────────────┼───────────────────────────── ─────┤
│ignore │ 0+ (ohne Argumente alles │
│ │ wird ignoriert) │
├───────────────────┼───────────────────────────── ─────┤
│aktivieren │ 1+ │
├───────────────────┼───────────────────────────── ─────┤
│nur │ 1+ │
└───────────────────┴───────────────────────────── ─────┘

Optionen, die keine Argumente annehmen, können mit vorangestellt werden nicht ihre Bedeutung umzukehren. Z.B
--luacheck: nicht ungenutzt args deaktiviert Warnungen über nicht verwendete Argumente.

Ein Teil der Datei, der von der Inline-Option betroffen ist, hängt davon ab, wo er platziert ist. Wenn da etwas ist
Code in der Zeile mit der Option, nur diese Zeile ist betroffen; ansonsten alles bis
das Ende der aktuellen Schließung ist. Insbesondere Inline-Optionen am Anfang der Datei
alles beeinflussen:

-- luacheck: globals g1 g2, ignoriere foo
local foo = g1(g2) -- Keine Warnungen ausgegeben.

-- Die folgende nicht verwendete Funktion wird nicht gemeldet.
lokale Funktion f() -- luacheck: ignorieren
-- luacheck: Globals g3
g3() -- Keine Warnung.
Ende

g3() -- Warnung wird als Inline-Option ausgegeben, die definiert, dass g3 nur die Funktion f betrifft.

Für eine feinkörnige Kontrolle über die Sichtbarkeit von Inline-Optionen verwenden Sie laucheck: drücken und laucheck:
Pop Richtlinien:

-- luacheck: Push ignorieren foo
foo() -- Keine Warnung.
-- luacheck: Pop
foo() -- Warnung wird ausgegeben.

Inline-Optionen können vollständig deaktiviert werden mit --no-inline CLI-Option oder Inline- Config
.

LUACHECK MODULE

Wasser aus einer regionalen laucheck = erfordern "luacheck" importieren laucheck Modul. Es enthält die
folgende Funktionen:

· luacheck.get_report(Quelle): Gegebener Quellstring, gibt Analysedaten (eine Tabelle) zurück.

· luacheck.process_reports(Berichte, Optionen): Verarbeitet eine Reihe von Analyseberichten und
wendet Optionen an. Berichte[i] verwendet Optionen, Optionen[i], Optionen[i][1], Optionen[i][2]...
als Optionen, die sich in dieser Reihenfolge gegenseitig überschreiben. Optionstabelle ist eine Tabelle mit Feldern
ähnlich wie Konfigurationsoptionen; siehe Optionen. Analyseberichte mit Feld tödlich werden ignoriert.
Prozessberichte gibt den Abschlussbericht zurück, siehe Profil melden Format.

· luacheck.check_strings(Quellen, Optionen): Überprüft das Array von Quellen mit Optionen, gibt zurück
Abschlussbericht. Tabellen mit Feld tödlich . Quellen Array werden ignoriert.

· luacheck.check_files(Dateien, Optionen): Überprüft das Array von Dateien mit Optionen und gibt final zurück
Prüfbericht. Offene Datei-Handles können anstelle von Dateinamen übergeben werden, in diesem Fall werden sie
bis EOF gelesen und geschlossen.

· luacheck.get_message(Problem): Gibt eine Zeichenfolgennachricht für ein Problem zurück, siehe Profil melden Format.

luacheck._VERSION enthält Luacheck-Version als String in MAJOR.MINOR.PATCH Format.

Die richtigen laucheck als Funktion ist äquivalent zum Aufrufen luacheck.check_files.

Profil melden Format
Ein Abschlussbericht besteht aus einer Reihe von Dateiberichten plus Feldern Warnungen, Fehler und tödlich
die die Gesamtzahl der Warnungen, Fehler und schwerwiegenden Fehler enthält.

Ein Dateibericht ist eine Reihe von Problemen (Warnungen oder Fehler). Wenn ein schwerwiegender Fehler aufgetreten ist, während
Wenn Sie eine Datei überprüfen, wird der Bericht Folgendes haben: tödlich Feld, das den Fehlertyp enthält.

Ein Problem ist eine Tabelle mit Feld Code Angabe des Typs (siehe Warnungen) und Felder Linie,
Überblick und Endspalte auf die Quelle der Warnung hinweisen. Name Feld kann Namen enthalten
der Beziehungsvariable. Ausgaben einiger Typen können auch zusätzliche Felder enthalten:

┌──────┬─────────────────────────────────┐
│Codes │ Zusätzliche Felder │
├──────┼─────────────────────────────────┤┤
│011 │ msg Feld enthält Syntaxfehler │
│ │ Nachricht. │
├──────┼─────────────────────────────────┤┤
│111 │ Modulen Feld zeigt an, dass │
│ │ Zuordnung ist zu einem Nicht-Modul │
│ │ globale Variable. │
├──────┼─────────────────────────────────┤┤
│211 │ Funkt Feld zeigt an, dass unbenutzt │
│ │ Variable ist eine Funktion. │
├──────┼─────────────────────────────────┤┤
│4.. │ prev_line und Vorherige_Spalte Felder
│ │ enthalten die Position der │
│ │ überschriebene Definition. │
└──────┴─────────────────────────────────

Andere Felder können aus internen Gründen vorhanden sein.

Dies ist die Dokumentation für die Version 0.13.0 von Luacheck, ein Linter für Lua.

Verwenden Sie luacheck online mit den onworks.net-Diensten